63#pragma data_alignment=256
64static uint8_t g_ohci_hcca[256];
65#pragma data_alignment=4
74char _is_in_interrupt = 0;
78#define OHCI_CONTROL_INIT \
79 ((OHCI_CTRL_CBSR & 0x3) | OHCI_CTRL_IE | OHCI_CTRL_PLE)
83#define OHCI_UNLINK_TIMEOUT 20
89static void td_submit_urb(
URB_T * urb);
90static int rh_submit_urb(
URB_T *urb);
91static ED_T *ep_add_ed(
USB_DEV_T *usb_dev, uint32_t pipe,
int interval,
int load);
92static int ep_link(ED_T *edi);
93static void ep_rm_ed(
USB_DEV_T *usb_dev, ED_T *ed);
94static int ep_unlink(ED_T *ed);
95static int rh_unlink_urb(
URB_T *urb);
98static int cc_to_error[16] =
124 for (i = 0; i < 32; i++)
125 printf(
"HCCA %02d - 0x%x\n", i, ohci.hcca->int_table[i]);
128static void TD_CompletionCode(uint8_t cc)
133 USB_debug(
"NO ERROR");
136 USB_debug(
"CRC ERROR");
138 case TD_CC_BITSTUFFING:
139 USB_debug(
"BIT STUFFING");
141 case TD_CC_DATATOGGLEM:
142 USB_debug(
"DATA TOGGLE MISMATCH");
148 USB_debug(
"DEVICE NOT RESPONDING");
150 case TD_PIDCHECKFAIL:
151 USB_debug(
"PID CHECK FAILURE");
153 case TD_UNEXPECTEDPID:
154 USB_debug(
"UNEXPECTED PID");
157 USB_debug(
"DATA OVERRUN");
159 case TD_DATAUNDERRUN:
160 USB_debug(
"DATA UNDERRUN");
162 case TD_BUFFEROVERRUN:
163 USB_debug(
"BUFFER OVERRUN");
165 case TD_BUFFERUNDERRUN:
166 USB_debug(
"BUFFER UNDERRUN");
169 USB_debug(
"NOT ACCESSED");
172 USB_debug(
", [0x%02x]\n", cc);
181static void urb_free_priv(URB_PRIV_T *urb_priv)
185 for (i = 0; i < urb_priv->length; i++)
188 ohci_free_td(urb_priv->td[i]);
197#ifdef USB_VERBOSE_DEBUG
198static void urb_print(
URB_T * urb,
char * str,
int small)
207 USB_debug(
"%s URB: no dev\n", str);
211 USB_debug(
"%s - ", str);
216 USB_debug(
"dev:%d, ", usb_pipedevice (pipe));
217 USB_debug(
"ep:%d<%c>, ", usb_pipeendpoint (pipe), usb_pipeout (pipe)?
'O':
'I');
229 if (usb_pipecontrol (pipe))
234 USB_debug(
"GET_STATUS");
237 USB_debug(
"CLEAR_FEATURE");
240 USB_debug(
"SET_FEATURE");
243 USB_debug(
"SET_ADDRESS");
246 USB_debug(
"GET_DESCRIPTOR");
249 USB_debug(
"SET_DESCRIPTOR");
252 USB_debug(
"GET_CONFIGURATION");
255 USB_debug(
"SET_CONFIGURATION");
258 USB_debug(
"GET_INTERFACE");
261 USB_debug(
"SET_INTERFACE");
264 USB_debug(
"SYNC_FRAME");
267 USB_debug(
"Command");
272 for (i = 0; i < 8 ; i++)
273 USB_debug (
" %02x", ((uint8_t *) urb->
setup_packet) [i]);
280 len = usb_pipeout (pipe)?
282 for (i = 0; i < 16 && i < len; i++)
284 USB_debug(
"%s stat:%d\n", i < len? "...": "", urb->status);
295static void ep_print_int_eds()
301 for (i = 0; i < 32; i++)
304 ed_p = &(ohci.hcca->int_table[i]);
307 USB_debug(
"branch %d:", i);
308 while ((*ed_p != 0) && (j--))
310 ed = (ED_T *) (*ed_p);
311 USB_debug(
" ed:%4x;", ed->hwINFO);
312 ed_p = &ed->hwNextED;
325static int sohci_return_urb(
URB_T * urb)
327 URB_PRIV_T *urb_priv;
338#ifdef USB_VERBOSE_DEBUG
339 urb_print (urb,
"RET", usb_pipeout(urb->
pipe));
342 switch (usb_pipetype (urb->
pipe))
349 if ((urb_priv->state != URB_DEL) && (urb->
status == 0))
351 if (urb_priv->state != URB_DEL)
359 case PIPE_ISOCHRONOUS:
361 for (urbt = urb->
next; urbt && (urbt != urb); urbt = urbt->
next);
369 if (urb_priv->state != URB_DEL)
404static int sohci_submit_urb(
URB_T * urb)
406 URB_PRIV_T *urb_priv;
413 USB_info(
"[OHCI] Enter sohci_submit_urb() ...\n");
418 if ((usb_pipeendpoint(pipe) != 0) &&
419 (usb_endpoint_halted(urb->
dev, usb_pipeendpoint (pipe), usb_pipeout (pipe))))
422#ifdef USB_VERBOSE_DEBUG
423 urb_print (urb,
"SUB", usb_pipein (pipe));
427 if (usb_pipedevice(pipe) == ohci.rh.devnum)
428 return rh_submit_urb(urb);
441 switch (usb_pipetype (pipe))
447 case PIPE_ISOCHRONOUS:
474 memset(urb_priv, 0,
sizeof(URB_PRIV_T));
476 for (i = 0; i < size; i++)
478 urb_priv->td[i] = ohci_alloc_td(urb->
dev);
479 if (!urb_priv->td[i])
481 urb_free_priv(urb_priv);
487 urb_priv->length = size;
490 if (ed->state == ED_NEW || (ed->state & ED_DEL))
492 urb_free_priv(urb_priv);
496 if (usb_pipetype(pipe) == PIPE_ISOCHRONOUS)
500 urb->
start_frame = ((ed->state == ED_OPER) ? (ed->last_iso + 1) : (ohci.hcca->frame_no)) & 0xffff;
507 if (pipe == PIPE_INTERRUPT)
508 USB_debug(
"submit: urb: %x, ed: %x\n", (
int)urb, (
int)ed);
511 if (ed->state != ED_OPER)
525static int sohci_unlink_urb (
URB_T * urb)
533#ifdef USB_VERBOSE_DEBUG
534 urb_print (urb,
"UNLINK", 1);
538 if (usb_pipedevice (urb->
pipe) == ohci.rh.devnum)
539 return rh_unlink_urb(urb);
545 URB_PRIV_T * urb_priv;
550 if (!(urb->
transfer_flags & USB_ASYNC_UNLINK) && _is_in_interrupt)
552 USB_error(
"bug in call to sohci_unlink_urb!!\n");
561 if (urb_priv->state == URB_DEL)
564 urb_priv->state = URB_DEL;
566 ep_rm_ed(urb->
dev, urb_priv->ed);
567 urb_priv->ed->state |= ED_URB_DEL;
576 USB_warning(
"unlink URB timeout\n");
608static int sohci_alloc_dev(
USB_DEV_T *usb_dev)
611 OHCI_DEVICE_T *ohcidev;
615 if (ohci_dev_alloc_mark[i] == 0)
617 ohci_dev_alloc_mark[i] = 1;
618 ohcidev = &g_ohci_dev_pool[i];
619 memset((
char *)ohcidev, 0,
sizeof (OHCI_DEVICE_T));
620 usb_dev->hcpriv = ohcidev;
624 USB_error(
"sohci_alloc_dev - no free memory!\n");
633static int sohci_free_dev (
USB_DEV_T * usb_dev)
639 dev = usb_to_ohci(usb_dev);
644 if (usb_dev->devnum >= 0)
650 for (i = 0; i < NUM_EDS; i++)
655 if (ed->state != ED_NEW)
657 if (ed->state == ED_OPER)
660 USB_warning(
"driver dev %d ed 0x%x unfreed URB\n", usb_dev->devnum, i);
663 ep_rm_ed(usb_dev, ed);
685 USB_warning(
"Warning! TD leak, %d\n", cnt);
687 else if (!_is_in_interrupt)
694 USB_error(
"Error! - free device %d timeout", usb_dev->devnum);
701 USB_error(
"Error! - devnum %d deletion in interrupt\nSystem Halt!!", usb_dev->devnum);
706 ohci_free_dev_td(usb_dev);
710 if (&g_ohci_dev_pool[i] == dev)
711 ohci_dev_alloc_mark[i] = 0;
719static int sohci_get_current_frame_number(
USB_DEV_T *usb_dev)
721 return ohci.hcca->frame_no;
726USB_OP_T sohci_device_operations =
730 sohci_get_current_frame_number,
743static int ep_int_ballance (
int interval,
int load)
748 for (i = 0; i < 32; i++)
749 if (ohci.ohci_int_load [branch] > ohci.ohci_int_load [i])
752 branch = branch % interval;
753 for (i = branch; i < 32; i += interval)
754 ohci.ohci_int_load [i] += load;
763static int ep_2_n_interval(
int inter)
767 for (i = 0; ((inter >> i) > 1 ) && (i < 5); i++);
777static int ep_rev(
int num_bits,
int word)
781 for (i = 0; i < num_bits; i++)
782 wout |= (((word >> i) & 1) << (num_bits - i - 1));
792static int ep_link(ED_T *edi)
808 if (ohci.ed_controltail ==
NULL)
809 USBH->HcControlHeadED = (uint32_t)ed;
811 ohci.ed_controltail->hwNextED = (uint32_t)ed;
812 ed->ed_prev = ohci.ed_controltail;
813 if (!ohci.ed_controltail && !ohci.ed_rm_list[0] && (!ohci.ed_rm_list[1]))
815 ohci.hc_control |= OHCI_CTRL_CLE;
816 USBH->HcControl = ohci.hc_control;
818 ohci.ed_controltail = edi;
823 if (ohci.ed_bulktail ==
NULL)
824 USBH->HcBulkHeadED = (uint32_t)ed;
826 ohci.ed_bulktail->hwNextED = (uint32_t)ed;
827 ed->ed_prev = ohci.ed_bulktail;
828 if (!ohci.ed_bulktail && !ohci.ed_rm_list[0] && (!ohci.ed_rm_list[1]))
830 ohci.hc_control |= OHCI_CTRL_BLE;
831 USBH->HcControl = ohci.hc_control;
833 ohci.ed_bulktail = edi;
838 interval = ep_2_n_interval(ed->int_period);
839 ed->int_interval = interval;
840 int_branch = ep_int_ballance(interval, load);
841 ed->int_branch = int_branch;
843 for (i = 0; i < ep_rev(6, interval); i += inter)
847 for (ed_p = &(ohci.hcca->int_table[ep_rev (5,i) + int_branch]);
848 (*ed_p != 0) && (((ED_T *) (*ed_p))->int_interval >= interval);
849 ed_p = &(((ED_T *) (*ed_p))->hwNextED))
850 inter = ep_rev(6, ((ED_T *) (*ed_p))->int_interval);
851 ed->hwNextED = *ed_p;
852 *ed_p = (uint32_t)ed;
856 case PIPE_ISOCHRONOUS:
858 ed->int_interval = 1;
859 if (ohci.ed_isotail !=
NULL)
861 ohci.ed_isotail->hwNextED = (uint32_t)ed;
862 ed->ed_prev = ohci.ed_isotail;
866 for ( i = 0; i < 32; i += inter)
869 for (ed_p = &(ohci.hcca->int_table[ep_rev (5, i)]);
870 (*ed_p != 0) && ed_p; ed_p = &(((ED_T *) (*ed_p))->hwNextED))
871 inter = ep_rev (6, ((ED_T *) (*ed_p))->int_interval);
872 *ed_p = (uint32_t)ed;
876 ohci.ed_isotail = edi;
889static int ep_unlink(ED_T *ed)
894 ed->hwINFO |= OHCI_ED_SKIP;
898 if (ed->ed_prev ==
NULL)
902 ohci.hc_control &= ~OHCI_CTRL_CLE;
903 USBH->HcControl = ohci.hc_control;
905 USBH->HcControlHeadED = ed->hwNextED;
908 ed->ed_prev->hwNextED = ed->hwNextED;
910 if (ohci.ed_controltail == ed)
911 ohci.ed_controltail = ed->ed_prev;
913 ((ED_T *)(ed->hwNextED))->ed_prev = ed->ed_prev;
917 if (ed->ed_prev ==
NULL)
921 ohci.hc_control &= ~OHCI_CTRL_BLE;
922 USBH->HcControl = ohci.hc_control;
924 USBH->HcBulkHeadED = ed->hwNextED;
927 ed->ed_prev->hwNextED = ed->hwNextED;
929 if (ohci.ed_bulktail == ed)
930 ohci.ed_bulktail = ed->ed_prev;
932 ((ED_T *)(ed->hwNextED))->ed_prev = ed->ed_prev;
935 case PIPE_ISOCHRONOUS:
937 if (ohci.ed_isotail == ed)
938 ohci.ed_isotail = ed->ed_prev;
939 if (ed->hwNextED != 0)
940 ((ED_T *)ed->hwNextED)->ed_prev = ed->ed_prev;
942 if (ed->ed_prev !=
NULL)
944 ed->ed_prev->hwNextED = ed->hwNextED;
950 for (i = 0; i < 32; i++)
952 for (ed_ptr = (uint32_t *)&(ohci.hcca->int_table[i]);
953 (*ed_ptr != 0); ed_ptr = (uint32_t *) &(((ED_T *) (*ed_ptr))->hwNextED))
955 if (ed_ptr == (uint32_t *) &(((ED_T *) (*ed_ptr))->hwNextED))
958 if ((ED_T *)*ed_ptr == ed)
960 *ed_ptr = (uint32_t) (((ED_T *) (*ed_ptr))->hwNextED);
968 ed->state = ED_UNLINK;
981static ED_T *ep_add_ed(
USB_DEV_T *usb_dev, uint32_t pipe,
int interval,
int load)
985 OHCI_DEVICE_T *ohci_dev;
989 ohci_dev = usb_to_ohci(usb_dev);
990 ep_num = (((pipe) >> 15) & 0xf);
994 if (ohci_dev->edp[ep_num] ==
NULL)
995 ohci_dev->edp[ep_num] = ohci_alloc_ed();
997 if (ohci_dev->edp[ep_num] ==
NULL)
1002 ed = ed_ret = ohci_dev->edp[ep_num];
1004 if ((ed->state & ED_DEL) || (ed->state & ED_URB_DEL))
1007 if (ed->state == ED_NEW)
1009 ed->hwINFO = OHCI_ED_SKIP;
1011 td = ohci_alloc_td(usb_dev);
1015 ed->hwTailP = (uint32_t)td;
1016 ed->hwHeadP = ed->hwTailP;
1017 ed->state = ED_UNLINK;
1018 ed->type = usb_pipetype(pipe);
1019 usb_to_ohci (usb_dev)->ed_cnt++;
1022 ohci.dev[usb_pipedevice(pipe)] = usb_dev;
1024 ed->hwINFO = (usb_pipedevice (pipe)
1025 | usb_pipeendpoint (pipe) << 7
1026 | (usb_pipeisoc (pipe)? 0x8000: 0)
1027 | (usb_pipecontrol (pipe)? 0: (usb_pipeout (pipe)? 0x800: 0x1000))
1028 | usb_pipeslow (pipe) << 13
1029 | usb_maxpacket(usb_dev, pipe, usb_pipeout(pipe)) << 16);
1031 if ((ed->type == PIPE_INTERRUPT) && (ed->state == ED_UNLINK))
1033 ed->int_period = interval;
1034 ed->int_load = load;
1047static void ep_rm_ed(
USB_DEV_T *usb_dev, ED_T *ed)
1051 if ((ed->state & ED_DEL) || (ed->state & ED_URB_DEL))
1054 ed->hwINFO |= OHCI_ED_SKIP;
1061 ohci.hc_control &= ~OHCI_CTRL_CLE;
1062 USBH->HcControl = ohci.hc_control;
1065 ohci.hc_control &= ~OHCI_CTRL_BLE;
1066 USBH->HcControl = ohci.hc_control;
1070 frame = ohci.hcca->frame_no & 0x1;
1071 ed->ed_rm_list = ohci.ed_rm_list[frame];
1072 ohci.ed_rm_list[frame] = ed;
1077 USBH->HcInterruptStatus = OHCI_INTR_SF;
1078 USBH->HcInterruptEnable = OHCI_INTR_SF;
1087static void iso_td_fill(uint32_t info,
void *data,
URB_T *urb,
int index)
1089 volatile TD_T *td, *td_pt;
1090 volatile URB_PRIV_T *urb_priv;
1092 uint32_t bufferStart;
1096 if (index >= urb_priv->length)
1098 USB_error(
"Error! - internal OHCI error: TD index > length\n");
1102 td_pt = urb_priv->td[index];
1105 td = urb_priv->td[index] = (TD_T *)((uint32_t)urb_priv->ed->hwTailP & 0xfffffff0);
1107 td->ed = urb_priv->ed;
1110 td->next_dl_td =
NULL;
1121 td->hwCBP = (uint32_t)((!bufferStart || !len) ? 0 : bufferStart) & 0xFFFFF000;
1122 td->hwBE = (uint32_t)((!bufferStart || !len ) ? 0 : (bufferStart + len -1));
1123 td->hwNextTD = (uint32_t)td_pt;
1124 td->is_iso_packet = 1;
1126#ifdef DELAY_INTERRUPT
1127 info = (info & 0xFF1FFFFF) | (3 << 21);
1135 td->hwPSW[i] |= 0xE000E000;
1138 USB_info(
"Frame:[%x], CBP:[%x], BE:[%x], PSW0:[%x], PSW1:[%x]\n",
1139 td->hwINFO & 0xffff, td->hwCBP, td->hwBE, td->hwPSW[0], td->hwPSW[1]);
1142 td_pt->hwNextTD = 0;
1143 td->ed->hwTailP = td->hwNextTD;
1149static void td_fill(uint32_t info,
void *data,
int len,
URB_T *urb,
int index)
1151 volatile TD_T *td, *td_pt;
1152 volatile URB_PRIV_T *urb_priv;
1156 if (index >= urb_priv->length)
1158 USB_error(
"Error! - internal OHCI error: TD index > length\n");
1162 td_pt = urb_priv->td[index];
1165 td = urb_priv->td[index] = (TD_T *)((uint32_t)urb_priv->ed->hwTailP & 0xfffffff0);
1166 td->ed = urb_priv->ed;
1167 td->next_dl_td =
NULL;
1172 td->hwCBP = (uint32_t)((!data || !len) ? 0 : data);
1173 td->hwBE = (uint32_t)((!data || !len ) ? 0 : (uint32_t)data + len - 1);
1174 td->hwNextTD = (uint32_t)td_pt;
1175 td->is_iso_packet = 0;
1177#ifdef DELAY_INTERRUPT
1178 info = (info & 0xFF1FFFFF) | (3 << 21);
1181 td_pt->hwNextTD = 0;
1182 td->ed->hwTailP = td->hwNextTD;
1191static void td_submit_urb(
URB_T * urb)
1193 URB_PRIV_T *urb_priv;
1199 uint32_t toggle = 0;
1206 if (usb_gettoggle(urb->
dev, usb_pipeendpoint(urb->
pipe), usb_pipeout(urb->
pipe)))
1208 toggle = TD_T_TOGGLE;
1212 toggle = TD_T_DATA0;
1213 usb_settoggle(urb->
dev, usb_pipeendpoint(urb->
pipe), usb_pipeout(urb->
pipe), 1);
1216 urb_priv->td_cnt = 0;
1218 switch (usb_pipetype (urb->
pipe))
1221 info = usb_pipeout(urb->
pipe)? (TD_CC | TD_DP_OUT) : (TD_CC | TD_DP_IN);
1222 while(data_len > 4096)
1224 td_fill(info | (cnt? TD_T_TOGGLE:toggle), data, 4096, urb, cnt);
1225 data = (
void *)((uint32_t)data + 4096);
1229 info = usb_pipeout(urb->
pipe)? (TD_CC | TD_DP_OUT) : (TD_CC | TD_R | TD_DP_IN);
1230 td_fill(info | (cnt? TD_T_TOGGLE:toggle), data, data_len, urb, cnt);
1232 USBH->HcCommandStatus = OHCI_BLF;
1235 case PIPE_INTERRUPT:
1236 info = usb_pipeout (urb->
pipe)? (TD_CC | TD_DP_OUT | toggle) : (TD_CC | TD_R | TD_DP_IN | toggle);
1237 td_fill(info, data, data_len, urb, cnt++);
1241 info = TD_CC | TD_DP_SETUP | TD_T_DATA0;
1242 td_fill(info, ctrl, 8, urb, cnt++);
1245 info = usb_pipeout (urb->
pipe)? (TD_CC | TD_R | TD_DP_OUT | TD_T_DATA1) : (TD_CC | TD_R | TD_DP_IN | TD_T_DATA1);
1246 td_fill(info, data, data_len, urb, cnt++);
1248 info = usb_pipeout (urb->
pipe)? (TD_CC | TD_DP_IN | TD_T_DATA1): (TD_CC | TD_DP_OUT | TD_T_DATA1);
1249 td_fill(info,
NULL, 0, urb, cnt++);
1250 USBH->HcCommandStatus = OHCI_CLF;
1253 case PIPE_ISOCHRONOUS:
1257 (uint8_t *) data, urb, cnt);
1261 if (urb_priv->length != cnt)
1262 USB_error(
"Error! - TD LENGTH %d != CNT %d", urb_priv->length, cnt);
1272static void dl_transfer_length(TD_T * td)
1274 uint32_t tdBE, tdCBP;
1277 URB_PRIV_T *urb_priv;
1284 tdBE = (uint32_t)td->hwBE;
1285 tdCBP = (uint32_t)td->hwCBP;
1287 if (td->is_iso_packet)
1296 tdPSW = td->hwPSW[i / 2] >> 16;
1298 tdPSW = td->hwPSW[i / 2] & 0xffff;
1300 cc = (tdPSW >> 12) & 0xF;
1303 if (usb_pipeout(urb->
pipe))
1306 dlen = tdPSW & 0x3ff;
1310 if (!(urb->
transfer_flags & USB_DISABLE_SPD) && (cc == TD_DATAUNDERRUN))
1319 if (!(usb_pipetype (urb->
pipe) == PIPE_CONTROL &&
1320 ((td->index == 0) || (td->index == urb_priv->length - 1))))
1330 USB_info(
"td:%x urb->actual_length:%d\n", (
int)td, urb->
actual_length);
1337static void dl_del_urb(
URB_T * urb)
1357static TD_T *dl_reverse_done_list()
1359 uint32_t td_list_hc;
1360 TD_T *td_rev =
NULL;
1361 TD_T *td_list =
NULL;
1362 URB_PRIV_T *urb_priv;
1364 td_list_hc = (uint32_t)(ohci.hcca->done_head) & 0xfffffff0;
1365 ohci.hcca->done_head = 0;
1369 td_list = (TD_T *)td_list_hc;
1370 USB_info(
"TD done - 0x%08x, DEV:[%d], ED:[%d] PSW:[%x]\n", (uint32_t)td_list, td_list->urb->dev->devnum, (td_list->ed->hwINFO>>7)&0xf, td_list->hwPSW[0] >> 12);
1372#ifdef USB_VERBOSE_DEBUG
1373 if (td_list->ed->hwHeadP & 0x1)
1374 USB_error(
"!!Halted - DEV:[%d], ED:[%d] PSW0:[%x] PSW1:[%x]\n",
1375 td_list->urb->dev->devnum, (td_list->ed->hwINFO>>7)&0xf,
1376 (td_list->hwPSW[0] >> 12) & 0xf, (td_list->hwPSW[0] >> 28) & 0xf);
1379 if (TD_CC_GET((uint32_t)td_list->hwINFO))
1381 urb_priv = &(td_list->urb->urb_hcpriv);
1383 if (td_list->ed->type == PIPE_ISOCHRONOUS)
1385 if ((td_list->hwINFO & 0xE0000000) == 0x80000000)
1391 USB_error(
"ISO! - CC:0x%x, PSW:0x%x 0x%x\n", td_list->hwINFO >> 28, td_list->hwPSW[0], td_list->hwPSW[1]);
1395 USB_error(
"CC Error!! - DEV[%d] ED[%d] - ", td_list->urb->dev->devnum, (td_list->ed->hwINFO >> 7) & 0xf);
1396 TD_CompletionCode(TD_CC_GET((uint32_t)(td_list->hwINFO)));
1399 if (td_list->ed->hwHeadP & 0x1)
1401 if (urb_priv && ((td_list->index + 1) < urb_priv->length))
1403 td_list->ed->hwHeadP = (urb_priv->td[urb_priv->length - 1]->hwNextTD & 0xfffffff0) |
1404 (td_list->ed->hwHeadP & 0x2);
1405 urb_priv->td_cnt += urb_priv->length - td_list->index - 1;
1408 td_list->ed->hwHeadP &= 0xfffffff2;
1412 td_list->next_dl_td = td_rev;
1414 td_list_hc = (uint32_t)(td_list->hwNextTD) & 0xfffffff0;
1425static void dl_del_list(uint32_t frame)
1434 for (ed = ohci.ed_rm_list[frame]; ed !=
NULL; ed = ed->ed_rm_list)
1436 tdTailP = (TD_T *)((uint32_t)(ed->hwTailP) & 0xfffffff0);
1437 tdHeadP = (TD_T *)((uint32_t)(ed->hwHeadP) & 0xfffffff0);
1438 edINFO = (uint32_t)ed->hwINFO;
1439 td_p = &ed->hwHeadP;
1441 for (td = tdHeadP; td != tdTailP; td = td_next)
1443 URB_T * urb = td->urb;
1444 URB_PRIV_T * urb_priv = &(td->urb->urb_hcpriv);
1446 td_next = (TD_T *)((uint32_t)(td->hwNextTD) & 0xfffffff0);
1447 if ((urb_priv->state == URB_DEL) || (ed->state & ED_DEL))
1449 tdINFO = (uint32_t)td->hwINFO;
1450 if (TD_CC_GET (tdINFO) < 0xE)
1451 dl_transfer_length(td);
1452 *td_p = td->hwNextTD | (*td_p & 0x3);
1455 if (++(urb_priv->td_cnt) == urb_priv->length)
1460 td_p = &td->hwNextTD;
1464 if (ed->state & ED_DEL)
1467 OHCI_DEVICE_T * dev = usb_to_ohci (ohci.dev[edINFO & 0x7F]);
1468 ohci_free_td(tdTailP);
1469 ed->hwINFO = OHCI_ED_SKIP;
1476 ed->state &= ~ED_URB_DEL;
1477 tdHeadP = (TD_T *)((uint32_t)(ed->hwHeadP) & 0xfffffff0);
1478 if (tdHeadP == tdTailP)
1480 if (ed->state == ED_OPER)
1482 ohci_free_td(tdTailP);
1483 ed->hwINFO = OHCI_ED_SKIP;
1485 --(usb_to_ohci (ohci.dev[edINFO & 0x7F]))->ed_cnt;
1488 ed->hwINFO &= ~OHCI_ED_SKIP;
1506 USBH->HcControlCurrentED = 0;
1508 USBH->HcBulkCurrentED = 0;
1509 if (!ohci.ed_rm_list[!frame])
1511 if (ohci.ed_controltail)
1512 ohci.hc_control |= OHCI_CTRL_CLE;
1513 if (ohci.ed_bulktail)
1514 ohci.hc_control |= OHCI_CTRL_BLE;
1515 USBH->HcControl = ohci.hc_control;
1519 ohci.ed_rm_list[frame] =
NULL;
1527static void dl_done_list(TD_T *td_list)
1529 TD_T *td_list_next =
NULL;
1533 URB_PRIV_T *urb_priv;
1534 uint32_t tdINFO, edHeadP, edTailP;
1538 td_list_next = td_list->next_dl_td;
1542 tdINFO = (uint32_t)(td_list->hwINFO);
1546 dl_transfer_length(td_list);
1549 cc = TD_CC_GET (tdINFO);
1550 if (cc == TD_CC_STALL)
1551 usb_endpoint_halt(urb->
dev, usb_pipeendpoint(urb->
pipe), usb_pipeout(urb->
pipe));
1553 if (!(urb->
transfer_flags & USB_DISABLE_SPD) && (cc == TD_DATAUNDERRUN))
1556 if (++(urb_priv->td_cnt) == urb_priv->length)
1558 if ((ed->state & (ED_OPER | ED_UNLINK)) && (urb_priv->state != URB_DEL))
1560 urb->
status = cc_to_error[cc];
1561 sohci_return_urb(urb);
1568 if (ed->state != ED_NEW)
1570 edHeadP = (uint32_t)(ed->hwHeadP) & 0xfffffff0;
1571 edTailP = (uint32_t)(ed->hwTailP);
1574 if ((edHeadP == edTailP) && (ed->state == ED_OPER))
1579 td_list = td_list_next;
1589static uint8_t root_hub_dev_des[] =
1613static uint8_t root_hub_config_des[] =
1654static int rh_send_irq(
void *rh_data,
int rh_len)
1662 num_ports =
USBH->HcRhDescriptorA & RH_A_NDP;
1665 *(uint8_t *)data = (
USBH->HcRhStatus & (RH_HS_LPSC | RH_HS_OCIC)) ? 1: 0;
1666 ret = *(uint8_t *)data;
1669 for ( i = 0; i < num_ports; i++)
1671 *(uint8_t *)(data + (i + 1) / 8) |= ((
USBH->HcRhPortStatus[i] &
1672 (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC | RH_PS_OCIC | RH_PS_PRSC))
1673 ? 1: 0) << ((i + 1) % 8);
1674 ret += *(uint8_t *)(data + (i + 1) / 8);
1680 memcpy(rh_data, data, min(len, min (rh_len,
sizeof(data))));
1687static URB_T *_OHCI_RH_IRQ;
1691void ohci_int_timer_do(
int ptr)
1694 URB_T *urb = _OHCI_RH_IRQ;
1702#ifdef USB_VERBOSE_DEBUG
1703 urb_print(urb,
"RET-t(rh)", usb_pipeout (urb->
pipe));
1714static int ascii2utf(
char *ascii, uint8_t *utf,
int utfmax)
1718 for (retval = 0; *ascii && utfmax > 1; utfmax -= 2, retval += 2)
1720 *utf++ = *ascii++ & 0x7f;
1732static int usbh_root_hub_string(
int id,
int serial,
char *type, uint8_t *data,
int len)
1748 sprintf (buf,
"%x", serial);
1753 sprintf (buf,
"USB %s Root Hub", type);
1760 data [0] = 2 + ascii2utf(buf, data + 2, len - 2);
1768#define RH_OK(x) len = (x); break
1769#define WR_RH_STAT(x) (USBH->HcRhStatus = (x))
1770#define WR_RH_PORTSTAT(x) (USBH->HcRhPortStatus[wIndex-1] = (x))
1771#define RD_RH_STAT (USBH->HcRhStatus)
1772#define RD_RH_PORTSTAT (USBH->HcRhPortStatus[wIndex-1])
1776static int rh_submit_urb(
URB_T *urb)
1783 int status = TD_CC_NOERROR;
1786 uint16_t bmRType_bReq;
1795 data_buf = (uint8_t *) datab;
1797 if (usb_pipeint(pipe))
1804 ohci_int_timer_do(0);
1810 bmRType_bReq = (cmd->requesttype << 8) | cmd->request;
1811 wValue = cmd->value;
1812 wIndex = cmd->index;
1813 wLength = cmd->length;
1814 USB_info(
"rh_submit_urb, req = 0x%x len=%d\n", bmRType_bReq, wLength);
1816#ifdef USB_VERBOSE_DEBUG
1817 USB_debug(
"Command - ");
1818 switch (bmRType_bReq & 0x80FF)
1821 USB_debug(
"GET_STATUS\n");
1824 case RH_CLEAR_FEATURE:
1825 USB_debug(
"CLEAR_FEATURE\n");
1828 case RH_SET_FEATURE:
1829 USB_debug(
"SET_FEATURE\n");
1832 case RH_SET_ADDRESS:
1833 USB_debug(
"SET_ADDRESS\n");
1836 case RH_GET_DESCRIPTOR:
1837 USB_debug(
"GET_DESCRIPTOR\n");
1840 case RH_SET_DESCRIPTOR:
1841 USB_debug(
"SET_DESCRIPTOR\n");
1844 case RH_GET_CONFIGURATION:
1845 USB_debug(
"GET_CONFIGURATION\n");
1848 case RH_SET_CONFIGURATION:
1849 USB_debug(
"RH_SET_CONFIGURATION\n");
1853 USB_debug(
"GET_STATE\n");
1856 case RH_GET_INTERFACE:
1857 USB_debug(
"GET_INTERFACE\n");
1860 case RH_SET_INTERFACE:
1861 USB_debug(
"SET_INTERFACE\n");
1865 USB_debug(
"SYNC_FRAME\n");
1869 USB_debug(
"SET_EP\n");
1874 switch (bmRType_bReq)
1885 *(uint16_t *) data_buf = USB_SWAP16(1);
1888 case RH_GET_STATUS | RH_INTERFACE:
1889 *(uint16_t *) data_buf = 0;
1892 case RH_GET_STATUS | RH_ENDPOINT:
1893 *(uint16_t *) data_buf = 0;
1896 case RH_GET_STATUS | RH_CLASS:
1898 data_buf[0] = RD_RH_STAT & 0xFF;
1899 data_buf[1] = (RD_RH_STAT >> 8) & 0xFF;
1900 data_buf[2] = (RD_RH_STAT >> 16) & 0xFF;
1901 data_buf[3] = (RD_RH_STAT >> 24) & 0xFF;
1902 *(uint32_t *) data_buf = RD_RH_STAT & ~(RH_HS_CRWE | RH_HS_DRWE);
1905 case RH_GET_STATUS | RH_OTHER | RH_CLASS:
1906 *(uint32_t *) data_buf = RD_RH_PORTSTAT;
1909 case RH_CLEAR_FEATURE | RH_ENDPOINT:
1912 case (RH_ENDPOINT_STALL):
1917 case RH_CLEAR_FEATURE | RH_CLASS:
1920 case RH_C_HUB_LOCAL_POWER:
1922 case (RH_C_HUB_OVER_CURRENT):
1923 WR_RH_STAT(RH_HS_OCIC);
1928 case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
1931 case (RH_PORT_ENABLE):
1932 WR_RH_PORTSTAT (RH_PS_CCS );
1934 case (RH_PORT_SUSPEND):
1935 WR_RH_PORTSTAT (RH_PS_POCI);
1937 case (RH_PORT_POWER):
1938 WR_RH_PORTSTAT (RH_PS_LSDA);
1940 case (RH_C_PORT_CONNECTION):
1941 WR_RH_PORTSTAT (RH_PS_CSC );
1943 case (RH_C_PORT_ENABLE):
1944 WR_RH_PORTSTAT (RH_PS_PESC);
1946 case (RH_C_PORT_SUSPEND):
1947 WR_RH_PORTSTAT (RH_PS_PSSC);
1949 case (RH_C_PORT_OVER_CURRENT):
1950 WR_RH_PORTSTAT (RH_PS_OCIC);
1952 case (RH_C_PORT_RESET):
1953 WR_RH_PORTSTAT (RH_PS_PRSC);
1958 case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
1961 case (RH_PORT_SUSPEND):
1962 WR_RH_PORTSTAT (RH_PS_PSS );
1965 case (RH_PORT_RESET):
1966 if (RD_RH_PORTSTAT & RH_PS_CCS)
1967 WR_RH_PORTSTAT (RH_PS_PRS);
1970 case (RH_PORT_POWER):
1971 WR_RH_PORTSTAT (RH_PS_PPS );
1974 case (RH_PORT_ENABLE):
1975 if (RD_RH_PORTSTAT & RH_PS_CCS)
1976 WR_RH_PORTSTAT (RH_PS_PES );
1981 case RH_SET_ADDRESS:
1982 ohci.rh.devnum = wValue;
1985 case RH_GET_DESCRIPTOR:
1986 switch ((wValue & 0xff00) >> 8)
1989 len = min (leni, min (
sizeof (root_hub_dev_des), wLength));
1990 data_buf = root_hub_dev_des;
1994 len = min (leni, min (
sizeof (root_hub_config_des), wLength));
1995 data_buf = root_hub_config_des;
1999 len = usbh_root_hub_string(wValue & 0xff, 0x0,
"OHCI", data, wLength);
2003 RH_OK(min (leni, len));
2007 status = TD_CC_STALL;
2011 case RH_GET_DESCRIPTOR | RH_CLASS:
2013 uint32_t temp =
USBH->HcRhDescriptorA;
2016 data_buf [1] = 0x29;
2017 data_buf [2] = temp & RH_A_NDP;
2019 if (temp & RH_A_PSM)
2020 data_buf [3] |= 0x1;
2021 if (temp & RH_A_NOCP)
2022 data_buf [3] |= 0x10;
2023 else if (temp & RH_A_OCPM)
2024 data_buf [3] |= 0x8;
2027 data_buf [5] = (temp & RH_A_POTPGT) >> 24;
2028 temp =
USBH->HcRhDescriptorB;
2029 data_buf [7] = temp & RH_B_DR;
2030 if (data_buf [2] < 7)
2032 data_buf [8] = 0xff;
2037 data_buf [8] = (temp & RH_B_DR) >> 8;
2038 data_buf [10] = data_buf [9] = 0xff;
2040 len = min (leni, min (data_buf [0], wLength));
2044 case RH_GET_CONFIGURATION:
2045 *(uint8_t *) data_buf = 0x01;
2048 case RH_SET_CONFIGURATION:
2049 WR_RH_STAT(0x10000);
2054 status = TD_CC_STALL;
2057 len = min(len, leni);
2058 if (data != data_buf)
2059 memcpy(data, data_buf, len);
2061 urb->
status = cc_to_error[status];
2072static int rh_unlink_urb(
URB_T *urb)
2074 if (ohci.rh.urb == urb)
2098static int ohci_reset()
2103 USBH->HcInterruptDisable = OHCI_INTR_MIE;
2106 USBH->HcControl = 0;
2109 USBH->HcCommandStatus = OHCI_HCR;
2111 while ((
USBH->HcCommandStatus & OHCI_HCR) != 0)
2115 USB_error(
"Error! - USB HC reset timed out!\n");
2120 USBH->HcControl = (
USBH->HcControl & 0xffffff3f) | OHCI_USB_RESET;
2127void USBH_IRQHandler(
void)
2131 _is_in_interrupt = 1;
2133 ints =
USBH->HcInterruptStatus;
2137 if ((ohci.hcca->done_head != 0) && !((uint32_t)(ohci.hcca->done_head) & 0x01))
2139 ints = OHCI_INTR_WDH;
2142 if (ints & OHCI_INTR_UE)
2145 USB_error(
"Error! - OHCI Unrecoverable Error, controller disabled\n");
2156 if (ints & OHCI_INTR_OC)
2158 USB_debug(
"Ownership change!!\n");
2161 if (ints & OHCI_INTR_WDH)
2163 dl_done_list(dl_reverse_done_list());
2164 USBH->HcInterruptStatus = OHCI_INTR_WDH;
2167 if (ints & OHCI_INTR_SO)
2172 USBH->HcInterruptDisable = OHCI_INTR_SO;
2173 USBH->HcInterruptStatus = OHCI_INTR_SO;
2176 if (ints & OHCI_INTR_SF)
2178 uint32_t frame = ohci.hcca->frame_no & 1;
2180 USBH->HcInterruptDisable = OHCI_INTR_SF;
2181 if (ohci.ed_rm_list[!frame] !=
NULL)
2183 dl_del_list(!frame);
2185 if (ohci.ed_rm_list[frame] !=
NULL)
2186 USBH->HcInterruptEnable = OHCI_INTR_SF;
2189 if (ints & OHCI_INTR_RHSC)
2191 USBH->HcInterruptDisable = OHCI_INTR_RHSC;
2192 USBH->HcInterruptStatus = OHCI_INTR_RHSC;
2195 if (ints & OHCI_INTR_RD)
2197 USBH->HcInterruptDisable = OHCI_INTR_RD;
2198 USBH->HcInterruptStatus = OHCI_INTR_RD;
2201 ints &= ~OHCI_INTR_WDH;
2202 USBH->HcInterruptEnable = OHCI_INTR_MIE;
2205 _is_in_interrupt = 0;
2215static int hc_start ()
2218 uint32_t fminterval;
2225 for (i = 0; i < NUM_INTS; i++)
2226 ohci.ohci_int_load[i] = 0;
2227 for (i = 0; i < NUM_INTS; i++)
2228 ohci.hcca->int_table[i] = 0;
2231 ohci.ed_rm_list [0] =
NULL;
2232 ohci.ed_rm_list [1] =
NULL;
2235 ohci.ed_isotail =
NULL;
2236 ohci.ed_controltail =
NULL;
2237 ohci.ed_bulktail =
NULL;
2241 USBH->HcControlHeadED = 0;
2242 USBH->HcBulkHeadED = 0;
2244 USBH->HcHCCA = (uint32_t)ohci.hcca;
2246 fminterval = 0x2edf;
2249 USBH->HcPeriodicStart = (fminterval * 9) / 10;
2252 fminterval |= ((((fminterval - 210) * 6) / 7) << 16);
2253 USBH->HcFmInterval = fminterval;
2255 USBH->HcLSThreshold = 0x628;
2258 ohci.hc_control = OHCI_CONTROL_INIT | OHCI_USB_OPER;
2260 USBH->HcControl = ohci.hc_control;
2263 mask = OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_WDH | OHCI_INTR_SO;
2264 USBH->HcInterruptEnable = mask;
2265 USBH->HcInterruptStatus = mask;
2268 USBH->HcRhDescriptorA = (
USBH->HcRhDescriptorA | RH_A_NPS) & ~RH_A_PSM;
2269 USBH->HcRhStatus = RH_HS_LPSC;
2272 usbh_mdelay((
USBH->HcRhDescriptorA >> 23) & 0x1fe);
2276 usb_dev = usbh_alloc_device(
NULL, ohci.bus);
2283 ohci.bus->root_hub = usb_dev;
2284 usbh_connect_device(usb_dev);
2285 if (usbh_settle_new_device(usb_dev) != 0)
2287 usbh_free_device(usb_dev);
2296static void hc_restart()
2302 if (ohci.bus->root_hub)
2303 usbh_disconnect_device(&ohci.bus->root_hub);
2306 for (i = 0; i < NUM_INTS; i++)
2307 ohci.ohci_int_load[i] = 0;
2308 for (i = 0; i < NUM_INTS; i++)
2309 ohci.hcca->int_table[i] = 0;
2312 ohci.ed_rm_list [0] =
NULL;
2313 ohci.ed_rm_list [1] =
NULL;
2316 ohci.ed_isotail =
NULL;
2317 ohci.ed_controltail =
NULL;
2318 ohci.ed_bulktail =
NULL;
2320 if ((temp = ohci_reset()) < 0 || (temp = hc_start ()) < 0)
2321 USB_error(
"Error! - can't restart usb-%s, %d\n",
"ohci->ohci_dev->slot_name", temp);
2323 USB_error(
"Error! - restart usb-%s completed\n",
"ohci->ohci_dev->slot_name");
2334 if (
sizeof(ED_T) != 32)
2336 USB_error(
"Wrong ED_T size!!!\n");
2340 if (
sizeof(TD_T) != 64)
2342 USB_error(
"Wrong TD_T size!!!\n");
2346 memset((
char *)&ohci, 0,
sizeof(OHCI_T));
2347 ohci.hcca = (OHCI_HCCA_T *)g_ohci_hcca;
2348 memset((
char *)ohci.hcca, 0, 256);
2351 ohci_dev_alloc_mark[i] = 0;
2355 if (ohci_reset() < 0)
2358 ohci.hc_control = OHCI_USB_RESET;
2359 USBH->HcControl = ohci.hc_control;
2367 g_ohci_bus.op = &sohci_device_operations;
2368 g_ohci_bus.root_hub =
NULL;
2369 g_ohci_bus.hcpriv = &ohci;
2370 ohci.bus = &g_ohci_bus;
2374 USB_error(
"Error! - can't start OHCI!\n");
void *__dso_handle __attribute__((weak))
NUC472/NUC442 peripheral access layer header file. This file contains all the peripheral register's d...
#define CC_ERR_NORESPONSE
#define CC_ERR_DATAUNDERRUN
#define CC_ERR_DATA_TOGGLE
#define MAX_TD_PER_OHCI_URB
#define CC_ERR_NOT_DEFINED
#define USB_ERR_INPROGRESS
#define CC_ERR_BUFFERUNDERRUN
#define CC_ERR_NOT_ACCESS
#define CC_ERR_BUFFEROVERRUN
#define USB_ERR_CONNRESET
#define CC_ERR_DATAOVERRUN
#define CC_ERR_INVALID_PID
#define USB_ERR_URB_PENDING
int transfer_buffer_length
ISO_PACKET_DESCRIPTOR_T iso_frame_desc[8]
void(* complete)(struct urb_t *)
HIDDEN_SYMBOLS struct usb_device USB_DEV_T
#define NULL
NULL pointer.
USB Host core driver header file.