1 /*****************************************************************************
2 * Copyright (c) 2013 IBM Corporation
3 * All rights reserved.
4 * This program and the accompanying materials
5 * are made available under the terms of the BSD License
6 * which accompanies this distribution, and is available at
7 * http://www.opensource.org/licenses/bsd-license.php
8 *
9 * Contributors:
10 * IBM Corporation - initial implementation
11 *****************************************************************************/
12
13 #include <string.h>
14 #include <byteorder.h>
15 #include "usb.h"
16 #include "usb-core.h"
17 #include "usb-ohci.h"
18
19 #undef OHCI_DEBUG
20 //#define OHCI_DEBUG
21 #ifdef OHCI_DEBUG
22 #define dprintf(_x ...) do { printf(_x); } while(0)
23 #else
24 #define dprintf(_x ...)
25 #endif
26
27 #undef OHCI_DEBUG_PACKET
28 //#define OHCI_DEBUG_PACKET
29 #ifdef OHCI_DEBUG_PACKET
30 #define dpprintf(_x ...) do { printf(_x); } while(0)
31 #else
32 #define dpprintf(_x ...)
33 #endif
34
35
36 /*
37 * Dump OHCI register
38 *
39 * @param - ohci_hcd
40 * @return -
41 */
ohci_dump_regs(struct ohci_regs * regs)42 static void ohci_dump_regs(struct ohci_regs *regs)
43 {
44 dprintf("\n - HcRevision %08X", read_reg32(®s->rev));
45 dprintf(" - HcControl %08X", read_reg32(®s->control));
46 dprintf("\n - HcCommandStatus %08X", read_reg32(®s->cmd_status));
47 dprintf(" - HcInterruptStatus %08X", read_reg32(®s->intr_status));
48 dprintf("\n - HcInterruptEnable %08X", read_reg32(®s->intr_enable));
49 dprintf(" - HcInterruptDisable %08X", read_reg32(®s->intr_disable));
50 dprintf("\n - HcHCCA %08X", read_reg32(®s->hcca));
51 dprintf(" - HcPeriodCurrentED %08X", read_reg32(®s->period_curr_ed));
52 dprintf("\n - HcControlHeadED %08X", read_reg32(®s->cntl_head_ed));
53 dprintf(" - HcControlCurrentED %08X", read_reg32(®s->cntl_curr_ed));
54 dprintf("\n - HcBulkHeadED %08X", read_reg32(®s->bulk_head_ed));
55 dprintf(" - HcBulkCurrentED %08X", read_reg32(®s->bulk_curr_ed));
56 dprintf("\n - HcDoneHead %08X", read_reg32(®s->done_head));
57 dprintf(" - HcFmInterval %08X", read_reg32(®s->fm_interval));
58 dprintf("\n - HcFmRemaining %08X", read_reg32(®s->fm_remaining));
59 dprintf(" - HcFmNumber %08X", read_reg32(®s->fm_num));
60 dprintf("\n - HcPeriodicStart %08X", read_reg32(®s->period_start));
61 dprintf(" - HcLSThreshold %08X", read_reg32(®s->ls_threshold));
62 dprintf("\n - HcRhDescriptorA %08X", read_reg32(®s->rh_desc_a));
63 dprintf(" - HcRhDescriptorB %08X", read_reg32(®s->rh_desc_b));
64 dprintf("\n - HcRhStatus %08X", read_reg32(®s->rh_status));
65 dprintf("\n");
66 }
67
68 /*
69 * OHCI Spec 5.1.1
70 * OHCI Spec 7.4 Root Hub Partition
71 */
ohci_hcd_reset(struct ohci_regs * regs)72 static int ohci_hcd_reset(struct ohci_regs *regs)
73 {
74 uint32_t time;
75
76 /* USBRESET - 1sec */
77 write_reg32(®s->control, 0);
78 SLOF_msleep(100);
79
80 write_reg32(®s->intr_disable, ~0);
81 write_reg32(®s->cmd_status, OHCI_CMD_STATUS_HCR);
82 mb();
83
84 time = 30; /* wait for not more than 30usec */
85 while ((read_reg32(®s->cmd_status) & OHCI_CMD_STATUS_HCR) != 0) {
86 time--;
87 if (!time) {
88 printf(" ** HCD Reset failed...");
89 return -1;
90 }
91 SLOF_usleep(1);
92 }
93 return 0;
94 }
95
ohci_hcd_init(struct ohci_hcd * ohcd)96 static int ohci_hcd_init(struct ohci_hcd *ohcd)
97 {
98 struct ohci_regs *regs;
99 struct ohci_ed *ed;
100 long ed_phys = 0;
101 unsigned int i;
102 uint32_t oldrwc;
103 struct usb_dev *rhdev = NULL;
104 struct usb_ep_descr ep;
105 uint32_t reg;
106
107 if (!ohcd)
108 return -1;
109
110 regs = ohcd->regs;
111 rhdev = &ohcd->rhdev;
112 dprintf("%s: HCCA memory %p\n", __func__, ohcd->hcca);
113 dprintf("%s: OHCI Regs %p\n", __func__, regs);
114
115 rhdev->hcidev = ohcd->hcidev;
116 ep.bmAttributes = USB_EP_TYPE_INTR;
117 ep.wMaxPacketSize = 8;
118 rhdev->intr = usb_get_pipe(rhdev, &ep, NULL, 0);
119 if (!rhdev->intr) {
120 printf("usb-ohci: oops could not allocate intr_pipe\n");
121 return -1;
122 }
123
124 /*
125 * OHCI Spec 4.4: Host Controller Communications Area
126 */
127 ed = ohci_pipe_get_ed(rhdev->intr);
128 ed_phys = ohci_pipe_get_ed_phys(rhdev->intr);
129 memset(ohcd->hcca, 0, HCCA_SIZE);
130 memset(ed, 0, sizeof(struct ohci_ed));
131 ed->attr = cpu_to_le32(EDA_SKIP);
132 for (i = 0; i < HCCA_INTR_NUM; i++)
133 ohcd->hcca->intr_table[i] = cpu_to_le32(ed_phys);
134
135 write_reg32(®s->hcca, ohcd->hcca_phys);
136 write_reg32(®s->cntl_head_ed, 0);
137 write_reg32(®s->bulk_head_ed, 0);
138
139 /* OHCI Spec 7.1.2 HcControl Register */
140 oldrwc = read_reg32(®s->control) & OHCI_CTRL_RWC;
141 write_reg32(®s->control, (OHCI_CTRL_CBSR | OHCI_CTRL_CLE |
142 OHCI_CTRL_BLE | OHCI_CTRL_PLE |
143 OHCI_USB_OPER | oldrwc));
144 SLOF_msleep(100);
145 /*
146 * For JS20/21 need to rewrite it after setting it to
147 * operational state
148 */
149 write_reg32(®s->fm_interval, FRAME_INTERVAL);
150 write_reg32(®s->period_start, PERIODIC_START);
151 reg = read_reg32(®s->rh_desc_a);
152 reg &= ~( RHDA_PSM_INDIVIDUAL | RHDA_OCPM_PERPORT );
153 reg |= RHDA_NPS_ENABLE;
154 write_reg32(®s->rh_desc_a, reg);
155 write_reg32(®s->rh_desc_b, 0);
156 mb();
157 SLOF_msleep(100);
158 ohci_dump_regs(regs);
159 return 0;
160 }
161
162 /*
163 * OHCI Spec 7.4 Root Hub Partition
164 */
ohci_hub_check_ports(struct ohci_hcd * ohcd)165 static void ohci_hub_check_ports(struct ohci_hcd *ohcd)
166 {
167 struct ohci_regs *regs;
168 struct usb_dev *dev;
169 unsigned int ports, i, port_status, port_clear = 0;
170
171 regs = ohcd->regs;
172 ports = read_reg32(®s->rh_desc_a) & RHDA_NDP;
173 write_reg32(®s->rh_status, RH_STATUS_LPSC);
174 SLOF_msleep(100);
175 dprintf("usb-ohci: ports connected %d\n", ports);
176 for (i = 0; i < ports; i++) {
177 dprintf("usb-ohci: ports scanning %d\n", i);
178 port_status = read_reg32(®s->rh_ps[i]);
179 if (port_status & RH_PS_CSC) {
180 if (port_status & RH_PS_CCS) {
181 write_reg32(®s->rh_ps[i], RH_PS_PRS);
182 mb();
183 port_clear |= RH_PS_CSC;
184 dprintf("Start enumerating device\n");
185 SLOF_msleep(100);
186 } else
187 printf("Start removing device\n");
188 }
189 port_status = read_reg32(®s->rh_ps[i]);
190 if (port_status & RH_PS_PRSC) {
191 port_clear |= RH_PS_PRSC;
192 dev = usb_devpool_get();
193 dprintf("usb-ohci: Device reset, setting up %p\n", dev);
194 dev->hcidev = ohcd->hcidev;
195 if (usb_setup_new_device(dev, i))
196 usb_slof_populate_new_device(dev);
197 else
198 printf("usb-ohci: unable to setup device on port %d\n", i);
199 }
200 if (port_status & RH_PS_PESC) {
201 port_clear |= RH_PS_PESC;
202 if (port_status & RH_PS_PES)
203 dprintf("enabled\n");
204 else
205 dprintf("disabled\n");
206 }
207 if (port_status & RH_PS_PSSC) {
208 port_clear |= RH_PS_PESC;
209 dprintf("suspended\n");
210 }
211 port_clear &= 0xFFFF0000;
212 if (port_clear)
213 write_reg32(®s->rh_ps[i], port_clear);
214 }
215 }
216
ohci_pipe_get_ed(struct usb_pipe * pipe)217 static inline struct ohci_ed *ohci_pipe_get_ed(struct usb_pipe *pipe)
218 {
219 struct ohci_pipe *opipe;
220 opipe = container_of(pipe, struct ohci_pipe, pipe);
221 dpprintf("%s: ed is %p\n", __func__, &opipe->ed);
222 return &opipe->ed;
223 }
224
ohci_pipe_get_ed_phys(struct usb_pipe * pipe)225 static inline long ohci_pipe_get_ed_phys(struct usb_pipe *pipe)
226 {
227 struct ohci_pipe *opipe;
228 opipe = container_of(pipe, struct ohci_pipe, pipe);
229 dpprintf("%s: ed_phys is %x\n", __func__, opipe->ed_phys);
230 return opipe->ed_phys;
231 }
232
ohci_pipe_get_opipe(struct usb_pipe * pipe)233 static inline struct ohci_pipe *ohci_pipe_get_opipe(struct usb_pipe *pipe)
234 {
235 struct ohci_pipe *opipe;
236 opipe = container_of(pipe, struct ohci_pipe, pipe);
237 dpprintf("%s: opipe is %p\n", __func__, opipe);
238 return opipe;
239 }
240
ohci_alloc_pipe_pool(struct ohci_hcd * ohcd)241 static int ohci_alloc_pipe_pool(struct ohci_hcd *ohcd)
242 {
243 struct ohci_pipe *opipe, *curr, *prev;
244 long opipe_phys = 0;
245 unsigned int i, count;
246 #ifdef OHCI_DEBUG_PACKET
247 struct usb_pipe *pipe;
248 #endif
249
250 dprintf("usb-ohci: %s enter\n", __func__);
251 count = OHCI_PIPE_POOL_SIZE/sizeof(*opipe);
252 ohcd->pool = opipe = SLOF_dma_alloc(OHCI_PIPE_POOL_SIZE);
253 if (!opipe)
254 return false;
255
256 ohcd->pool_phys = opipe_phys = SLOF_dma_map_in(opipe, OHCI_PIPE_POOL_SIZE, true);
257 dprintf("usb-ohci: %s opipe %p, opipe_phys %lx size %ld count %d\n",
258 __func__, opipe, opipe_phys, sizeof(*opipe), count);
259 /* Although an array, link them*/
260 for (i = 0, curr = opipe, prev = NULL; i < count; i++, curr++) {
261 if (prev)
262 prev->pipe.next = &curr->pipe;
263 curr->pipe.next = NULL;
264 prev = curr;
265
266 if (((uint64_t)&curr->ed) % 16)
267 printf("usb-ohci: Warning ED not aligned to 16byte boundary");
268 curr->ed_phys = opipe_phys + (curr - opipe) * sizeof(*curr) +
269 offset_of(struct ohci_pipe, ed);
270 }
271
272 if (!ohcd->freelist)
273 ohcd->freelist = &opipe->pipe;
274 else
275 ohcd->end->next = &opipe->pipe;
276 ohcd->end = &prev->pipe;
277
278 #ifdef OHCI_DEBUG_PACKET
279 for (i = 0, pipe = ohcd->freelist; pipe; pipe = pipe->next)
280 dprintf("usb-ohci: %d: pipe cur %p ed %p ed_phys %x\n",
281 i++, pipe, ohci_pipe_get_ed(pipe),
282 ohci_pipe_get_ed_phys(pipe));
283 #endif
284
285 dprintf("usb-ohci: %s exit\n", __func__);
286 return true;
287 }
288
ohci_init(struct usb_hcd_dev * hcidev)289 static void ohci_init(struct usb_hcd_dev *hcidev)
290 {
291 struct ohci_hcd *ohcd;
292
293 printf(" OHCI: initializing\n");
294 dprintf("%s: device base address %p\n", __func__, hcidev->base);
295
296 ohcd = SLOF_alloc_mem(sizeof(struct ohci_hcd));
297 if (!ohcd) {
298 printf("usb-ohci: Unable to allocate memory\n");
299 goto out;
300 }
301
302 hcidev->nextaddr = 1;
303 hcidev->priv = ohcd;
304 memset(ohcd, 0, sizeof(*ohcd));
305 ohcd->hcidev = hcidev;
306 ohcd->freelist = NULL;
307 ohcd->end = NULL;
308 ohcd->regs = (struct ohci_regs *)(hcidev->base);
309 ohcd->hcca = SLOF_dma_alloc(sizeof(struct ohci_hcca));
310 if (!ohcd->hcca || PTR_U32(ohcd->hcca) & HCCA_ALIGN) {
311 printf("usb-ohci: Unable to allocate/unaligned HCCA memory %p\n",
312 ohcd->hcca);
313 goto out_free_hcd;
314 }
315 ohcd->hcca_phys = SLOF_dma_map_in(ohcd->hcca,
316 sizeof(struct ohci_hcca), true);
317 dprintf("usb-ohci: HCCA memory %p HCCA-dev memory %08lx\n",
318 ohcd->hcca, ohcd->hcca_phys);
319
320 ohci_hcd_reset(ohcd->regs);
321 ohci_hcd_init(ohcd);
322 ohci_hub_check_ports(ohcd);
323 return;
324
325 out_free_hcd:
326 SLOF_dma_free(ohcd->hcca, sizeof(struct ohci_hcca));
327 SLOF_free_mem(ohcd, sizeof(struct ohci_hcd));
328 out:
329 return;
330 }
331
ohci_exit(struct usb_hcd_dev * hcidev)332 static void ohci_exit(struct usb_hcd_dev *hcidev)
333 {
334 struct ohci_hcd *ohcd = NULL;
335
336 dprintf("%s: enter \n", __func__);
337 if (!hcidev && !hcidev->priv)
338 return;
339
340 ohcd = hcidev->priv;
341 write_reg32(&ohcd->regs->control, (OHCI_CTRL_CBSR | OHCI_USB_SUSPEND));
342 SLOF_msleep(20);
343 write_reg32(&ohcd->regs->hcca, cpu_to_le32(0));
344
345 if (ohcd->pool) {
346 SLOF_dma_map_out(ohcd->pool_phys, ohcd->pool, OHCI_PIPE_POOL_SIZE);
347 SLOF_dma_free(ohcd->pool, OHCI_PIPE_POOL_SIZE);
348 }
349 if (ohcd->hcca) {
350 SLOF_dma_map_out(ohcd->hcca_phys, ohcd->hcca, sizeof(struct ohci_hcca));
351 SLOF_dma_free(ohcd->hcca, sizeof(struct ohci_hcca));
352 }
353 SLOF_free_mem(ohcd, sizeof(struct ohci_hcd));
354 return;
355 }
356
ohci_detect(void)357 static void ohci_detect(void)
358 {
359
360 }
361
ohci_disconnect(void)362 static void ohci_disconnect(void)
363 {
364
365 }
366
367 #define OHCI_CTRL_TDS 3
368
ohci_fill_td(struct ohci_td * td,long next,long req,size_t size,unsigned int attr)369 static void ohci_fill_td(struct ohci_td *td, long next,
370 long req, size_t size, unsigned int attr)
371 {
372 if (size && req) {
373 td->cbp = cpu_to_le32(req);
374 td->be = cpu_to_le32(req + size - 1);
375 } else {
376 td->cbp = 0;
377 td->be = 0;
378 }
379 td->attr = cpu_to_le32(attr);
380 td->next_td = cpu_to_le32(next);
381
382 dpprintf("%s: cbp %08X attr %08X next_td %08X be %08X\n", __func__,
383 le32_to_cpu(td->cbp), le32_to_cpu(td->attr),
384 le32_to_cpu(td->next_td), le32_to_cpu(td->be));
385 }
386
ohci_fill_ed(struct ohci_ed * ed,long headp,long tailp,unsigned int attr,long next_ed)387 static void ohci_fill_ed(struct ohci_ed *ed, long headp, long tailp,
388 unsigned int attr, long next_ed)
389 {
390 ed->attr = cpu_to_le32(attr);
391 ed->headp = cpu_to_le32(headp) | (ed->headp & ~EDA_HEADP_MASK_LE);
392 ed->tailp = cpu_to_le32(tailp);
393 ed->next_ed = cpu_to_le32(next_ed);
394 dpprintf("%s: headp %08X tailp %08X next_td %08X attr %08X\n", __func__,
395 le32_to_cpu(ed->headp), le32_to_cpu(ed->tailp),
396 le32_to_cpu(ed->next_ed), le32_to_cpu(ed->attr));
397
398 }
399
ohci_get_td_phys(struct ohci_td * curr,struct ohci_td * start,long td_phys)400 static long ohci_get_td_phys(struct ohci_td *curr, struct ohci_td *start, long td_phys)
401 {
402 dpprintf("position %d\n", curr - start);
403 return td_phys + (curr - start) * sizeof(*start);
404 }
405
ohci_get_td_virt(struct ohci_td * curr,struct ohci_td * start,long td_virt,long total_count)406 static long ohci_get_td_virt(struct ohci_td *curr, struct ohci_td *start, long td_virt, long total_count)
407 {
408 dpprintf("position %d\n", curr - start);
409 if ( (curr - start) >= total_count) {
410 /* busted position, should ignore this */
411 return 0;
412 }
413 return td_virt + (curr - start) * sizeof(*start);
414 }
415
416 /* OHCI Spec: 4.4.2.3 HccaDoneHead*/
ohci_process_done_head(struct ohci_hcd * ohcd,struct ohci_td * td_start,long __td_start_phys,long total_count)417 static int ohci_process_done_head(struct ohci_hcd *ohcd,
418 struct ohci_td *td_start,
419 long __td_start_phys, long total_count)
420 {
421 struct ohci_hcca *hcca;
422 struct ohci_td *td_phys = NULL, *td_start_phys;
423 struct ohci_td *td, *prev_td = NULL;
424 uint32_t reg = 0, time = 0;
425 int ret = true;
426 long count;
427
428 count = total_count;
429 td_start_phys = (struct ohci_td *) __td_start_phys;
430 hcca = ohcd->hcca;
431 time = SLOF_GetTimer() + USB_TIMEOUT;
432 dpprintf("Claiming %ld\n", count);
433
434 again:
435 mb();
436 /* Check if there is an interrupt */
437 reg = read_reg32(&ohcd->regs->intr_status);
438 while(!(reg & OHCI_INTR_STATUS_WD))
439 {
440 if (time < SLOF_GetTimer()) {
441 printf("Timed out waiting for interrupt %x\n", reg);
442 return false;
443 }
444 mb();
445 reg = read_reg32(&ohcd->regs->intr_status);
446 }
447
448 /* Interrupt is there, read from done_head pointer */
449 td_phys = (struct ohci_td *)(uint64_t) le32_to_cpu(hcca->done_head);
450 if (!td_phys) {
451 dprintf("Again td_phys null\n");
452 goto again;
453 }
454 hcca->done_head = 0;
455 mb();
456
457 while (td_phys && (count > 0)) {
458 td = (struct ohci_td *)(uint64_t) ohci_get_td_virt(td_phys,
459 td_start_phys,
460 PTR_U32(td_start),
461 total_count);
462
463 if (!td) {
464 printf("USB: Error TD null %p\n", td_phys);
465 break;
466 }
467 count--;
468 dprintf("Claimed %p(%p) td_start %p count %ld\n",
469 td, td_phys, td_start_phys, count);
470 dpprintf("%s: cbp %08X attr %08X next_td %08X be %08X\n",
471 __func__,
472 le32_to_cpu(td->cbp), le32_to_cpu(td->attr),
473 le32_to_cpu(td->next_td), le32_to_cpu(td->be));
474 mb();
475 reg = (le32_to_cpu(td->attr) & TDA_CC) >> 28;
476 if (reg) {
477 dprintf("%s: cbp %08X attr %08X next_td %08X be %08X\n",
478 __func__,
479 le32_to_cpu(td->cbp), le32_to_cpu(td->attr),
480 le32_to_cpu(td->next_td), le32_to_cpu(td->be));
481 printf("USB: Error %s %p\n", tda_cc_error[reg], td);
482 if (reg > 3) /* Return negative error code */
483 ret = reg * -1;
484 }
485 prev_td = td;
486 td_phys = (struct ohci_td *)(uint64_t) le32_to_cpu(td->next_td);
487 prev_td->attr |= cpu_to_le32(TDA_DONE);
488 prev_td->next_td = 0;
489 mb();
490 }
491 /* clear the WD interrupt status */
492 write_reg32(&ohcd->regs->intr_status, OHCI_INTR_STATUS_WD);
493 mb();
494 read_reg32(&ohcd->regs->intr_status);
495
496 if (count > 0) {
497 dpprintf("Pending count %d\n", count);
498 goto again;
499 }
500 dprintf("TD claims done\n");
501 return ret;
502 }
503
504 /*
505 * OHCI Spec:
506 * 4.2 Endpoint Descriptor
507 * 4.3.1 General Transfer Descriptor
508 * 5.2.8 Transfer Descriptor Queues
509 */
ohci_send_ctrl(struct usb_pipe * pipe,struct usb_dev_req * req,void * data)510 static int ohci_send_ctrl(struct usb_pipe *pipe, struct usb_dev_req *req, void *data)
511 {
512 struct ohci_ed *ed;
513 struct ohci_td *tds, *td, *td_phys;
514 struct ohci_regs *regs;
515 struct ohci_hcd *ohcd;
516 uint32_t datalen;
517 uint32_t dir, attr = 0;
518 uint32_t time;
519 int ret = true, i;
520 long req_phys = 0, data_phys = 0, td_next = 0, td_count = 0;
521 unsigned char *dbuf;
522
523 datalen = le16_to_cpu(req->wLength);
524 dir = (req->bmRequestType & REQT_DIR_IN) ? 1 : 0;
525
526 dprintf("usb-ohci: %s len %d DIR_IN %d\n", __func__, datalen, dir);
527
528 tds = td = (struct ohci_td *) SLOF_dma_alloc(sizeof(*td) * OHCI_CTRL_TDS);
529 td_phys = (struct ohci_td *) SLOF_dma_map_in(td, sizeof(*td) * OHCI_CTRL_TDS, true);
530 memset(td, 0, sizeof(*td) * OHCI_CTRL_TDS);
531
532 req_phys = SLOF_dma_map_in(req, sizeof(struct usb_dev_req), true);
533 attr = TDA_DP_SETUP | TDA_CC | TDA_TOGGLE_DATA0;
534 td_next = ohci_get_td_phys(td + 1, tds, PTR_U32(td_phys));
535 ohci_fill_td(td, td_next, req_phys, sizeof(*req), attr);
536 td++; td_count++;
537
538 if (datalen) {
539 data_phys = SLOF_dma_map_in(data, datalen, true);
540 attr = 0;
541 attr = (dir ? TDA_DP_IN : TDA_DP_OUT) | TDA_TOGGLE_DATA1 | TDA_CC;
542 td_next = ohci_get_td_phys(td + 1, tds, PTR_U32(td_phys));
543 ohci_fill_td(td, td_next, data_phys, datalen, attr);
544 td++; td_count++;
545 }
546
547 attr = 0;
548 attr = (dir ? TDA_DP_OUT : TDA_DP_IN) | TDA_CC | TDA_TOGGLE_DATA1;
549 td_next = ohci_get_td_phys(td + 1, tds, PTR_U32(td_phys));
550 ohci_fill_td(td, 0, 0, 0, attr);
551 td_count++;
552
553 ed = ohci_pipe_get_ed(pipe);
554 attr = 0;
555 attr = EDA_FADDR(pipe->dev->addr) | EDA_MPS(pipe->mps) | EDA_SKIP;
556 ohci_fill_ed(ed, PTR_U32(td_phys), td_next, attr, 0);
557 ed->tailp = 0; /* HACK */
558 dprintf("usb-ohci: %s - td_start %p td_end %lx req %lx\n", __func__,
559 td_phys, td_next, req_phys);
560 mb();
561 ed->attr &= cpu_to_le32(~EDA_SKIP);
562
563 ohcd = pipe->dev->hcidev->priv;
564 regs = ohcd->regs;
565 write_reg32(®s->cntl_head_ed, ohci_pipe_get_ed_phys(pipe));
566 mb();
567 write_reg32(®s->cmd_status, OHCI_CMD_STATUS_CLF);
568
569 time = SLOF_GetTimer() + USB_TIMEOUT;
570 while ((time > SLOF_GetTimer()) &&
571 ((ed->headp & EDA_HEADP_MASK_LE) != ed->tailp))
572 cpu_relax();
573
574 if ((ed->headp & EDA_HEADP_MASK_LE) == ed->tailp) {
575 dprintf("%s: packet sent\n", __func__);
576 #ifdef OHCI_DEBUG_PACKET
577 dpprintf("Request: ");
578 dbuf = (unsigned char *)req;
579 for(i = 0; i < 8; i++)
580 printf("%02X ", dbuf[i]);
581 dpprintf("\n");
582 if (datalen) {
583 dbuf = (unsigned char *)data;
584 dpprintf("Reply: ");
585 for(i = 0; i < datalen; i++)
586 printf("%02X ", dbuf[i]);
587 dpprintf("\n");
588 }
589 #endif
590 }
591 else {
592 printf("%s: timed out - failed\n", __func__);
593 dpprintf("%s: headp %08X tailp %08X next_td %08X attr %08X\n",
594 __func__,
595 le32_to_cpu(ed->headp), le32_to_cpu(ed->tailp),
596 le32_to_cpu(ed->next_ed), le32_to_cpu(ed->attr));
597 printf("Request: ");
598 dbuf = (unsigned char *)req;
599 for(i = 0; i < 8; i++)
600 printf("%02X ", dbuf[i]);
601 printf("\n");
602 }
603 ret = ohci_process_done_head(ohcd, tds, (long)td_phys, td_count);
604 mb();
605 ed->attr |= cpu_to_le32(EDA_SKIP);
606 mb();
607 write_reg32(®s->cntl_head_ed, 0);
608 write_reg32(®s->cntl_curr_ed, 0);
609
610 SLOF_dma_map_out(req_phys, req, sizeof(struct usb_dev_req));
611 if (datalen)
612 SLOF_dma_map_out(data_phys, data, datalen);
613 SLOF_dma_map_out(PTR_U32(td_phys), tds, sizeof(*td) * OHCI_CTRL_TDS);
614 SLOF_dma_free(tds, sizeof(*td) * OHCI_CTRL_TDS);
615 return (ret > 0) ? true : false;
616 }
617
ohci_transfer_bulk(struct usb_pipe * pipe,void * td_ptr,void * td_phys_ptr,void * data_phys,int datalen)618 static int ohci_transfer_bulk(struct usb_pipe *pipe, void *td_ptr,
619 void *td_phys_ptr, void *data_phys, int datalen)
620 {
621 struct ohci_ed *ed;
622 struct ohci_td *td, *tds;
623 struct ohci_regs *regs;
624 struct ohci_hcd *ohcd;
625 long td_phys = 0, td_next, ed_phys, ptr, td_count = 0;
626 uint32_t dir, attr = 0, count;
627 size_t len, packet_len;
628 uint32_t time;
629 int ret = true;
630
631 if (pipe->type != USB_EP_TYPE_BULK) {
632 printf("usb-ohci: Not a bulk pipe.\n");
633 ret = false;
634 goto end;
635 }
636
637 dir = (pipe->dir == USB_PIPE_OUT) ? 0 : 1;
638 count = datalen / OHCI_MAX_BULK_SIZE;
639 if (count > OHCI_MAX_TDS) {
640 printf("usb-ohci: buffer size not supported - %d\n", datalen);
641 ret = false;
642 goto end;
643 }
644
645 td = tds = (struct ohci_td *) td_ptr;
646 td_phys = (long)td_phys_ptr;
647 dprintf("usb-ohci: %s pipe %p data_phys %p len %d DIR_IN %d td %p td_phys %lx\n",
648 __func__, pipe, data_phys, datalen, dir, td, td_phys);
649
650 if (!tds) {
651 printf("%s: tds NULL recieved\n", __func__);
652 ret = false;
653 goto end;
654 }
655 memset(td, 0, sizeof(*td) * OHCI_MAX_TDS);
656
657 len = datalen;
658 ptr = (long)data_phys;
659 attr = 0;
660 attr = (dir ? TDA_DP_IN : TDA_DP_OUT) | TDA_CC | TDA_ROUNDING;
661 while (len) {
662 packet_len = (OHCI_MAX_BULK_SIZE < len)? OHCI_MAX_BULK_SIZE : len;
663 td_next = ohci_get_td_phys((td + 1), tds, td_phys);
664 ohci_fill_td(td, td_next, ptr, packet_len, attr);
665 ptr = ptr + packet_len;
666 len = len - packet_len;
667 td++; td_count++;
668 }
669
670 ed = ohci_pipe_get_ed(pipe);
671 attr = 0;
672 dir = pipe->dir ? EDA_DIR_IN : EDA_DIR_OUT;
673 attr = dir | EDA_FADDR(pipe->dev->addr) | EDA_MPS(pipe->mps)
674 | EDA_SKIP | pipe->dev->speed | EDA_EP(pipe->epno);
675 td_next = ohci_get_td_phys(td, tds, td_phys);
676 ohci_fill_ed(ed, td_phys, td_next, attr, 0);
677 dprintf("usb-ohci: %s - tds %lx td %lx\n", __func__, td_phys, td_next);
678 mb();
679 ed->attr &= cpu_to_le32(~EDA_SKIP);
680
681 ohcd = pipe->dev->hcidev->priv;
682 regs = ohcd->regs;
683 ed_phys = ohci_pipe_get_ed_phys(pipe);
684 write_reg32(®s->bulk_head_ed, ed_phys);
685 mb();
686 write_reg32(®s->cmd_status, 0x4);
687
688 time = SLOF_GetTimer() + USB_TIMEOUT;
689 while ((time > SLOF_GetTimer()) &&
690 ((ed->headp & EDA_HEADP_MASK_LE) != ed->tailp))
691 cpu_relax();
692
693 if ((ed->headp & EDA_HEADP_MASK_LE) == ed->tailp)
694 dprintf("%s: packet sent\n", __func__);
695 else {
696 dpprintf("%s: headp %08X tailp %08X next_td %08X attr %08X\n", __func__,
697 le32_to_cpu(ed->headp), le32_to_cpu(ed->tailp),
698 le32_to_cpu(ed->next_ed), le32_to_cpu(ed->attr));
699 }
700 mb();
701 ret = ohci_process_done_head(ohcd, tds, td_phys, td_count);
702 mb();
703 ed->attr |= cpu_to_le32(EDA_SKIP);
704 mb();
705 write_reg32(®s->bulk_head_ed, 0);
706 write_reg32(®s->bulk_curr_ed, 0);
707
708 if (le32_to_cpu(ed->headp) & EDA_HEADP_HALTED) {
709 printf("ED Halted\n");
710 printf("%s: headp %08X tailp %08X next_td %08X attr %08X\n", __func__,
711 le32_to_cpu(ed->headp), le32_to_cpu(ed->tailp),
712 le32_to_cpu(ed->next_ed), le32_to_cpu(ed->attr));
713 ed->headp &= ~cpu_to_le32(EDA_HEADP_HALTED);
714 mb();
715 if (ret == USB_STALL) /* Call reset recovery */
716 usb_msc_resetrecovery(pipe->dev);
717 }
718
719 end:
720 return (ret > 0) ? true : false;
721 }
722
723 /* Populate the hcca intr region with periodic intr */
ohci_get_pipe_intr(struct usb_pipe * pipe,struct ohci_hcd * ohcd,char * buf,size_t buflen)724 static int ohci_get_pipe_intr(struct usb_pipe *pipe, struct ohci_hcd *ohcd,
725 char *buf, size_t buflen)
726 {
727 struct ohci_hcca *hcca;
728 struct ohci_pipe *opipe;
729 struct ohci_ed *ed;
730 struct usb_dev *dev;
731 struct ohci_td *tds, *td;
732 int32_t count = 0, i;
733 uint8_t *ptr;
734 uint16_t mps;
735 long ed_phys, td_phys, td_next, buf_phys;
736
737 if (!pipe || !ohcd)
738 return false;
739
740 hcca = ohcd->hcca;
741 dev = pipe->dev;
742 if (dev->class != DEV_HID_KEYB && dev->class != DEV_HUB)
743 return false;
744
745 opipe = ohci_pipe_get_opipe(pipe);
746 ed = &(opipe->ed);
747 ed_phys = opipe->ed_phys;
748 mps = pipe->mps;
749 ed->attr = cpu_to_le32(EDA_DIR_IN |
750 EDA_FADDR(dev->addr) |
751 dev->speed |
752 EDA_MPS(pipe->mps) |
753 EDA_SKIP |
754 EDA_EP(pipe->epno));
755 dprintf("%s: pipe %p ed %p dev %p opipe %p\n", __func__,
756 pipe, ed, dev, opipe);
757 count = (buflen/mps) + 1;
758 tds = td = SLOF_dma_alloc(sizeof(*td) * count);
759 if (!tds) {
760 printf("%s: alloc failed\n", __func__);
761 return false;
762 }
763 td_phys = SLOF_dma_map_in(td, sizeof(*td) * count, false);
764
765 memset(tds, 0, sizeof(*tds) * count);
766 memset(buf, 0, buflen);
767 buf_phys = SLOF_dma_map_in(buf, buflen, false);
768 opipe->td = td;
769 opipe->td_phys = td_phys;
770 opipe->count = count;
771 opipe->buf = buf;
772 opipe->buflen = buflen;
773 opipe->buf_phys = buf_phys;
774
775 ptr = (uint8_t *)buf_phys;
776 for (i = 0; i < count - 1; i++, ptr += mps) {
777 td = &tds[i];
778 td_next = ohci_get_td_phys(td + 1, &tds[0], td_phys);
779 td->cbp = cpu_to_le32(PTR_U32(ptr));
780 td->attr = cpu_to_le32(TDA_DP_IN | TDA_ROUNDING | TDA_CC);
781 td->next_td = cpu_to_le32(td_next);
782 td->be = cpu_to_le32(PTR_U32(ptr) + mps - 1);
783 dprintf("td %p td++ %x ptr %p be %x\n",
784 td, le32_to_cpu(td->next_td),
785 ptr, (PTR_U32(ptr) + mps - 1));
786 }
787 td->next_td = 0;
788 td_next = ohci_get_td_phys(td, &tds[0], td_phys);
789 ed->headp = cpu_to_le32(td_phys);
790 ed->tailp = cpu_to_le32(td_next);
791
792 dprintf("%s: head %08X tail %08X, count %d, mps %d\n", __func__,
793 le32_to_cpu(ed->headp),
794 le32_to_cpu(ed->tailp),
795 count, mps);
796 ed->next_ed = 0;
797
798
799 switch (dev->class) {
800 case DEV_HID_KEYB:
801 dprintf("%s: Keyboard class %d\n", __func__, dev->class);
802 hcca->intr_table[0] = cpu_to_le32(ed_phys);
803 hcca->intr_table[8] = cpu_to_le32(ed_phys);
804 hcca->intr_table[16] = cpu_to_le32(ed_phys);
805 hcca->intr_table[24] = cpu_to_le32(ed_phys);
806 ed->attr &= cpu_to_le32(~EDA_SKIP);
807 break;
808
809 case DEV_HUB:
810 dprintf("%s: HUB class %x\n", __func__, dev->class);
811 hcca->intr_table[1] = cpu_to_le32(ed_phys);
812 ed->attr &= cpu_to_le32(~EDA_SKIP);
813 break;
814
815 default:
816 dprintf("%s: unhandled class %d\n", __func__, dev->class);
817 }
818 return true;
819 }
820
ohci_put_pipe_intr(struct usb_pipe * pipe,struct ohci_hcd * ohcd)821 static int ohci_put_pipe_intr(struct usb_pipe *pipe, struct ohci_hcd *ohcd)
822 {
823 struct ohci_hcca *hcca;
824 struct ohci_pipe *opipe;
825 struct ohci_ed *ed;
826 struct usb_dev *dev;
827 struct ohci_td *td;
828 long ed_phys;
829
830 if (!pipe || !ohcd)
831 return false;
832
833 hcca = ohcd->hcca;
834 dev = pipe->dev;
835
836 if (dev->class != DEV_HID_KEYB && dev->class != DEV_HUB)
837 return false;
838
839 opipe = ohci_pipe_get_opipe(pipe);
840 ed = &(opipe->ed);
841 ed_phys = opipe->ed_phys;
842 dprintf("%s: td %p td_phys %08lx buf %p buf_phys %08lx\n", __func__,
843 opipe->td, opipe->td_phys, opipe->buf, opipe->buf_phys);
844
845 ed->attr |= cpu_to_le32(EDA_SKIP);
846 mb();
847 ed->headp = 0;
848 ed->tailp = 0;
849 ed->next_ed = 0;
850 SLOF_dma_map_out(opipe->buf_phys, opipe->buf, opipe->buflen);
851 SLOF_dma_map_out(opipe->td_phys, opipe->td, sizeof(*td) * opipe->count);
852 SLOF_dma_free(opipe->td, sizeof(*td) * opipe->count);
853
854 switch (dev->class) {
855 case DEV_HID_KEYB:
856 dprintf("%s: Keyboard class %d\n", __func__, dev->class);
857 hcca->intr_table[0] = cpu_to_le32(ed_phys);
858 hcca->intr_table[8] = cpu_to_le32(ed_phys);
859 hcca->intr_table[16] = cpu_to_le32(ed_phys);
860 hcca->intr_table[24] = cpu_to_le32(ed_phys);
861 break;
862
863 case DEV_HUB:
864 dprintf("%s: HUB class %d\n", __func__, dev->class);
865 hcca->intr_table[1] = cpu_to_le32(ed_phys);
866 break;
867
868 default:
869 dprintf("%s: unhandled class %d\n", __func__, dev->class);
870 }
871 return true;
872 }
873
ohci_init_bulk_ed(struct usb_dev * dev,struct usb_pipe * pipe)874 static int ohci_init_bulk_ed(struct usb_dev *dev, struct usb_pipe *pipe)
875 {
876 struct ohci_pipe *opipe;
877 struct ohci_ed *ed;
878 uint32_t dir;
879
880 if (!pipe || !dev)
881 return false;
882
883 opipe = ohci_pipe_get_opipe(pipe);
884 ed = &(opipe->ed);
885 dir = pipe->dir ? EDA_DIR_IN : EDA_DIR_OUT;
886
887 ed->attr = cpu_to_le32(dir |
888 EDA_FADDR(dev->addr) |
889 dev->speed |
890 EDA_MPS(pipe->mps) |
891 EDA_SKIP |
892 EDA_EP(pipe->epno));
893
894 dprintf("%s: pipe %p attr %x\n", __func__, pipe,
895 le32_to_cpu(ed->attr));
896 return true;
897 }
898
ohci_get_pipe(struct usb_dev * dev,struct usb_ep_descr * ep,char * buf,size_t buflen)899 static struct usb_pipe *ohci_get_pipe(struct usb_dev *dev, struct usb_ep_descr *ep,
900 char *buf, size_t buflen)
901 {
902 struct ohci_hcd *ohcd;
903 struct usb_pipe *new = NULL;
904
905 dprintf("usb-ohci: %s enter %p\n", __func__, dev);
906 if (!dev)
907 return NULL;
908
909 ohcd = (struct ohci_hcd *)dev->hcidev->priv;
910 if (!ohcd->freelist) {
911 dprintf("usb-ohci: %s allocating pool\n", __func__);
912 if (!ohci_alloc_pipe_pool(ohcd))
913 return NULL;
914 }
915
916 new = ohcd->freelist;
917 ohcd->freelist = ohcd->freelist->next;
918 if (!ohcd->freelist)
919 ohcd->end = NULL;
920
921 memset(new, 0, sizeof(*new));
922 new->dev = dev;
923 new->next = NULL;
924 new->type = ep->bmAttributes & USB_EP_TYPE_MASK;
925 new->speed = dev->speed;
926 new->mps = le16_to_cpu(ep->wMaxPacketSize);
927 new->epno = ep->bEndpointAddress & 0xF;
928 new->dir = ep->bEndpointAddress & 0x80;
929 if (new->type == USB_EP_TYPE_INTR)
930 if (!ohci_get_pipe_intr(new, ohcd, buf, buflen))
931 dprintf("usb-ohci: %s alloc_intr failed %p\n",
932 __func__, new);
933 if (new->type == USB_EP_TYPE_BULK)
934 ohci_init_bulk_ed(dev, new);
935
936 dprintf("usb-ohci: %s exit %p\n", __func__, new);
937 return new;
938 }
939
ohci_put_pipe(struct usb_pipe * pipe)940 static void ohci_put_pipe(struct usb_pipe *pipe)
941 {
942 struct ohci_hcd *ohcd;
943
944 dprintf("usb-ohci: %s enter - %p\n", __func__, pipe);
945 if (!pipe || !pipe->dev)
946 return;
947 ohcd = pipe->dev->hcidev->priv;
948 if (ohcd->end)
949 ohcd->end->next = pipe;
950 else
951 ohcd->freelist = pipe;
952
953 if (pipe->type == USB_EP_TYPE_INTR)
954 if (!ohci_put_pipe_intr(pipe, ohcd))
955 dprintf("usb-ohci: %s alloc_intr failed %p\n",
956 __func__, pipe);
957
958 ohcd->end = pipe;
959 pipe->next = NULL;
960 pipe->dev = NULL;
961 memset(pipe, 0, sizeof(*pipe));
962 dprintf("usb-ohci: %s exit\n", __func__);
963 }
964
ohci_get_last_frame(struct usb_dev * dev)965 static uint16_t ohci_get_last_frame(struct usb_dev *dev)
966 {
967 struct ohci_hcd *ohcd;
968 struct ohci_regs *regs;
969
970 ohcd = dev->hcidev->priv;
971 regs = ohcd->regs;
972 return read_reg32(®s->fm_num);
973 }
974
ohci_poll_intr(struct usb_pipe * pipe,uint8_t * data)975 static int ohci_poll_intr(struct usb_pipe *pipe, uint8_t *data)
976 {
977 struct ohci_pipe *opipe;
978 struct ohci_ed *ed;
979 struct ohci_td *head, *tail, *curr, *next;
980 struct ohci_td *head_phys, *tail_phys, *curr_phys;
981 uint8_t *ptr = NULL;
982 unsigned int i, pos;
983 static uint16_t last_frame;
984 long ptr_phys = 0;
985 long td_next;
986
987 if (!pipe || last_frame == ohci_get_last_frame(pipe->dev))
988 return 0;
989
990 dprintf("%s: enter\n", __func__);
991
992 last_frame = ohci_get_last_frame(pipe->dev);
993 opipe = ohci_pipe_get_opipe(pipe);
994 ed = &opipe->ed;
995
996 head_phys = (struct ohci_td *)(long)(le32_to_cpu(ed->headp) & EDA_HEADP_MASK);
997 tail_phys = (struct ohci_td *)(long)le32_to_cpu(ed->tailp);
998 curr_phys = (struct ohci_td *) opipe->td_phys;
999 pos = (tail_phys - curr_phys + 1) % (opipe->count - 1);
1000 dprintf("pos %d %ld -- %d\n", pos, (tail_phys - curr_phys + 1),
1001 opipe->count);
1002 curr = opipe->td + pos;
1003 head = opipe->td + (head_phys - (struct ohci_td *) opipe->td_phys);
1004 tail = opipe->td + (tail_phys - (struct ohci_td *) opipe->td_phys);
1005
1006 /* dprintf("%08X %08X %08X %08X\n",
1007 opipe->td_phys, head_phys, tail_phys, curr_phys);
1008 dprintf("%08X %08X %08X %08X\n", opipe->td, head, tail, curr); */
1009
1010 if (curr != head) {
1011 ptr = (uint8_t *) ((long)opipe->buf + pipe->mps * pos);
1012 ptr_phys = opipe->buf_phys + pipe->mps * pos;
1013 if (le32_to_cpu(*(uint32_t *)ptr) != 0) {
1014 for (i = 0; i < 8; i++)
1015 data[i] = *(ptr + i);
1016 }
1017
1018 next = curr + 1;
1019 if (next == (opipe->td + opipe->count - 1))
1020 next = opipe->td;
1021
1022 curr->attr = cpu_to_le32(TDA_DP_IN | TDA_ROUNDING | TDA_CC);
1023 curr->next_td = cpu_to_le32(0);
1024 curr->cbp = cpu_to_le32(PTR_U32(ptr_phys));
1025 curr->be = cpu_to_le32(PTR_U32(ptr_phys + pipe->mps - 1));
1026 td_next = ohci_get_td_phys(curr, opipe->td, opipe->td_phys);
1027 dprintf("Connecting %p to %p(phys %08lx) ptr %p, "
1028 "ptr_phys %08lx\n", tail, curr, td_next, ptr, ptr_phys);
1029 tail->next_td = cpu_to_le32(td_next);
1030 mb();
1031 ed->tailp = cpu_to_le32(td_next);
1032 } else
1033 return 0;
1034
1035 dprintf("%s: exit\n", __func__);
1036 return 1;
1037 }
1038
1039 struct usb_hcd_ops ohci_ops = {
1040 .name = "ohci-hcd",
1041 .init = ohci_init,
1042 .exit = ohci_exit,
1043 .detect = ohci_detect,
1044 .disconnect = ohci_disconnect,
1045 .get_pipe = ohci_get_pipe,
1046 .put_pipe = ohci_put_pipe,
1047 .send_ctrl = ohci_send_ctrl,
1048 .transfer_bulk = ohci_transfer_bulk,
1049 .poll_intr = ohci_poll_intr,
1050 .usb_type = USB_OHCI,
1051 .next = NULL,
1052 };
1053
usb_ohci_register(void)1054 void usb_ohci_register(void)
1055 {
1056 usb_hcd_register(&ohci_ops);
1057 }
1058