Lines Matching defs:ftdi
97 * require more than a couple of elan-ftdi devices, 8 seems
195 struct usb_ftdi *ftdi = kref_to_usb_ftdi(kref);
196 dev_warn(&ftdi->udev->dev, "FREEING ftdi=%p\n", ftdi);
197 usb_put_dev(ftdi->udev);
198 ftdi->disconnected += 1;
200 list_del_init(&ftdi->ftdi_list);
203 kfree(ftdi->bulk_in_buffer);
204 ftdi->bulk_in_buffer = NULL;
205 kfree(ftdi);
208 static void ftdi_elan_put_kref(struct usb_ftdi *ftdi)
210 kref_put(&ftdi->kref, ftdi_elan_delete);
213 static void ftdi_elan_get_kref(struct usb_ftdi *ftdi)
215 kref_get(&ftdi->kref);
218 static void ftdi_elan_init_kref(struct usb_ftdi *ftdi)
220 kref_init(&ftdi->kref);
223 static void ftdi_status_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
225 if (!schedule_delayed_work(&ftdi->status_work, delta))
226 kref_put(&ftdi->kref, ftdi_elan_delete);
229 static void ftdi_status_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
231 if (schedule_delayed_work(&ftdi->status_work, delta))
232 kref_get(&ftdi->kref);
235 static void ftdi_status_cancel_work(struct usb_ftdi *ftdi)
237 if (cancel_delayed_work_sync(&ftdi->status_work))
238 kref_put(&ftdi->kref, ftdi_elan_delete);
241 static void ftdi_command_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
243 if (!schedule_delayed_work(&ftdi->command_work, delta))
244 kref_put(&ftdi->kref, ftdi_elan_delete);
247 static void ftdi_command_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
249 if (schedule_delayed_work(&ftdi->command_work, delta))
250 kref_get(&ftdi->kref);
253 static void ftdi_command_cancel_work(struct usb_ftdi *ftdi)
255 if (cancel_delayed_work_sync(&ftdi->command_work))
256 kref_put(&ftdi->kref, ftdi_elan_delete);
259 static void ftdi_response_requeue_work(struct usb_ftdi *ftdi,
262 if (!schedule_delayed_work(&ftdi->respond_work, delta))
263 kref_put(&ftdi->kref, ftdi_elan_delete);
266 static void ftdi_respond_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
268 if (schedule_delayed_work(&ftdi->respond_work, delta))
269 kref_get(&ftdi->kref);
272 static void ftdi_response_cancel_work(struct usb_ftdi *ftdi)
274 if (cancel_delayed_work_sync(&ftdi->respond_work))
275 kref_put(&ftdi->kref, ftdi_elan_delete);
280 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
281 ftdi->gone_away += 1;
282 ftdi_elan_put_kref(ftdi);
292 static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
294 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi);
295 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi);
296 static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi);
297 static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi);
298 static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi);
299 static int ftdi_elan_synchronize(struct usb_ftdi *ftdi);
300 static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi);
301 static int ftdi_elan_command_engine(struct usb_ftdi *ftdi);
302 static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi);
303 static int ftdi_elan_hcd_init(struct usb_ftdi *ftdi)
305 if (ftdi->platform_dev.dev.parent)
308 ftdi_elan_get_kref(ftdi);
309 ftdi->platform_data.potpg = 100;
310 ftdi->platform_data.reset = NULL;
311 ftdi->platform_dev.id = ftdi->sequence_num;
312 ftdi->platform_dev.resource = ftdi->resources;
313 ftdi->platform_dev.num_resources = ARRAY_SIZE(ftdi->resources);
314 ftdi->platform_dev.dev.platform_data = &ftdi->platform_data;
315 ftdi->platform_dev.dev.parent = NULL;
316 ftdi->platform_dev.dev.release = ftdi_release_platform_dev;
317 ftdi->platform_dev.dev.dma_mask = NULL;
318 snprintf(ftdi->device_name, sizeof(ftdi->device_name), "u132_hcd");
319 ftdi->platform_dev.name = ftdi->device_name;
320 dev_info(&ftdi->udev->dev, "requesting module '%s'\n", "u132_hcd");
322 dev_info(&ftdi->udev->dev, "registering '%s'\n",
323 ftdi->platform_dev.name);
325 return platform_device_register(&ftdi->platform_dev);
328 static void ftdi_elan_abandon_completions(struct usb_ftdi *ftdi)
330 mutex_lock(&ftdi->u132_lock);
331 while (ftdi->respond_next > ftdi->respond_head) {
332 struct u132_respond *respond = &ftdi->respond[RESPOND_MASK &
333 ftdi->respond_head++];
338 mutex_unlock(&ftdi->u132_lock);
341 static void ftdi_elan_abandon_targets(struct usb_ftdi *ftdi)
344 mutex_lock(&ftdi->u132_lock);
346 struct u132_target *target = &ftdi->target[ed_number];
349 mutex_unlock(&ftdi->u132_lock);
350 ftdi_elan_do_callback(ftdi, target, NULL, 0);
351 mutex_lock(&ftdi->u132_lock);
354 ftdi->received = 0;
355 ftdi->expected = 4;
356 ftdi->ed_found = 0;
357 mutex_unlock(&ftdi->u132_lock);
360 static void ftdi_elan_flush_targets(struct usb_ftdi *ftdi)
363 mutex_lock(&ftdi->u132_lock);
365 struct u132_target *target = &ftdi->target[ed_number];
368 int command_size = ftdi->command_next -
369 ftdi->command_head;
371 struct u132_command *command = &ftdi->command[
372 COMMAND_MASK & ftdi->command_next];
380 ftdi->command_next += 1;
381 ftdi_elan_kick_command_queue(ftdi);
383 mutex_unlock(&ftdi->u132_lock);
385 mutex_lock(&ftdi->u132_lock);
390 int command_size = ftdi->command_next -
391 ftdi->command_head;
393 struct u132_command *command = &ftdi->command[
394 COMMAND_MASK & ftdi->command_next];
402 ftdi->command_next += 1;
403 ftdi_elan_kick_command_queue(ftdi);
405 mutex_unlock(&ftdi->u132_lock);
407 mutex_lock(&ftdi->u132_lock);
412 ftdi->received = 0;
413 ftdi->expected = 4;
414 ftdi->ed_found = 0;
415 mutex_unlock(&ftdi->u132_lock);
418 static void ftdi_elan_cancel_targets(struct usb_ftdi *ftdi)
421 mutex_lock(&ftdi->u132_lock);
423 struct u132_target *target = &ftdi->target[ed_number];
426 int command_size = ftdi->command_next -
427 ftdi->command_head;
429 struct u132_command *command = &ftdi->command[
430 COMMAND_MASK & ftdi->command_next];
438 ftdi->command_next += 1;
439 ftdi_elan_kick_command_queue(ftdi);
441 mutex_unlock(&ftdi->u132_lock);
443 mutex_lock(&ftdi->u132_lock);
448 ftdi->received = 0;
449 ftdi->expected = 4;
450 ftdi->ed_found = 0;
451 mutex_unlock(&ftdi->u132_lock);
454 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi)
456 ftdi_command_queue_work(ftdi, 0);
461 struct usb_ftdi *ftdi =
464 if (ftdi->disconnected > 0) {
465 ftdi_elan_put_kref(ftdi);
468 int retval = ftdi_elan_command_engine(ftdi);
470 ftdi->disconnected += 1;
472 ftdi->disconnected += 1;
474 dev_err(&ftdi->udev->dev, "command error %d\n", retval);
475 ftdi_command_requeue_work(ftdi, msecs_to_jiffies(10));
480 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi)
482 ftdi_respond_queue_work(ftdi, 0);
487 struct usb_ftdi *ftdi =
489 if (ftdi->disconnected > 0) {
490 ftdi_elan_put_kref(ftdi);
493 int retval = ftdi_elan_respond_engine(ftdi);
496 ftdi->disconnected += 1;
498 ftdi->disconnected += 1;
500 ftdi->disconnected += 1;
502 ftdi->disconnected += 1;
503 dev_err(&ftdi->udev->dev, "respond error %d\n", retval);
505 if (ftdi->disconnected > 0) {
506 ftdi_elan_abandon_completions(ftdi);
507 ftdi_elan_abandon_targets(ftdi);
509 ftdi_response_requeue_work(ftdi, msecs_to_jiffies(10));
522 struct usb_ftdi *ftdi =
525 if (ftdi->disconnected > 0) {
526 ftdi_elan_put_kref(ftdi);
528 } else if (ftdi->synchronized == 0) {
529 down(&ftdi->sw_lock);
530 if (ftdi_elan_synchronize(ftdi) == 0) {
531 ftdi->synchronized = 1;
532 ftdi_command_queue_work(ftdi, 1);
533 ftdi_respond_queue_work(ftdi, 1);
534 up(&ftdi->sw_lock);
537 dev_err(&ftdi->udev->dev, "synchronize failed\n");
538 up(&ftdi->sw_lock);
541 } else if (ftdi->stuck_status > 0) {
542 if (ftdi_elan_stuck_waiting(ftdi) == 0) {
543 ftdi->stuck_status = 0;
544 ftdi->synchronized = 0;
545 } else if ((ftdi->stuck_status++ % 60) == 1) {
546 dev_err(&ftdi->udev->dev, "WRONG type of card inserted - please remove\n");
548 dev_err(&ftdi->udev->dev, "WRONG type of card inserted - checked %d times\n",
549 ftdi->stuck_status);
551 } else if (ftdi->enumerated == 0) {
552 if (ftdi_elan_enumeratePCI(ftdi) == 0) {
553 ftdi->enumerated = 1;
557 } else if (ftdi->initialized == 0) {
558 if (ftdi_elan_setupOHCI(ftdi) == 0) {
559 ftdi->initialized = 1;
562 dev_err(&ftdi->udev->dev, "initialized failed - trying again in 10 seconds\n");
565 } else if (ftdi->registered == 0) {
567 if (ftdi_elan_hcd_init(ftdi) == 0) {
568 ftdi->registered = 1;
570 dev_err(&ftdi->udev->dev, "register failed\n");
573 if (ftdi_elan_checkingPCI(ftdi) == 0) {
575 } else if (ftdi->controlreg & 0x00400000) {
576 if (ftdi->gone_away > 0) {
577 dev_err(&ftdi->udev->dev, "PCI device eject confirmed platform_dev.dev.parent=%p platform_dev.dev=%p\n",
578 ftdi->platform_dev.dev.parent,
579 &ftdi->platform_dev.dev);
580 platform_device_unregister(&ftdi->platform_dev);
581 ftdi->platform_dev.dev.parent = NULL;
582 ftdi->registered = 0;
583 ftdi->enumerated = 0;
584 ftdi->card_ejected = 0;
585 ftdi->initialized = 0;
586 ftdi->gone_away = 0;
588 ftdi_elan_flush_targets(ftdi);
591 dev_err(&ftdi->udev->dev, "PCI device has disappeared\n");
592 ftdi_elan_cancel_targets(ftdi);
594 ftdi->enumerated = 0;
595 ftdi->initialized = 0;
598 if (ftdi->disconnected > 0) {
599 ftdi_elan_put_kref(ftdi);
602 ftdi_status_requeue_work(ftdi,
627 struct usb_ftdi *ftdi = usb_get_intfdata(interface);
628 if (!ftdi) {
631 if (down_interruptible(&ftdi->sw_lock)) {
634 ftdi_elan_get_kref(ftdi);
635 file->private_data = ftdi;
644 struct usb_ftdi *ftdi = file->private_data;
645 if (ftdi == NULL)
647 up(&ftdi->sw_lock); /* decrement the count on our device */
648 ftdi_elan_put_kref(ftdi);
667 struct usb_ftdi *ftdi = file->private_data;
668 if (ftdi->disconnected > 0) {
672 have:if (ftdi->bulk_in_left > 0) {
674 char *p = ++ftdi->bulk_in_last + ftdi->bulk_in_buffer;
675 ftdi->bulk_in_left -= 1;
692 int retval = usb_bulk_msg(ftdi->udev,
693 usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
694 ftdi->bulk_in_buffer, ftdi->bulk_in_size,
697 ftdi->bulk_in_left = packet_bytes - 2;
698 ftdi->bulk_in_last = 1;
720 struct usb_ftdi *ftdi = urb->context;
725 dev_err(&ftdi->udev->dev,
732 static int fill_buffer_with_all_queued_commands(struct usb_ftdi *ftdi,
738 int i = ftdi->command_head;
740 struct u132_command *command = &ftdi->command[COMMAND_MASK &
759 static int ftdi_elan_total_command_size(struct usb_ftdi *ftdi, int command_size)
763 int i = ftdi->command_head;
765 struct u132_command *command = &ftdi->command[COMMAND_MASK &
772 static int ftdi_elan_command_engine(struct usb_ftdi *ftdi)
779 int command_size = ftdi->command_next - ftdi->command_head;
782 total_size = ftdi_elan_total_command_size(ftdi, command_size);
786 buf = usb_alloc_coherent(ftdi->udev, total_size, GFP_KERNEL,
789 dev_err(&ftdi->udev->dev, "could not get a buffer to write %d commands totaling %d bytes to the Uxxx\n",
794 ed_commands = fill_buffer_with_all_queued_commands(ftdi, buf,
796 usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
797 ftdi->bulk_out_endpointAddr), buf, total_size,
798 ftdi_elan_write_bulk_callback, ftdi);
816 dev_err(&ftdi->udev->dev, "failed %d to submit urb %p to write %d commands totaling %d bytes to the Uxxx\n",
818 usb_free_coherent(ftdi->udev, total_size, buf, urb->transfer_dma);
824 ftdi->command_head += command_size;
825 ftdi_elan_kick_respond_queue(ftdi);
829 static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
850 static char *have_ed_set_response(struct usb_ftdi *ftdi,
855 mutex_lock(&ftdi->u132_lock);
862 mutex_unlock(&ftdi->u132_lock);
863 ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
865 ftdi->received = 0;
866 ftdi->expected = 4;
867 ftdi->ed_found = 0;
868 return ftdi->response;
870 ftdi->expected = 4 + payload;
871 ftdi->ed_found = 1;
872 mutex_unlock(&ftdi->u132_lock);
877 mutex_unlock(&ftdi->u132_lock);
878 ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
880 ftdi->received = 0;
881 ftdi->expected = 4;
882 ftdi->ed_found = 0;
883 return ftdi->response;
887 static char *have_ed_get_response(struct usb_ftdi *ftdi,
891 mutex_lock(&ftdi->u132_lock);
896 mutex_unlock(&ftdi->u132_lock);
898 ftdi_elan_do_callback(ftdi, target, NULL, 0);
900 ftdi->received = 0;
901 ftdi->expected = 4;
902 ftdi->ed_found = 0;
903 return ftdi->response;
915 static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi)
917 u8 *b = ftdi->response + ftdi->received;
923 int retval = usb_bulk_msg(ftdi->udev,
924 usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
925 ftdi->bulk_in_buffer, ftdi->bulk_in_size,
930 u8 *c = ftdi->bulk_in_buffer;
940 ftdi->bulk_in_left = packet_bytes - 2;
941 ftdi->bulk_in_last = 1;
945 dev_err(&ftdi->udev->dev, "TIMED OUT with packet_bytes = %d with total %d bytes%s\n",
949 dev_err(&ftdi->udev->dev, "ONLY %d bytes%s\n",
953 dev_err(&ftdi->udev->dev, "TIMED OUT with packet_bytes = %d with total %d bytes%s\n",
958 dev_err(&ftdi->udev->dev, "error = %d with packet_bytes = %d with total %d bytes%s\n",
962 dev_err(&ftdi->udev->dev, "error = %d with packet_bytes = %d with total %d bytes%s\n",
975 have:if (ftdi->bulk_in_left > 0) {
976 u8 c = ftdi->bulk_in_buffer[++ftdi->bulk_in_last];
978 ftdi->bulk_in_left -= 1;
979 if (ftdi->received == 0 && c == 0xFF) {
983 if (++ftdi->received < ftdi->expected) {
985 } else if (ftdi->ed_found) {
986 int ed_number = (ftdi->response[0] >> 5) & 0x03;
987 u16 ed_length = (ftdi->response[2] << 8) |
988 ftdi->response[1];
989 struct u132_target *target = &ftdi->target[ed_number];
994 u8 *c = 4 + ftdi->response;
1003 ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
1005 ftdi->received = 0;
1006 ftdi->expected = 4;
1007 ftdi->ed_found = 0;
1008 b = ftdi->response;
1010 } else if (ftdi->expected == 8) {
1012 int respond_head = ftdi->respond_head++;
1013 struct u132_respond *respond = &ftdi->respond[
1015 u32 data = ftdi->response[7];
1017 data |= ftdi->response[6];
1019 data |= ftdi->response[5];
1021 data |= ftdi->response[4];
1025 ftdi->received = 0;
1026 ftdi->expected = 4;
1027 ftdi->ed_found = 0;
1028 b = ftdi->response;
1029 buscmd = (ftdi->response[0] >> 0) & 0x0F;
1035 dev_err(&ftdi->udev->dev, "Uxxx unknown(%0X) value = %08X\n",
1039 if ((ftdi->response[0] & 0x80) == 0x00) {
1040 ftdi->expected = 8;
1043 int ed_number = (ftdi->response[0] >> 5) & 0x03;
1044 int ed_type = (ftdi->response[0] >> 0) & 0x03;
1045 u16 ed_length = (ftdi->response[2] << 8) |
1046 ftdi->response[1];
1047 struct u132_target *target = &ftdi->target[
1049 target->halted = (ftdi->response[0] >> 3) &
1051 target->skipped = (ftdi->response[0] >> 2) &
1053 target->toggle_bits = (ftdi->response[3] >> 6)
1055 target->error_count = (ftdi->response[3] >> 4)
1057 target->condition_code = (ftdi->response[
1059 if ((ftdi->response[0] & 0x10) == 0x00) {
1060 b = have_ed_set_response(ftdi, target,
1065 b = have_ed_get_response(ftdi, target,
1088 struct usb_ftdi *ftdi = file->private_data;
1090 if (ftdi->disconnected > 0) {
1101 buf = usb_alloc_coherent(ftdi->udev, count, GFP_KERNEL,
1111 usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
1112 ftdi->bulk_out_endpointAddr), buf, count,
1113 ftdi_elan_write_bulk_callback, ftdi);
1117 dev_err(&ftdi->udev->dev,
1126 usb_free_coherent(ftdi->udev, count, buf, urb->transfer_dma);
1147 .name = "ftdi-%d-jtag",
1185 static int ftdi_elan_write_reg(struct usb_ftdi *ftdi, u32 data)
1187 wait:if (ftdi->disconnected > 0) {
1191 mutex_lock(&ftdi->u132_lock);
1192 command_size = ftdi->command_next - ftdi->command_head;
1194 struct u132_command *command = &ftdi->command[
1195 COMMAND_MASK & ftdi->command_next];
1203 ftdi->command_next += 1;
1204 ftdi_elan_kick_command_queue(ftdi);
1205 mutex_unlock(&ftdi->u132_lock);
1208 mutex_unlock(&ftdi->u132_lock);
1215 static int ftdi_elan_write_config(struct usb_ftdi *ftdi, int config_offset,
1219 wait:if (ftdi->disconnected > 0) {
1223 mutex_lock(&ftdi->u132_lock);
1224 command_size = ftdi->command_next - ftdi->command_head;
1226 struct u132_command *command = &ftdi->command[
1227 COMMAND_MASK & ftdi->command_next];
1235 ftdi->command_next += 1;
1236 ftdi_elan_kick_command_queue(ftdi);
1237 mutex_unlock(&ftdi->u132_lock);
1240 mutex_unlock(&ftdi->u132_lock);
1247 static int ftdi_elan_write_pcimem(struct usb_ftdi *ftdi, int mem_offset,
1251 wait:if (ftdi->disconnected > 0) {
1255 mutex_lock(&ftdi->u132_lock);
1256 command_size = ftdi->command_next - ftdi->command_head;
1258 struct u132_command *command = &ftdi->command[
1259 COMMAND_MASK & ftdi->command_next];
1267 ftdi->command_next += 1;
1268 ftdi_elan_kick_command_queue(ftdi);
1269 mutex_unlock(&ftdi->u132_lock);
1272 mutex_unlock(&ftdi->u132_lock);
1282 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1283 return ftdi_elan_write_pcimem(ftdi, mem_offset, width, data);
1288 static int ftdi_elan_read_reg(struct usb_ftdi *ftdi, u32 *data)
1290 wait:if (ftdi->disconnected > 0) {
1295 mutex_lock(&ftdi->u132_lock);
1296 command_size = ftdi->command_next - ftdi->command_head;
1297 respond_size = ftdi->respond_next - ftdi->respond_head;
1300 struct u132_command *command = &ftdi->command[
1301 COMMAND_MASK & ftdi->command_next];
1302 struct u132_respond *respond = &ftdi->respond[
1303 RESPOND_MASK & ftdi->respond_next];
1315 ftdi->command_next += 1;
1316 ftdi->respond_next += 1;
1317 ftdi_elan_kick_command_queue(ftdi);
1318 mutex_unlock(&ftdi->u132_lock);
1322 mutex_unlock(&ftdi->u132_lock);
1329 static int ftdi_elan_read_config(struct usb_ftdi *ftdi, int config_offset,
1333 wait:if (ftdi->disconnected > 0) {
1338 mutex_lock(&ftdi->u132_lock);
1339 command_size = ftdi->command_next - ftdi->command_head;
1340 respond_size = ftdi->respond_next - ftdi->respond_head;
1343 struct u132_command *command = &ftdi->command[
1344 COMMAND_MASK & ftdi->command_next];
1345 struct u132_respond *respond = &ftdi->respond[
1346 RESPOND_MASK & ftdi->respond_next];
1359 ftdi->command_next += 1;
1360 ftdi->respond_next += 1;
1361 ftdi_elan_kick_command_queue(ftdi);
1362 mutex_unlock(&ftdi->u132_lock);
1366 mutex_unlock(&ftdi->u132_lock);
1373 static int ftdi_elan_read_pcimem(struct usb_ftdi *ftdi, int mem_offset,
1377 wait:if (ftdi->disconnected > 0) {
1382 mutex_lock(&ftdi->u132_lock);
1383 command_size = ftdi->command_next - ftdi->command_head;
1384 respond_size = ftdi->respond_next - ftdi->respond_head;
1387 struct u132_command *command = &ftdi->command[
1388 COMMAND_MASK & ftdi->command_next];
1389 struct u132_respond *respond = &ftdi->respond[
1390 RESPOND_MASK & ftdi->respond_next];
1403 ftdi->command_next += 1;
1404 ftdi->respond_next += 1;
1405 ftdi_elan_kick_command_queue(ftdi);
1406 mutex_unlock(&ftdi->u132_lock);
1410 mutex_unlock(&ftdi->u132_lock);
1420 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1421 if (ftdi->initialized == 0) {
1424 return ftdi_elan_read_pcimem(ftdi, mem_offset, width, data);
1429 static int ftdi_elan_edset_setup(struct usb_ftdi *ftdi, u8 ed_number,
1436 wait:if (ftdi->disconnected > 0) {
1438 } else if (ftdi->initialized == 0) {
1442 mutex_lock(&ftdi->u132_lock);
1443 command_size = ftdi->command_next - ftdi->command_head;
1445 struct u132_target *target = &ftdi->target[ed];
1446 struct u132_command *command = &ftdi->command[
1447 COMMAND_MASK & ftdi->command_next];
1461 ftdi->command_next += 1;
1462 ftdi_elan_kick_command_queue(ftdi);
1463 mutex_unlock(&ftdi->u132_lock);
1466 mutex_unlock(&ftdi->u132_lock);
1479 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1480 return ftdi_elan_edset_setup(ftdi, ed_number, endp, urb, address,
1486 static int ftdi_elan_edset_input(struct usb_ftdi *ftdi, u8 ed_number,
1493 wait:if (ftdi->disconnected > 0) {
1495 } else if (ftdi->initialized == 0) {
1499 mutex_lock(&ftdi->u132_lock);
1500 command_size = ftdi->command_next - ftdi->command_head;
1502 struct u132_target *target = &ftdi->target[ed];
1503 struct u132_command *command = &ftdi->command[
1504 COMMAND_MASK & ftdi->command_next];
1526 ftdi->command_next += 1;
1527 ftdi_elan_kick_command_queue(ftdi);
1528 mutex_unlock(&ftdi->u132_lock);
1531 mutex_unlock(&ftdi->u132_lock);
1544 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1545 return ftdi_elan_edset_input(ftdi, ed_number, endp, urb, address,
1551 static int ftdi_elan_edset_empty(struct usb_ftdi *ftdi, u8 ed_number,
1558 wait:if (ftdi->disconnected > 0) {
1560 } else if (ftdi->initialized == 0) {
1564 mutex_lock(&ftdi->u132_lock);
1565 command_size = ftdi->command_next - ftdi->command_head;
1567 struct u132_target *target = &ftdi->target[ed];
1568 struct u132_command *command = &ftdi->command[
1569 COMMAND_MASK & ftdi->command_next];
1583 ftdi->command_next += 1;
1584 ftdi_elan_kick_command_queue(ftdi);
1585 mutex_unlock(&ftdi->u132_lock);
1588 mutex_unlock(&ftdi->u132_lock);
1601 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1602 return ftdi_elan_edset_empty(ftdi, ed_number, endp, urb, address,
1608 static int ftdi_elan_edset_output(struct usb_ftdi *ftdi, u8 ed_number,
1615 wait:if (ftdi->disconnected > 0) {
1617 } else if (ftdi->initialized == 0) {
1621 mutex_lock(&ftdi->u132_lock);
1622 command_size = ftdi->command_next - ftdi->command_head;
1631 struct u132_target *target = &ftdi->target[ed];
1632 struct u132_command *command = &ftdi->command[
1633 COMMAND_MASK & ftdi->command_next];
1662 ftdi->command_next += 1;
1663 ftdi_elan_kick_command_queue(ftdi);
1664 mutex_unlock(&ftdi->u132_lock);
1667 mutex_unlock(&ftdi->u132_lock);
1680 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1681 return ftdi_elan_edset_output(ftdi, ed_number, endp, urb, address,
1687 static int ftdi_elan_edset_single(struct usb_ftdi *ftdi, u8 ed_number,
1694 wait:if (ftdi->disconnected > 0) {
1696 } else if (ftdi->initialized == 0) {
1700 mutex_lock(&ftdi->u132_lock);
1701 command_size = ftdi->command_next - ftdi->command_head;
1705 struct u132_target *target = &ftdi->target[ed];
1706 struct u132_command *command = &ftdi->command[
1707 COMMAND_MASK & ftdi->command_next];
1727 ftdi->command_next += 1;
1728 ftdi_elan_kick_command_queue(ftdi);
1729 mutex_unlock(&ftdi->u132_lock);
1732 mutex_unlock(&ftdi->u132_lock);
1745 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1746 return ftdi_elan_edset_single(ftdi, ed_number, endp, urb, address,
1752 static int ftdi_elan_edset_flush(struct usb_ftdi *ftdi, u8 ed_number,
1756 if (ftdi->disconnected > 0) {
1758 } else if (ftdi->initialized == 0) {
1761 struct u132_target *target = &ftdi->target[ed];
1762 mutex_lock(&ftdi->u132_lock);
1764 mutex_unlock(&ftdi->u132_lock);
1769 int command_size = ftdi->command_next -
1770 ftdi->command_head;
1773 &ftdi->command[COMMAND_MASK &
1774 ftdi->command_next];
1783 ftdi->command_next += 1;
1784 ftdi_elan_kick_command_queue(ftdi);
1786 mutex_unlock(&ftdi->u132_lock);
1788 mutex_lock(&ftdi->u132_lock);
1792 mutex_unlock(&ftdi->u132_lock);
1801 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
1802 return ftdi_elan_edset_flush(ftdi, ed_number, endp);
1807 static int ftdi_elan_flush_input_fifo(struct usb_ftdi *ftdi)
1814 int retval = usb_bulk_msg(ftdi->udev,
1815 usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
1816 ftdi->bulk_in_buffer, ftdi->bulk_in_size,
1822 char *b = ftdi->bulk_in_buffer;
1838 char s1 = ftdi->bulk_in_buffer[0];
1839 char s2 = ftdi->bulk_in_buffer[1];
1845 dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
1849 char b1 = ftdi->bulk_in_buffer[0];
1850 dev_err(&ftdi->udev->dev, "only one byte flushed from FTDI = %02X\n",
1855 dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
1862 dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
1869 dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
1873 dev_err(&ftdi->udev->dev, "error = %d\n", retval);
1885 static int ftdi_elan_synchronize_flush(struct usb_ftdi *ftdi)
1895 buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
1897 dev_err(&ftdi->udev->dev, "could not get a buffer for flush sequence\n");
1903 usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
1904 ftdi->bulk_out_endpointAddr), buf, i,
1905 ftdi_elan_write_bulk_callback, ftdi);
1909 dev_err(&ftdi->udev->dev, "failed to submit urb containing the flush sequence\n");
1910 usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
1923 static int ftdi_elan_synchronize_reset(struct usb_ftdi *ftdi)
1933 buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
1935 dev_err(&ftdi->udev->dev, "could not get a buffer for the reset sequence\n");
1943 usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
1944 ftdi->bulk_out_endpointAddr), buf, i,
1945 ftdi_elan_write_bulk_callback, ftdi);
1949 dev_err(&ftdi->udev->dev, "failed to submit urb containing the reset sequence\n");
1950 usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
1958 static int ftdi_elan_synchronize(struct usb_ftdi *ftdi)
1965 retval = ftdi_elan_flush_input_fifo(ftdi);
1968 ftdi->bulk_in_left = 0;
1969 ftdi->bulk_in_last = -1;
1973 retval = ftdi_elan_synchronize_flush(ftdi);
1976 retval = ftdi_elan_flush_input_fifo(ftdi);
1979 reset:retval = ftdi_elan_synchronize_reset(ftdi);
1986 retval = usb_bulk_msg(ftdi->udev,
1987 usb_rcvbulkpipe(ftdi->udev,
1988 ftdi->bulk_in_endpointAddr),
1989 ftdi->bulk_in_buffer, ftdi->bulk_in_size,
1995 char *b = ftdi->bulk_in_buffer;
2017 dev_err(&ftdi->udev->dev, "retry limit reached\n");
2022 unsigned char s1 = ftdi->bulk_in_buffer[0];
2023 unsigned char s2 = ftdi->bulk_in_buffer[1];
2033 dev_err(&ftdi->udev->dev, "retry limit reached\n");
2041 dev_err(&ftdi->udev->dev, "retry limit reached\n");
2048 dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
2055 dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
2060 dev_err(&ftdi->udev->dev, "error = %d\n",
2065 dev_err(&ftdi->udev->dev, "retry limit reached\n");
2071 dev_err(&ftdi->udev->dev, "failed to synchronize\n");
2075 static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi)
2082 int retval = usb_bulk_msg(ftdi->udev,
2083 usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
2084 ftdi->bulk_in_buffer, ftdi->bulk_in_size,
2090 char *b = ftdi->bulk_in_buffer;
2106 char s1 = ftdi->bulk_in_buffer[0];
2107 char s2 = ftdi->bulk_in_buffer[1];
2116 char b1 = ftdi->bulk_in_buffer[0];
2117 dev_err(&ftdi->udev->dev, "only one byte flushed from FTDI = %02X\n", b1);
2122 dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
2129 dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
2136 dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
2140 dev_err(&ftdi->udev->dev, "error = %d\n", retval);
2147 static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi)
2149 int UxxxStatus = ftdi_elan_read_reg(ftdi, &ftdi->controlreg);
2152 if (ftdi->controlreg & 0x00400000) {
2153 if (ftdi->card_ejected) {
2155 ftdi->card_ejected = 1;
2156 dev_err(&ftdi->udev->dev, "CARD EJECTED - controlreg = %08X\n",
2157 ftdi->controlreg);
2161 u8 fn = ftdi->function - 1;
2167 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2173 if (pciVID == ftdi->platform_data.vendor && pciPID ==
2174 ftdi->platform_data.device) {
2177 dev_err(&ftdi->udev->dev, "vendor=%04X pciVID=%04X device=%04X pciPID=%04X\n",
2178 ftdi->platform_data.vendor, pciVID,
2179 ftdi->platform_data.device, pciPID);
2186 #define ftdi_read_pcimem(ftdi, member, data) ftdi_elan_read_pcimem(ftdi, \
2188 #define ftdi_write_pcimem(ftdi, member, data) ftdi_elan_write_pcimem(ftdi, \
2194 static int ftdi_elan_check_controller(struct usb_ftdi *ftdi, int quirk)
2212 retval = ftdi_write_pcimem(ftdi, intrdisable, OHCI_INTR_MIE);
2215 retval = ftdi_read_pcimem(ftdi, control, &control);
2218 retval = ftdi_read_pcimem(ftdi, roothub.a, &rh_a);
2222 retval = ftdi_read_pcimem(ftdi, fminterval, &hc_fminterval);
2229 retval = ftdi_read_pcimem(ftdi, control, &hc_control);
2248 retval = ftdi_write_pcimem(ftdi, control, hc_control);
2251 retval = ftdi_read_pcimem(ftdi, control, &control);
2255 retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
2260 retval = ftdi_write_pcimem(ftdi,
2266 retval = ftdi_read_pcimem(ftdi, control, &control);
2269 retry:retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
2272 retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_HCR);
2276 retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
2281 dev_err(&ftdi->udev->dev, "USB HC reset timed out!\n");
2290 retval = ftdi_write_pcimem(ftdi, control, hc_control);
2293 retval = ftdi_read_pcimem(ftdi, control, &control);
2297 retval = ftdi_write_pcimem(ftdi, ed_controlhead, 0x00000000);
2300 retval = ftdi_write_pcimem(ftdi, ed_bulkhead, 0x11000000);
2303 retval = ftdi_write_pcimem(ftdi, hcca, 0x00000000);
2306 retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
2309 retval = ftdi_write_pcimem(ftdi, fminterval,
2313 retval = ftdi_write_pcimem(ftdi, periodicstart,
2317 retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
2320 retval = ftdi_read_pcimem(ftdi, periodicstart, &periodicstart);
2328 dev_err(&ftdi->udev->dev, "init err(%08x %04x)\n",
2333 retval = ftdi_write_pcimem(ftdi, control, hc_control);
2336 retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_BLF);
2339 retval = ftdi_read_pcimem(ftdi, cmdstatus, &cmdstatus);
2342 retval = ftdi_read_pcimem(ftdi, control, &control);
2345 retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_DRWE);
2348 retval = ftdi_write_pcimem(ftdi, intrstatus, mask);
2351 retval = ftdi_write_pcimem(ftdi, intrdisable,
2357 retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
2364 retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
2369 retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
2373 retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_LPSC);
2376 retval = ftdi_write_pcimem(ftdi, roothub.b,
2380 retval = ftdi_read_pcimem(ftdi, control, &control);
2386 retval = ftdi_read_pcimem(ftdi, roothub.portstatus[temp],
2396 static int ftdi_elan_setup_controller(struct usb_ftdi *ftdi, int fn)
2403 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
2407 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
2411 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2415 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
2419 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2424 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2430 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
2434 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2439 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
2443 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2448 UxxxStatus = ftdi_elan_read_pcimem(ftdi, reg, 0, &pcidata);
2455 static int ftdi_elan_close_controller(struct usb_ftdi *ftdi, int fn)
2462 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
2466 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
2470 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2474 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
2478 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2483 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2489 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
2493 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2498 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
2502 return ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, &pcidata);
2505 static int ftdi_elan_found_controller(struct usb_ftdi *ftdi, int fn, int quirk)
2509 UxxxStatus = ftdi_elan_setup_controller(ftdi, fn);
2512 result = ftdi_elan_check_controller(ftdi, quirk);
2513 UxxxStatus = ftdi_elan_close_controller(ftdi, fn);
2519 static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi)
2524 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2527 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000000L);
2531 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x100);
2534 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x500);
2537 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2540 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020CL | 0x000);
2543 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020DL | 0x000);
2547 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020FL | 0x000);
2550 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2553 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x800);
2556 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2559 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
2570 static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi)
2580 ftdi->function = 0;
2586 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
2593 devices = ftdi_elan_found_controller(ftdi, fn, 0);
2597 devices = ftdi_elan_found_controller(ftdi, fn, 0);
2600 devices = ftdi_elan_found_controller(ftdi, fn, 0);
2604 devices = ftdi_elan_found_controller(ftdi, fn, 0);
2607 devices = ftdi_elan_found_controller(ftdi, fn,
2611 devices = ftdi_elan_found_controller(ftdi, fn,
2619 ftdi->function = fn + 1;
2620 ftdi->platform_data.vendor = pciVID;
2621 ftdi->platform_data.device = pciPID;
2624 if (ftdi->function > 0) {
2625 return ftdi_elan_setup_controller(ftdi, ftdi->function - 1);
2631 ftdi->enumerated = 0;
2646 struct usb_ftdi *ftdi;
2648 ftdi = kzalloc(sizeof(struct usb_ftdi), GFP_KERNEL);
2649 if (!ftdi)
2653 list_add_tail(&ftdi->ftdi_list, &ftdi_static_list);
2654 ftdi->sequence_num = ++ftdi_instances;
2656 ftdi_elan_init_kref(ftdi);
2657 sema_init(&ftdi->sw_lock, 1);
2658 ftdi->udev = usb_get_dev(interface_to_usbdev(interface));
2659 ftdi->interface = interface;
2660 mutex_init(&ftdi->u132_lock);
2661 ftdi->expected = 4;
2667 dev_err(&ftdi->udev->dev, "Could not find both bulk-in and bulk-out endpoints\n");
2671 ftdi->bulk_in_size = usb_endpoint_maxp(bulk_in);
2672 ftdi->bulk_in_endpointAddr = bulk_in->bEndpointAddress;
2673 ftdi->bulk_in_buffer = kmalloc(ftdi->bulk_in_size, GFP_KERNEL);
2674 if (!ftdi->bulk_in_buffer) {
2679 ftdi->bulk_out_endpointAddr = bulk_out->bEndpointAddress;
2681 dev_info(&ftdi->udev->dev, "interface %d has I=%02X O=%02X\n",
2682 iface_desc->desc.bInterfaceNumber, ftdi->bulk_in_endpointAddr,
2683 ftdi->bulk_out_endpointAddr);
2684 usb_set_intfdata(interface, ftdi);
2686 ftdi->bulk_in_endpointAddr == 0x81 &&
2687 ftdi->bulk_out_endpointAddr == 0x02) {
2690 dev_err(&ftdi->udev->dev, "Not able to get a minor for this device\n");
2695 ftdi->class = &ftdi_elan_jtag_class;
2696 dev_info(&ftdi->udev->dev, "USB FDTI=%p JTAG interface %d now attached to ftdi%d\n",
2697 ftdi, iface_desc->desc.bInterfaceNumber,
2702 ftdi->bulk_in_endpointAddr == 0x83 &&
2703 ftdi->bulk_out_endpointAddr == 0x04) {
2704 ftdi->class = NULL;
2705 dev_info(&ftdi->udev->dev, "USB FDTI=%p ELAN interface %d now activated\n",
2706 ftdi, iface_desc->desc.bInterfaceNumber);
2707 INIT_DELAYED_WORK(&ftdi->status_work, ftdi_elan_status_work);
2708 INIT_DELAYED_WORK(&ftdi->command_work, ftdi_elan_command_work);
2709 INIT_DELAYED_WORK(&ftdi->respond_work, ftdi_elan_respond_work);
2710 ftdi_status_queue_work(ftdi, msecs_to_jiffies(3 *1000));
2713 dev_err(&ftdi->udev->dev,
2718 error:if (ftdi) {
2719 ftdi_elan_put_kref(ftdi);
2726 struct usb_ftdi *ftdi = usb_get_intfdata(interface);
2727 ftdi->disconnected += 1;
2728 if (ftdi->class) {
2730 struct usb_class_driver *class = ftdi->class;
2733 dev_info(&ftdi->udev->dev, "USB FTDI U132 jtag interface on minor %d now disconnected\n",
2736 ftdi_status_cancel_work(ftdi);
2737 ftdi_command_cancel_work(ftdi);
2738 ftdi_response_cancel_work(ftdi);
2739 ftdi_elan_abandon_completions(ftdi);
2740 ftdi_elan_abandon_targets(ftdi);
2741 if (ftdi->registered) {
2742 platform_device_unregister(&ftdi->platform_dev);
2743 ftdi->synchronized = 0;
2744 ftdi->enumerated = 0;
2745 ftdi->initialized = 0;
2746 ftdi->registered = 0;
2748 ftdi->disconnected += 1;
2750 dev_info(&ftdi->udev->dev, "USB FTDI U132 host controller interface now disconnected\n");
2752 ftdi_elan_put_kref(ftdi);
2756 .name = "ftdi-elan",
2777 struct usb_ftdi *ftdi;
2781 list_for_each_entry_safe(ftdi, temp, &ftdi_static_list, ftdi_list) {
2782 ftdi_status_cancel_work(ftdi);
2783 ftdi_command_cancel_work(ftdi);
2784 ftdi_response_cancel_work(ftdi);