Lines Matching defs:vub300
371 struct vub300_mmc_host *vub300 = kref_to_vub300_mmc_host(kref);
372 struct mmc_host *mmc = vub300->mmc;
373 usb_free_urb(vub300->command_out_urb);
374 vub300->command_out_urb = NULL;
375 usb_free_urb(vub300->command_res_urb);
376 vub300->command_res_urb = NULL;
377 usb_put_dev(vub300->udev);
380 * and hence also frees vub300
385 static void vub300_queue_cmnd_work(struct vub300_mmc_host *vub300)
387 kref_get(&vub300->kref);
388 if (queue_work(cmndworkqueue, &vub300->cmndwork)) {
401 kref_put(&vub300->kref, vub300_delete);
405 static void vub300_queue_poll_work(struct vub300_mmc_host *vub300, int delay)
407 kref_get(&vub300->kref);
408 if (queue_delayed_work(pollworkqueue, &vub300->pollwork, delay)) {
421 kref_put(&vub300->kref, vub300_delete);
425 static void vub300_queue_dead_work(struct vub300_mmc_host *vub300)
427 kref_get(&vub300->kref);
428 if (queue_work(deadworkqueue, &vub300->deadwork)) {
441 kref_put(&vub300->kref, vub300_delete);
447 struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)urb->context;
449 vub300->usb_transport_fail = urb->status;
450 complete(&vub300->irqpoll_complete);
455 struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)urb->context;
457 vub300->usb_transport_fail = urb->status;
458 complete(&vub300->irqpoll_complete);
463 usb_rcvbulkpipe(vub300->udev, vub300->cmnd_res_ep);
464 usb_fill_bulk_urb(vub300->command_res_urb, vub300->udev, pipe,
465 &vub300->resp, sizeof(vub300->resp),
466 irqpoll_res_completed, vub300);
467 vub300->command_res_urb->actual_length = 0;
468 ret = usb_submit_urb(vub300->command_res_urb, GFP_ATOMIC);
470 vub300->usb_transport_fail = ret;
471 complete(&vub300->irqpoll_complete);
477 static void send_irqpoll(struct vub300_mmc_host *vub300)
482 vub300->cmnd.poll.header_size = 22;
483 vub300->cmnd.poll.header_type = 1;
484 vub300->cmnd.poll.port_number = 0;
485 vub300->cmnd.poll.command_type = 2;
486 vub300->cmnd.poll.poll_timeout_lsb = 0xFF & (unsigned)timeout;
487 vub300->cmnd.poll.poll_timeout_msb = 0xFF & (unsigned)(timeout >> 8);
488 usb_fill_bulk_urb(vub300->command_out_urb, vub300->udev,
489 usb_sndbulkpipe(vub300->udev, vub300->cmnd_out_ep)
490 , &vub300->cmnd, sizeof(vub300->cmnd)
491 , irqpoll_out_completed, vub300);
492 retval = usb_submit_urb(vub300->command_out_urb, GFP_KERNEL);
494 vub300->usb_transport_fail = retval;
495 vub300_queue_poll_work(vub300, 1);
496 complete(&vub300->irqpoll_complete);
503 static void new_system_port_status(struct vub300_mmc_host *vub300)
505 int old_card_present = vub300->card_present;
507 (0x0001 & vub300->system_port_status.port_flags) ? 1 : 0;
508 vub300->read_only =
509 (0x0010 & vub300->system_port_status.port_flags) ? 1 : 0;
511 dev_info(&vub300->udev->dev, "card just inserted\n");
512 vub300->card_present = 1;
513 vub300->bus_width = 0;
515 strncpy(vub300->vub_name, "EMPTY Processing Disabled",
516 sizeof(vub300->vub_name));
518 vub300->vub_name[0] = 0;
519 mmc_detect_change(vub300->mmc, 1);
521 dev_info(&vub300->udev->dev, "card just ejected\n");
522 vub300->card_present = 0;
523 mmc_detect_change(vub300->mmc, 0);
529 static void __add_offloaded_reg_to_fifo(struct vub300_mmc_host *vub300,
533 u8 r = vub300->fn[func].offload_point + vub300->fn[func].offload_count;
534 memcpy(&vub300->fn[func].reg[MAXREGMASK & r], register_access,
536 vub300->fn[func].offload_count += 1;
537 vub300->total_offload_count += 1;
540 static void add_offloaded_reg(struct vub300_mmc_host *vub300,
547 u8 regs = vub300->dynamic_register_count;
549 while (0 < regs-- && 1 == vub300->sdio_register[i].activate) {
550 if (vub300->sdio_register[i].func_num == func &&
551 vub300->sdio_register[i].sdio_reg == Register) {
552 if (vub300->sdio_register[i].prepared == 0)
553 vub300->sdio_register[i].prepared = 1;
554 vub300->sdio_register[i].response =
556 vub300->sdio_register[i].regvalue =
564 __add_offloaded_reg_to_fifo(vub300, register_access, func);
567 static void check_vub300_port_status(struct vub300_mmc_host *vub300)
575 usb_control_msg(vub300->udev, usb_rcvctrlpipe(vub300->udev, 0),
578 0x0000, 0x0000, &vub300->system_port_status,
579 sizeof(vub300->system_port_status), 1000);
580 if (sizeof(vub300->system_port_status) == retval)
581 new_system_port_status(vub300);
584 static void __vub300_irqpoll_response(struct vub300_mmc_host *vub300)
587 if (vub300->command_res_urb->actual_length == 0)
590 switch (vub300->resp.common.header_type) {
592 mutex_lock(&vub300->irq_mutex);
593 if (vub300->irq_enabled)
594 mmc_signal_sdio_irq(vub300->mmc);
596 vub300->irqs_queued += 1;
597 vub300->irq_disabled = 1;
598 mutex_unlock(&vub300->irq_mutex);
601 if (vub300->resp.error.error_code == SD_ERROR_NO_DEVICE)
602 check_vub300_port_status(vub300);
605 vub300->system_port_status = vub300->resp.status;
606 new_system_port_status(vub300);
607 if (!vub300->card_present)
608 vub300_queue_poll_work(vub300, HZ / 5);
612 int offloaded_data_length = vub300->resp.common.header_size - 3;
616 add_offloaded_reg(vub300, &vub300->resp.irq.reg[ri]);
619 mutex_lock(&vub300->irq_mutex);
620 if (vub300->irq_enabled)
621 mmc_signal_sdio_irq(vub300->mmc);
623 vub300->irqs_queued += 1;
624 vub300->irq_disabled = 1;
625 mutex_unlock(&vub300->irq_mutex);
630 int offloaded_data_length = vub300->resp.common.header_size - 3;
634 add_offloaded_reg(vub300, &vub300->resp.irq.reg[ri]);
637 mutex_lock(&vub300->irq_mutex);
638 if (vub300->irq_enabled)
639 mmc_signal_sdio_irq(vub300->mmc);
641 vub300->irqs_queued += 1;
642 vub300->irq_disabled = 0;
643 mutex_unlock(&vub300->irq_mutex);
647 vub300_queue_poll_work(vub300, 1);
654 static void __do_poll(struct vub300_mmc_host *vub300)
658 mod_timer(&vub300->inactivity_timer, jiffies + HZ);
659 init_completion(&vub300->irqpoll_complete);
660 send_irqpoll(vub300);
661 commretval = wait_for_completion_timeout(&vub300->irqpoll_complete,
663 if (vub300->usb_transport_fail) {
666 vub300->usb_timed_out = 1;
667 usb_kill_urb(vub300->command_out_urb);
668 usb_kill_urb(vub300->command_res_urb);
670 __vub300_irqpoll_response(vub300);
679 struct vub300_mmc_host *vub300 = container_of(work,
681 if (!vub300->interface) {
682 kref_put(&vub300->kref, vub300_delete);
685 mutex_lock(&vub300->cmd_mutex);
686 if (vub300->cmd) {
687 vub300_queue_poll_work(vub300, 1);
688 } else if (!vub300->card_present) {
690 } else { /* vub300->card_present */
691 mutex_lock(&vub300->irq_mutex);
692 if (!vub300->irq_enabled) {
693 mutex_unlock(&vub300->irq_mutex);
694 } else if (vub300->irqs_queued) {
695 vub300->irqs_queued -= 1;
696 mmc_signal_sdio_irq(vub300->mmc);
697 mod_timer(&vub300->inactivity_timer, jiffies + HZ);
698 mutex_unlock(&vub300->irq_mutex);
699 } else { /* NOT vub300->irqs_queued */
700 mutex_unlock(&vub300->irq_mutex);
701 __do_poll(vub300);
704 mutex_unlock(&vub300->cmd_mutex);
705 kref_put(&vub300->kref, vub300_delete);
710 struct vub300_mmc_host *vub300 =
712 if (!vub300->interface) {
713 kref_put(&vub300->kref, vub300_delete);
716 mutex_lock(&vub300->cmd_mutex);
717 if (vub300->cmd) {
724 } else if (vub300->card_present) {
725 check_vub300_port_status(vub300);
726 } else if (vub300->mmc && vub300->mmc->card) {
734 check_vub300_port_status(vub300);
736 mod_timer(&vub300->inactivity_timer, jiffies + HZ);
737 mutex_unlock(&vub300->cmd_mutex);
738 kref_put(&vub300->kref, vub300_delete);
743 struct vub300_mmc_host *vub300 = from_timer(vub300, t,
745 if (!vub300->interface) {
746 kref_put(&vub300->kref, vub300_delete);
747 } else if (vub300->cmd) {
748 mod_timer(&vub300->inactivity_timer, jiffies + HZ);
750 vub300_queue_dead_work(vub300);
751 mod_timer(&vub300->inactivity_timer, jiffies + HZ);
793 struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)urb->context;
796 } else if (vub300->command_res_urb->actual_length == 0) {
801 } else if (!vub300->data) {
803 } else if (vub300->resp.common.header_type != 0x02) {
808 } else if (vub300->urb) {
809 vub300->cmd->error =
810 vub300_response_error(vub300->resp.error.error_code);
811 usb_unlink_urb(vub300->urb);
813 vub300->cmd->error =
814 vub300_response_error(vub300->resp.error.error_code);
815 usb_sg_cancel(&vub300->sg_request);
817 complete(&vub300->command_complete); /* got_response_in */
822 struct vub300_mmc_host *vub300 = (struct vub300_mmc_host *)urb->context;
824 complete(&vub300->command_complete);
828 usb_rcvbulkpipe(vub300->udev, vub300->cmnd_res_ep);
829 usb_fill_bulk_urb(vub300->command_res_urb, vub300->udev, pipe,
830 &vub300->resp, sizeof(vub300->resp),
831 command_res_completed, vub300);
832 vub300->command_res_urb->actual_length = 0;
833 ret = usb_submit_urb(vub300->command_res_urb, GFP_ATOMIC);
844 complete(&vub300->command_complete);
852 static void snoop_block_size_and_bus_width(struct vub300_mmc_host *vub300,
856 vub300->fbs[1] = (cmd_arg << 8) | (0x00FF & vub300->fbs[1]);
858 vub300->fbs[1] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[1]);
860 vub300->fbs[2] = (cmd_arg << 8) | (0x00FF & vub300->fbs[2]);
862 vub300->fbs[2] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[2]);
864 vub300->fbs[3] = (cmd_arg << 8) | (0x00FF & vub300->fbs[3]);
866 vub300->fbs[3] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[3]);
868 vub300->fbs[4] = (cmd_arg << 8) | (0x00FF & vub300->fbs[4]);
870 vub300->fbs[4] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[4]);
872 vub300->fbs[5] = (cmd_arg << 8) | (0x00FF & vub300->fbs[5]);
874 vub300->fbs[5] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[5]);
876 vub300->fbs[6] = (cmd_arg << 8) | (0x00FF & vub300->fbs[6]);
878 vub300->fbs[6] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[6]);
880 vub300->fbs[7] = (cmd_arg << 8) | (0x00FF & vub300->fbs[7]);
882 vub300->fbs[7] = (0xFF & cmd_arg) | (0xFF00 & vub300->fbs[7]);
884 vub300->bus_width = 1;
886 vub300->bus_width = 4;
889 static void send_command(struct vub300_mmc_host *vub300)
892 struct mmc_command *cmd = vub300->cmd;
893 struct mmc_data *data = vub300->data;
897 if (vub300->app_spec) {
901 vub300->resp_len = 6;
903 vub300->bus_width = 1;
905 vub300->bus_width = 4;
907 dev_err(&vub300->udev->dev,
913 vub300->resp_len = 6;
917 vub300->resp_len = 6;
921 vub300->resp_len = 6;
925 vub300->resp_len = 6;
929 vub300->resp_len = 6;
933 vub300->resp_len = 6;
937 vub300->resp_len = 6;
940 vub300->resp_len = 0;
942 complete(&vub300->command_complete);
945 vub300->app_spec = 0;
950 vub300->resp_len = 0;
954 vub300->resp_len = 6;
958 vub300->resp_len = 17;
962 vub300->resp_len = 6;
966 vub300->resp_len = 0;
970 vub300->resp_len = 6;
974 vub300->resp_len = 6;
978 vub300->resp_len = 6;
982 vub300->resp_len = 6;
986 vub300->resp_len = 17;
990 vub300->resp_len = 17;
994 vub300->resp_len = 6;
998 vub300->resp_len = 6;
1002 vub300->resp_len = 0;
1005 for (i = 0; i < ARRAY_SIZE(vub300->fbs); i++)
1006 vub300->fbs[i] = 0xFFFF & cmd->arg;
1008 vub300->resp_len = 6;
1016 vub300->resp_len = 6;
1021 vub300->resp_len = 6;
1027 vub300->resp_len = 6;
1031 vub300->resp_len = 6;
1035 vub300->resp_len = 6;
1039 vub300->resp_len = 6;
1040 snoop_block_size_and_bus_width(vub300, cmd->arg);
1044 vub300->resp_len = 6;
1048 vub300->resp_len = 6;
1049 vub300->app_spec = 1;
1053 vub300->resp_len = 6;
1056 vub300->resp_len = 0;
1058 complete(&vub300->command_complete);
1066 vub300->cmnd.head.header_size = 20;
1067 vub300->cmnd.head.header_type = 0x00;
1068 vub300->cmnd.head.port_number = 0; /* "0" means port 1 */
1069 vub300->cmnd.head.command_type = 0x00; /* standard read command */
1070 vub300->cmnd.head.response_type = response_type;
1071 vub300->cmnd.head.command_index = cmd->opcode;
1072 vub300->cmnd.head.arguments[0] = cmd->arg >> 24;
1073 vub300->cmnd.head.arguments[1] = cmd->arg >> 16;
1074 vub300->cmnd.head.arguments[2] = cmd->arg >> 8;
1075 vub300->cmnd.head.arguments[3] = cmd->arg >> 0;
1078 vub300->cmnd.head.block_count[0] = 0;
1079 vub300->cmnd.head.block_count[1] = 0;
1080 vub300->cmnd.head.block_size[0] = (vub300->fbs[fn] >> 8) & 0xFF;
1081 vub300->cmnd.head.block_size[1] = (vub300->fbs[fn] >> 0) & 0xFF;
1082 vub300->cmnd.head.command_type = 0x00;
1083 vub300->cmnd.head.transfer_size[0] = 0;
1084 vub300->cmnd.head.transfer_size[1] = 0;
1085 vub300->cmnd.head.transfer_size[2] = 0;
1086 vub300->cmnd.head.transfer_size[3] = 0;
1088 vub300->cmnd.head.block_count[0] = 0;
1089 vub300->cmnd.head.block_count[1] = 0;
1090 vub300->cmnd.head.block_size[0] = (vub300->fbs[0] >> 8) & 0xFF;
1091 vub300->cmnd.head.block_size[1] = (vub300->fbs[0] >> 0) & 0xFF;
1092 vub300->cmnd.head.command_type = 0x00;
1093 vub300->cmnd.head.transfer_size[0] = 0;
1094 vub300->cmnd.head.transfer_size[1] = 0;
1095 vub300->cmnd.head.transfer_size[2] = 0;
1096 vub300->cmnd.head.transfer_size[3] = 0;
1099 if (0x08 & vub300->cmnd.head.arguments[0]) { /* BLOCK MODE */
1100 vub300->cmnd.head.block_count[0] =
1102 vub300->cmnd.head.block_count[1] =
1104 vub300->cmnd.head.block_size[0] =
1106 vub300->cmnd.head.block_size[1] =
1109 vub300->cmnd.head.block_count[0] = 0;
1110 vub300->cmnd.head.block_count[1] = 0;
1111 vub300->cmnd.head.block_size[0] =
1112 (vub300->datasize >> 8) & 0xFF;
1113 vub300->cmnd.head.block_size[1] =
1114 (vub300->datasize >> 0) & 0xFF;
1116 vub300->cmnd.head.command_type =
1118 vub300->cmnd.head.transfer_size[0] =
1119 (vub300->datasize >> 24) & 0xFF;
1120 vub300->cmnd.head.transfer_size[1] =
1121 (vub300->datasize >> 16) & 0xFF;
1122 vub300->cmnd.head.transfer_size[2] =
1123 (vub300->datasize >> 8) & 0xFF;
1124 vub300->cmnd.head.transfer_size[3] =
1125 (vub300->datasize >> 0) & 0xFF;
1126 if (vub300->datasize < vub300->fbs[fn]) {
1127 vub300->cmnd.head.block_count[0] = 0;
1128 vub300->cmnd.head.block_count[1] = 0;
1131 vub300->cmnd.head.block_count[0] = (data->blocks >> 8) & 0xFF;
1132 vub300->cmnd.head.block_count[1] = (data->blocks >> 0) & 0xFF;
1133 vub300->cmnd.head.block_size[0] = (data->blksz >> 8) & 0xFF;
1134 vub300->cmnd.head.block_size[1] = (data->blksz >> 0) & 0xFF;
1135 vub300->cmnd.head.command_type =
1137 vub300->cmnd.head.transfer_size[0] =
1138 (vub300->datasize >> 24) & 0xFF;
1139 vub300->cmnd.head.transfer_size[1] =
1140 (vub300->datasize >> 16) & 0xFF;
1141 vub300->cmnd.head.transfer_size[2] =
1142 (vub300->datasize >> 8) & 0xFF;
1143 vub300->cmnd.head.transfer_size[3] =
1144 (vub300->datasize >> 0) & 0xFF;
1145 if (vub300->datasize < vub300->fbs[0]) {
1146 vub300->cmnd.head.block_count[0] = 0;
1147 vub300->cmnd.head.block_count[1] = 0;
1150 if (vub300->cmnd.head.block_size[0] || vub300->cmnd.head.block_size[1]) {
1151 u16 block_size = vub300->cmnd.head.block_size[1] |
1152 (vub300->cmnd.head.block_size[0] << 8);
1155 vub300->cmnd.head.block_boundary[0] =
1157 vub300->cmnd.head.block_boundary[1] =
1160 vub300->cmnd.head.block_boundary[0] = 0;
1161 vub300->cmnd.head.block_boundary[1] = 0;
1163 usb_fill_bulk_urb(vub300->command_out_urb, vub300->udev,
1164 usb_sndbulkpipe(vub300->udev, vub300->cmnd_out_ep),
1165 &vub300->cmnd, sizeof(vub300->cmnd),
1166 command_out_completed, vub300);
1167 retval = usb_submit_urb(vub300->command_out_urb, GFP_KERNEL);
1170 complete(&vub300->command_complete);
1183 struct vub300_mmc_host *vub300 = from_timer(vub300, t,
1185 vub300->usb_timed_out = 1;
1186 usb_sg_cancel(&vub300->sg_request);
1187 usb_unlink_urb(vub300->command_out_urb);
1188 usb_unlink_urb(vub300->command_res_urb);
1199 static void __download_offload_pseudocode(struct vub300_mmc_host *vub300,
1208 dev_info(&vub300->udev->dev, "using %s for SDIO offload processing\n",
1209 vub300->vub_name);
1213 dev_info(&vub300->udev->dev, "using offload firmware %s %s\n", fw->data,
1214 vub300->vub_name);
1216 dev_err(&vub300->udev->dev,
1218 vub300->vub_name);
1219 strncpy(vub300->vub_name, "corrupt offload pseudocode",
1220 sizeof(vub300->vub_name));
1239 usb_control_msg(vub300->udev,
1240 usb_sndctrlpipe(vub300->udev, 0),
1249 dev_err(&vub300->udev->dev,
1252 vub300->vub_name);
1253 strncpy(vub300->vub_name,
1255 sizeof(vub300->vub_name));
1259 dev_err(&vub300->udev->dev,
1261 fw->data, vub300->vub_name);
1262 strncpy(vub300->vub_name, "corrupt interrupt pseudocode",
1263 sizeof(vub300->vub_name));
1282 usb_control_msg(vub300->udev,
1283 usb_sndctrlpipe(vub300->udev, 0),
1292 dev_err(&vub300->udev->dev,
1295 vub300->vub_name);
1296 strncpy(vub300->vub_name,
1298 sizeof(vub300->vub_name));
1302 dev_err(&vub300->udev->dev,
1304 fw->data, vub300->vub_name);
1305 strncpy(vub300->vub_name, "corrupt transfer pseudocode",
1306 sizeof(vub300->vub_name));
1312 int I = vub300->dynamic_register_count = register_count;
1316 vub300->sdio_register[i].func_num = *data++;
1326 vub300->sdio_register[i].sdio_reg = func_num;
1327 vub300->sdio_register[i].activate = 1;
1328 vub300->sdio_register[i].prepared = 0;
1331 dev_info(&vub300->udev->dev,
1333 vub300->dynamic_register_count);
1336 dev_err(&vub300->udev->dev,
1338 vub300->vub_name);
1339 strncpy(vub300->vub_name, "corrupt dynamic registers",
1340 sizeof(vub300->vub_name));
1347 strncpy(vub300->vub_name, "SDIO pseudocode download failed",
1348 sizeof(vub300->vub_name));
1353 * vub300->vub_name is set anyway in order to prevent an automatic retry
1355 static void download_offload_pseudocode(struct vub300_mmc_host *vub300)
1357 struct mmc_card *card = vub300->mmc->card;
1360 int l = snprintf(vub300->vub_name, sizeof(vub300->vub_name),
1366 l += scnprintf(vub300->vub_name + l,
1367 sizeof(vub300->vub_name) - l, "_%04X%04X",
1370 snprintf(vub300->vub_name + l, sizeof(vub300->vub_name) - l, ".bin");
1371 dev_info(&vub300->udev->dev, "requesting offload firmware %s\n",
1372 vub300->vub_name);
1373 retval = request_firmware(&fw, vub300->vub_name, &card->dev);
1375 strncpy(vub300->vub_name, "vub_default.bin",
1376 sizeof(vub300->vub_name));
1377 retval = request_firmware(&fw, vub300->vub_name, &card->dev);
1379 strncpy(vub300->vub_name,
1381 sizeof(vub300->vub_name));
1383 __download_offload_pseudocode(vub300, fw);
1387 __download_offload_pseudocode(vub300, fw);
1397 static int vub300_usb_bulk_msg(struct vub300_mmc_host *vub300,
1402 struct usb_device *usb_dev = vub300->udev;
1405 vub300->urb = usb_alloc_urb(0, GFP_KERNEL);
1406 if (!vub300->urb)
1408 usb_fill_bulk_urb(vub300->urb, usb_dev, pipe, data, len,
1411 vub300->urb->context = &done;
1412 vub300->urb->actual_length = 0;
1413 retval = usb_submit_urb(vub300->urb, GFP_KERNEL);
1419 usb_kill_urb(vub300->urb);
1421 retval = vub300->urb->status;
1424 *actual_length = vub300->urb->actual_length;
1425 usb_free_urb(vub300->urb);
1426 vub300->urb = NULL;
1430 static int __command_read_data(struct vub300_mmc_host *vub300,
1434 int linear_length = vub300->datasize;
1435 int padded_length = vub300->large_usb_packets ?
1441 pipe = usb_rcvbulkpipe(vub300->udev, vub300->data_inp_ep);
1442 result = usb_sg_init(&vub300->sg_request, vub300->udev,
1446 usb_unlink_urb(vub300->command_out_urb);
1447 usb_unlink_urb(vub300->command_res_urb);
1452 vub300->sg_transfer_timer.expires =
1455 add_timer(&vub300->sg_transfer_timer);
1456 usb_sg_wait(&vub300->sg_request);
1457 del_timer(&vub300->sg_transfer_timer);
1458 if (vub300->sg_request.status < 0) {
1459 cmd->error = vub300->sg_request.status;
1463 data->bytes_xfered = vub300->datasize;
1471 unsigned pipe = usb_rcvbulkpipe(vub300->udev,
1472 vub300->data_inp_ep);
1474 result = vub300_usb_bulk_msg(vub300, pipe, buf,
1491 data->bytes_xfered = vub300->datasize;
1502 static int __command_write_data(struct vub300_mmc_host *vub300,
1506 unsigned pipe = usb_sndbulkpipe(vub300->udev, vub300->data_out_ep);
1507 int linear_length = vub300->datasize;
1514 vub300->padded_buffer,
1515 sizeof(vub300->padded_buffer));
1516 memset(vub300->padded_buffer + linear_length, 0,
1517 sizeof(vub300->padded_buffer) - linear_length);
1518 result = vub300_usb_bulk_msg(vub300, pipe, vub300->padded_buffer,
1519 sizeof(vub300->padded_buffer),
1521 (sizeof(vub300->padded_buffer) /
1527 data->bytes_xfered = vub300->datasize;
1529 } else if ((!vub300->large_usb_packets && (0 < modulo_64_length)) ||
1530 (vub300->large_usb_packets && (64 > modulo_512_length))
1542 vub300_usb_bulk_msg(vub300, pipe, buf,
1550 data->bytes_xfered = vub300->datasize;
1560 result = usb_sg_init(&vub300->sg_request, vub300->udev,
1564 usb_unlink_urb(vub300->command_out_urb);
1565 usb_unlink_urb(vub300->command_res_urb);
1569 vub300->sg_transfer_timer.expires =
1572 add_timer(&vub300->sg_transfer_timer);
1573 usb_sg_wait(&vub300->sg_request);
1577 del_timer(&vub300->sg_transfer_timer);
1578 if (vub300->sg_request.status < 0) {
1579 cmd->error = vub300->sg_request.status;
1582 data->bytes_xfered = vub300->datasize;
1590 static void __vub300_command_response(struct vub300_mmc_host *vub300,
1598 wait_for_completion_timeout(&vub300->command_complete,
1603 vub300->usb_timed_out = 1;
1604 usb_kill_urb(vub300->command_out_urb);
1605 usb_kill_urb(vub300->command_res_urb);
1607 result = usb_lock_device_for_reset(vub300->udev,
1608 vub300->interface);
1610 result = usb_reset_device(vub300->udev);
1611 usb_unlock_device(vub300->udev);
1615 usb_kill_urb(vub300->command_out_urb);
1616 usb_kill_urb(vub300->command_res_urb);
1623 } else if (vub300->command_out_urb->status) {
1624 vub300->usb_transport_fail = vub300->command_out_urb->status;
1625 cmd->error = -EPROTO == vub300->command_out_urb->status ?
1626 -ESHUTDOWN : vub300->command_out_urb->status;
1627 } else if (vub300->command_res_urb->status) {
1628 vub300->usb_transport_fail = vub300->command_res_urb->status;
1629 cmd->error = -EPROTO == vub300->command_res_urb->status ?
1630 -ESHUTDOWN : vub300->command_res_urb->status;
1631 } else if (vub300->resp.common.header_type == 0x00) {
1636 } else if (vub300->resp.common.header_type == RESPONSE_ERROR) {
1638 vub300_response_error(vub300->resp.error.error_code);
1639 if (vub300->data)
1640 usb_sg_cancel(&vub300->sg_request);
1641 } else if (vub300->resp.common.header_type == RESPONSE_PIGGYBACKED) {
1643 vub300->resp.common.header_size -
1648 add_offloaded_reg(vub300, &vub300->resp.pig.reg[ri]);
1651 vub300->resp.common.header_size =
1653 vub300->resp.common.header_type = 0x00;
1655 } else if (vub300->resp.common.header_type == RESPONSE_PIG_DISABLED) {
1657 vub300->resp.common.header_size -
1662 add_offloaded_reg(vub300, &vub300->resp.pig.reg[ri]);
1665 mutex_lock(&vub300->irq_mutex);
1666 if (vub300->irqs_queued) {
1667 vub300->irqs_queued += 1;
1668 } else if (vub300->irq_enabled) {
1669 vub300->irqs_queued += 1;
1670 vub300_queue_poll_work(vub300, 0);
1672 vub300->irqs_queued += 1;
1674 vub300->irq_disabled = 1;
1675 mutex_unlock(&vub300->irq_mutex);
1676 vub300->resp.common.header_size =
1678 vub300->resp.common.header_type = 0x00;
1680 } else if (vub300->resp.common.header_type == RESPONSE_PIG_ENABLED) {
1682 vub300->resp.common.header_size -
1687 add_offloaded_reg(vub300, &vub300->resp.pig.reg[ri]);
1690 mutex_lock(&vub300->irq_mutex);
1691 if (vub300->irqs_queued) {
1692 vub300->irqs_queued += 1;
1693 } else if (vub300->irq_enabled) {
1694 vub300->irqs_queued += 1;
1695 vub300_queue_poll_work(vub300, 0);
1697 vub300->irqs_queued += 1;
1699 vub300->irq_disabled = 0;
1700 mutex_unlock(&vub300->irq_mutex);
1701 vub300->resp.common.header_size =
1703 vub300->resp.common.header_type = 0x00;
1710 static void construct_request_response(struct vub300_mmc_host *vub300,
1713 int resp_len = vub300->resp_len;
1717 u8 *r = vub300->resp.response.command_response;
1744 struct vub300_mmc_host *vub300 =
1746 if (!vub300->interface) {
1747 kref_put(&vub300->kref, vub300_delete);
1750 struct mmc_request *req = vub300->req;
1751 struct mmc_command *cmd = vub300->cmd;
1752 struct mmc_data *data = vub300->data;
1754 mutex_lock(&vub300->cmd_mutex);
1755 init_completion(&vub300->command_complete);
1756 if (likely(vub300->vub_name[0]) || !vub300->mmc->card) {
1762 } else if (0 == vub300->mmc->card->sdio_funcs) {
1763 strncpy(vub300->vub_name, "SD memory device",
1764 sizeof(vub300->vub_name));
1766 download_offload_pseudocode(vub300);
1768 send_command(vub300);
1772 data_length = __command_read_data(vub300, cmd, data);
1774 data_length = __command_write_data(vub300, cmd, data);
1775 __vub300_command_response(vub300, cmd, data, data_length);
1776 vub300->req = NULL;
1777 vub300->cmd = NULL;
1778 vub300->data = NULL;
1781 check_vub300_port_status(vub300);
1782 mutex_unlock(&vub300->cmd_mutex);
1783 mmc_request_done(vub300->mmc, req);
1784 kref_put(&vub300->kref, vub300_delete);
1787 construct_request_response(vub300, cmd);
1788 vub300->resp_len = 0;
1789 mutex_unlock(&vub300->cmd_mutex);
1790 kref_put(&vub300->kref, vub300_delete);
1791 mmc_request_done(vub300->mmc, req);
1797 static int examine_cyclic_buffer(struct vub300_mmc_host *vub300,
1805 int first = MAXREGMASK & vub300->fn[Function].offload_point;
1806 struct offload_registers_access *rf = &vub300->fn[Function].reg[first];
1817 vub300->fn[Function].offload_point += 1;
1818 vub300->fn[Function].offload_count -= 1;
1819 vub300->total_offload_count -= 1;
1823 u8 register_count = vub300->fn[Function].offload_count - 1;
1824 u32 register_point = vub300->fn[Function].offload_point + 1;
1828 &vub300->fn[Function].reg[point];
1839 vub300->fn[Function].offload_point += delta;
1840 vub300->fn[Function].offload_count -= delta;
1841 vub300->total_offload_count -= delta;
1854 static int satisfy_request_from_offloaded_data(struct vub300_mmc_host *vub300,
1858 u8 regs = vub300->dynamic_register_count;
1863 if ((vub300->sdio_register[i].func_num == func) &&
1864 (vub300->sdio_register[i].sdio_reg == reg)) {
1865 if (!vub300->sdio_register[i].prepared) {
1872 vub300->sdio_register[i].prepared = 0;
1878 u8 rsp2 = vub300->sdio_register[i].response;
1879 u8 rsp3 = vub300->sdio_register[i].regvalue;
1880 vub300->sdio_register[i].prepared = 0;
1893 if (vub300->total_offload_count == 0)
1895 else if (vub300->fn[func].offload_count == 0)
1898 return examine_cyclic_buffer(vub300, cmd, func);
1904 struct vub300_mmc_host *vub300 = mmc_priv(mmc);
1905 if (!vub300->interface) {
1911 if (!vub300->card_powered) {
1916 if (!vub300->card_present) {
1921 if (vub300->usb_transport_fail) {
1922 cmd->error = vub300->usb_transport_fail;
1926 if (!vub300->interface) {
1931 kref_get(&vub300->kref);
1932 mutex_lock(&vub300->cmd_mutex);
1933 mod_timer(&vub300->inactivity_timer, jiffies + HZ);
1939 satisfy_request_from_offloaded_data(vub300, cmd)) {
1941 mutex_unlock(&vub300->cmd_mutex);
1942 kref_put(&vub300->kref, vub300_delete);
1946 vub300->cmd = cmd;
1947 vub300->req = req;
1948 vub300->data = data;
1950 vub300->datasize = data->blksz * data->blocks;
1952 vub300->datasize = 0;
1953 vub300_queue_cmnd_work(vub300);
1954 mutex_unlock(&vub300->cmd_mutex);
1955 kref_put(&vub300->kref, vub300_delete);
1967 static void __set_clock_speed(struct vub300_mmc_host *vub300, u8 buf[8],
1994 usb_control_msg(vub300->udev, usb_sndctrlpipe(vub300->udev, 0),
1999 dev_err(&vub300->udev->dev, "SET_CLOCK_SPEED"
2002 dev_dbg(&vub300->udev->dev, "SET_CLOCK_SPEED"
2009 struct vub300_mmc_host *vub300 = mmc_priv(mmc);
2010 if (!vub300->interface)
2012 kref_get(&vub300->kref);
2013 mutex_lock(&vub300->cmd_mutex);
2014 if ((ios->power_mode == MMC_POWER_OFF) && vub300->card_powered) {
2015 vub300->card_powered = 0;
2016 usb_control_msg(vub300->udev, usb_sndctrlpipe(vub300->udev, 0),
2022 } else if ((ios->power_mode == MMC_POWER_UP) && !vub300->card_powered) {
2023 usb_control_msg(vub300->udev, usb_sndctrlpipe(vub300->udev, 0),
2028 vub300->card_powered = 1;
2032 __set_clock_speed(vub300, buf, ios);
2038 mutex_unlock(&vub300->cmd_mutex);
2039 kref_put(&vub300->kref, vub300_delete);
2044 struct vub300_mmc_host *vub300 = mmc_priv(mmc);
2045 return vub300->read_only;
2050 struct vub300_mmc_host *vub300 = mmc_priv(mmc);
2051 if (!vub300->interface)
2053 kref_get(&vub300->kref);
2056 mutex_lock(&vub300->irq_mutex);
2057 if (vub300->irqs_queued) {
2058 vub300->irqs_queued -= 1;
2059 mmc_signal_sdio_irq(vub300->mmc);
2060 } else if (vub300->irq_disabled) {
2061 vub300->irq_disabled = 0;
2062 vub300->irq_enabled = 1;
2063 vub300_queue_poll_work(vub300, 0);
2064 } else if (vub300->irq_enabled) {
2067 vub300->irq_enabled = 1;
2068 vub300_queue_poll_work(vub300, 0);
2070 mutex_unlock(&vub300->irq_mutex);
2073 vub300->irq_enabled = 0;
2075 kref_put(&vub300->kref, vub300_delete);
2088 struct vub300_mmc_host *vub300;
2175 vub300 = mmc_priv(mmc);
2176 vub300->mmc = mmc;
2177 vub300->card_powered = 0;
2178 vub300->bus_width = 0;
2179 vub300->cmnd.head.block_size[0] = 0x00;
2180 vub300->cmnd.head.block_size[1] = 0x00;
2181 vub300->app_spec = 0;
2182 mutex_init(&vub300->cmd_mutex);
2183 mutex_init(&vub300->irq_mutex);
2184 vub300->command_out_urb = command_out_urb;
2185 vub300->command_res_urb = command_res_urb;
2186 vub300->usb_timed_out = 0;
2187 vub300->dynamic_register_count = 0;
2189 for (i = 0; i < ARRAY_SIZE(vub300->fn); i++) {
2190 vub300->fn[i].offload_point = 0;
2191 vub300->fn[i].offload_count = 0;
2194 vub300->total_offload_count = 0;
2195 vub300->irq_enabled = 0;
2196 vub300->irq_disabled = 0;
2197 vub300->irqs_queued = 0;
2199 for (i = 0; i < ARRAY_SIZE(vub300->sdio_register); i++)
2200 vub300->sdio_register[i++].activate = 0;
2202 vub300->udev = udev;
2203 vub300->interface = interface;
2204 vub300->cmnd_res_ep = 0;
2205 vub300->cmnd_out_ep = 0;
2206 vub300->data_inp_ep = 0;
2207 vub300->data_out_ep = 0;
2209 for (i = 0; i < ARRAY_SIZE(vub300->fbs); i++)
2210 vub300->fbs[i] = 512;
2221 vub300->large_usb_packets = 0;
2226 dev_info(&vub300->udev->dev,
2227 "vub300 testing %s EndPoint(%d) %02X\n",
2232 vub300->large_usb_packets = 1;
2234 if (!vub300->cmnd_res_ep) {
2235 vub300->cmnd_res_ep =
2237 } else if (!vub300->data_inp_ep) {
2238 vub300->data_inp_ep =
2241 dev_warn(&vub300->udev->dev,
2246 if (!vub300->cmnd_out_ep) {
2247 vub300->cmnd_out_ep =
2249 } else if (!vub300->data_out_ep) {
2250 vub300->data_out_ep =
2253 dev_warn(&vub300->udev->dev,
2258 dev_warn(&vub300->udev->dev,
2259 "vub300 ignoring EndPoint(%d) %02X", i,
2263 if (vub300->cmnd_res_ep && vub300->cmnd_out_ep &&
2264 vub300->data_inp_ep && vub300->data_out_ep) {
2265 dev_info(&vub300->udev->dev,
2266 "vub300 %s packets"
2268 vub300->large_usb_packets ? "LARGE" : "SMALL",
2269 vub300->cmnd_out_ep, vub300->cmnd_res_ep,
2270 vub300->data_out_ep, vub300->data_inp_ep);
2273 dev_err(&vub300->udev->dev,
2279 usb_control_msg(vub300->udev, usb_rcvctrlpipe(vub300->udev, 0),
2282 0x0000, 0x0000, &vub300->hc_info,
2283 sizeof(vub300->hc_info), 1000);
2287 usb_control_msg(vub300->udev, usb_sndctrlpipe(vub300->udev, 0),
2293 dev_info(&vub300->udev->dev,
2299 vub300->large_usb_packets ? 512 : 64);
2301 usb_control_msg(vub300->udev, usb_rcvctrlpipe(vub300->udev, 0),
2304 0x0000, 0x0000, &vub300->system_port_status,
2305 sizeof(vub300->system_port_status), 1000);
2308 } else if (sizeof(vub300->system_port_status) == retval) {
2309 vub300->card_present =
2310 (0x0001 & vub300->system_port_status.port_flags) ? 1 : 0;
2311 vub300->read_only =
2312 (0x0010 & vub300->system_port_status.port_flags) ? 1 : 0;
2317 usb_set_intfdata(interface, vub300);
2318 INIT_DELAYED_WORK(&vub300->pollwork, vub300_pollwork_thread);
2319 INIT_WORK(&vub300->cmndwork, vub300_cmndwork_thread);
2320 INIT_WORK(&vub300->deadwork, vub300_deadwork_thread);
2321 kref_init(&vub300->kref);
2322 timer_setup(&vub300->sg_transfer_timer, vub300_sg_timed_out, 0);
2323 kref_get(&vub300->kref);
2324 timer_setup(&vub300->inactivity_timer,
2326 vub300->inactivity_timer.expires = jiffies + HZ;
2327 add_timer(&vub300->inactivity_timer);
2328 if (vub300->card_present)
2329 dev_info(&vub300->udev->dev,
2330 "USB vub300 remote SDIO host controller[%d]"
2334 dev_info(&vub300->udev->dev,
2335 "USB vub300 remote SDIO host controller[%d]"
2344 del_timer_sync(&vub300->inactivity_timer);
2348 * and hence also frees vub300
2362 struct vub300_mmc_host *vub300 = usb_get_intfdata(interface);
2363 if (!vub300 || !vub300->mmc) {
2366 struct mmc_host *mmc = vub300->mmc;
2367 if (!vub300->mmc) {
2373 vub300->interface = NULL;
2374 kref_put(&vub300->kref, vub300_delete);
2376 pr_info("USB vub300 remote SDIO host controller[%d]"
2399 struct vub300_mmc_host *vub300 = usb_get_intfdata(intf);
2400 mutex_lock(&vub300->cmd_mutex);
2406 struct vub300_mmc_host *vub300 = usb_get_intfdata(intf);
2408 vub300->errors = -EPIPE;
2409 mutex_unlock(&vub300->cmd_mutex);
2414 .name = "vub300",