开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
usb-uhci.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：84k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

usb-uhci.c：源码内容
  1. /* 
  2.  * Universal Host Controller Interface driver for USB (take II).
  3.  *
  4.  * (c) 1999-2001 Georg Acher, acher@in.tum.de (executive slave) (base guitar)
  5.  *               Deti Fliegl, deti@fliegl.de (executive slave) (lead voice)
  6.  *               Thomas Sailer, sailer@ife.ee.ethz.ch (chief consultant) (cheer leader)
  7.  *               Roman Weissgaerber, weissg@vienna.at (virt root hub) (studio porter)
  8.  * (c) 2000      Yggdrasil Computing, Inc. (port of new PCI interface support
  9.  *               from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
  10.  * (C) 2000      David Brownell, david-b@pacbell.net (usb-ohci.c)
  11.  *          
  12.  * HW-initalization based on material of
  13.  *
  14.  * (C) Copyright 1999 Linus Torvalds
  15.  * (C) Copyright 1999 Johannes Erdfelt
  16.  * (C) Copyright 1999 Randy Dunlap
  17.  * (C) Copyright 1999 Gregory P. Smith
  18.  *
  19.  * $Id: usb-uhci.c,v 1.275 2002/01/19 20:57:33 acher Exp $
  20.  */
  22. #include <linux/config.h>
  23. #include <linux/module.h>
  24. #include <linux/pci.h>
  25. #include <linux/kernel.h>
  26. #include <linux/delay.h>
  27. #include <linux/ioport.h>
  28. #include <linux/sched.h>
  29. #include <linux/slab.h>
  30. #include <linux/smp_lock.h>
  31. #include <linux/errno.h>
  32. #include <linux/unistd.h>
  33. #include <linux/interrupt.h> /* for in_interrupt() */
  34. #include <linux/init.h>
  35. #include <linux/version.h>
  36. #include <linux/pm.h>
  37. #include <linux/timer.h>
  39. #include <asm/uaccess.h>
  40. #include <asm/io.h>
  41. #include <asm/irq.h>
  42. #include <asm/system.h>
  44. /* This enables more detailed sanity checks in submit_iso */
  45. //#define ISO_SANITY_CHECK
  47. /* This enables debug printks */
  48. #define DEBUG
  50. /* This enables all symbols to be exported, to ease debugging oopses */
  51. //#define DEBUG_SYMBOLS
  53. /* This enables an extra UHCI slab for memory debugging */
  54. #define DEBUG_SLAB
  56. #define VERSTR "$Revision: 1.275 $ time " __TIME__ " " __DATE__
  58. #include <linux/usb.h>
  59. #include "usb-uhci.h"
  60. #include "usb-uhci-debug.h"
  62. /*
  63.  * Version Information
  64.  */
  65. #define DRIVER_VERSION "v1.275"
  66. #define DRIVER_AUTHOR "Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber"
  67. #define DRIVER_DESC "USB Universal Host Controller Interface driver"
  69. #undef DEBUG
  70. #undef dbg
  71. #define dbg(format, arg...) do {} while (0)
  72. #define DEBUG_SYMBOLS
  73. #ifdef DEBUG_SYMBOLS
  74. #define _static
  75. #ifndef EXPORT_SYMTAB
  76. #define EXPORT_SYMTAB
  77. #endif
  78. #else
  79. #define _static static
  80. #endif
  82. #define queue_dbg dbg //err
  83. #define async_dbg dbg //err
  85. #ifdef DEBUG_SLAB
  86. static kmem_cache_t *urb_priv_kmem;
  87. #endif
  89. #define SLAB_FLAG     (in_interrupt ()? SLAB_ATOMIC : SLAB_KERNEL)
  90. #define KMALLOC_FLAG  (in_interrupt ()? GFP_ATOMIC : GFP_KERNEL)
  92. /* CONFIG_USB_UHCI_HIGH_BANDWITH turns on Full Speed Bandwidth
  93.  * Reclamation: feature that puts loop on descriptor loop when
  94.  * there's some transfer going on. With FSBR, USB performance
  95.  * is optimal, but PCI can be slowed down up-to 5 times, slowing down
  96.  * system performance (eg. framebuffer devices).
  97.  */
  98. #define CONFIG_USB_UHCI_HIGH_BANDWIDTH 
  100. /* *_DEPTH_FIRST puts descriptor in depth-first mode. This has
  101.  * somehow similar effect to FSBR (higher speed), but does not
  102.  * slow PCI down. OTOH USB performace is slightly slower than
  103.  * in FSBR case and single device could hog whole USB, starving
  104.  * other devices.
  105.  */
  106. #define USE_CTRL_DEPTH_FIRST 0  // 0: Breadth first, 1: Depth first
  107. #define USE_BULK_DEPTH_FIRST 0  // 0: Breadth first, 1: Depth first
  109. /* Turning off both CONFIG_USB_UHCI_HIGH_BANDWITH and *_DEPTH_FIRST
  110.  * will lead to <64KB/sec performance over USB for bulk transfers targeting
  111.  * one device's endpoint. You probably do not want to do that.
  112.  */
  114. // stop bandwidth reclamation after (roughly) 50ms
  115. #define IDLE_TIMEOUT  (HZ/20)
  117. // Suppress HC interrupt error messages for 5s
  118. #define ERROR_SUPPRESSION_TIME (HZ*5)
  120. _static int rh_submit_urb (urb_t *urb);
  121. _static int rh_unlink_urb (urb_t *urb);
  122. _static int delete_qh (uhci_t *s, uhci_desc_t *qh);
  123. _static int process_transfer (uhci_t *s, urb_t *urb, int mode);
  124. _static int process_interrupt (uhci_t *s, urb_t *urb);
  125. _static int process_iso (uhci_t *s, urb_t *urb, int force);
  127. // How much URBs with ->next are walked
  128. #define MAX_NEXT_COUNT 2048
  130. static uhci_t *devs = NULL;
  132. /* used by userspace UHCI data structure dumper */
  133. uhci_t **uhci_devices = &devs;
  135. /*-------------------------------------------------------------------*/
  136. // Cleans up collected QHs, but not more than 100 in one go
  137. void clean_descs(uhci_t *s, int force)
  138. {
  139. struct list_head *q;
  140. uhci_desc_t *qh;
  141. int now=UHCI_GET_CURRENT_FRAME(s), n=0;
  143. q=s->free_desc.prev;
  145. while (q != &s->free_desc && (force || n<100)) {
  146. qh = list_entry (q, uhci_desc_t, horizontal);
  147. q=qh->horizontal.prev;
  149. if ((qh->last_used!=now) || force)
  150. delete_qh(s,qh);
  151. n++;
  152. }
  153. }
  154. /*-------------------------------------------------------------------*/
  155. _static void uhci_switch_timer_int(uhci_t *s)
  156. {
  158. if (!list_empty(&s->urb_unlinked))
  159. set_td_ioc(s->td1ms);
  160. else
  161. clr_td_ioc(s->td1ms);
  163. if (s->timeout_urbs)
  164. set_td_ioc(s->td32ms);
  165. else
  166. clr_td_ioc(s->td32ms);
  167. wmb();
  168. }
  169. /*-------------------------------------------------------------------*/
  170. #ifdef CONFIG_USB_UHCI_HIGH_BANDWIDTH
  171. _static void enable_desc_loop(uhci_t *s, urb_t *urb)
  172. {
  173. int flags;
  175. if (urb->transfer_flags & USB_NO_FSBR)
  176. return;
  178. spin_lock_irqsave (&s->qh_lock, flags);
  179. s->chain_end->hw.qh.head&=cpu_to_le32(~UHCI_PTR_TERM);
  180. mb();
  181. s->loop_usage++;
  182. ((urb_priv_t*)urb->hcpriv)->use_loop=1;
  183. spin_unlock_irqrestore (&s->qh_lock, flags);
  184. }
  185. /*-------------------------------------------------------------------*/
  186. _static void disable_desc_loop(uhci_t *s, urb_t *urb)
  187. {
  188. int flags;
  190. if (urb->transfer_flags & USB_NO_FSBR)
  191. return;
  193. spin_lock_irqsave (&s->qh_lock, flags);
  194. if (((urb_priv_t*)urb->hcpriv)->use_loop) {
  195. s->loop_usage--;
  197. if (!s->loop_usage) {
  198. s->chain_end->hw.qh.head|=cpu_to_le32(UHCI_PTR_TERM);
  199. mb();
  200. }
  201. ((urb_priv_t*)urb->hcpriv)->use_loop=0;
  202. }
  203. spin_unlock_irqrestore (&s->qh_lock, flags);
  204. }
  205. #endif
  206. /*-------------------------------------------------------------------*/
  207. _static void queue_urb_unlocked (uhci_t *s, urb_t *urb)
  208. {
  209. struct list_head *p=&urb->urb_list;
  210. #ifdef CONFIG_USB_UHCI_HIGH_BANDWIDTH
  211. {
  212. int type;
  213. type=usb_pipetype (urb->pipe);
  215. if ((type == PIPE_BULK) || (type == PIPE_CONTROL))
  216. enable_desc_loop(s, urb);
  217. }
  218. #endif
  219. urb->status = -EINPROGRESS;
  220. ((urb_priv_t*)urb->hcpriv)->started=jiffies;
  221. list_add (p, &s->urb_list);
  222. if (urb->timeout)
  223. s->timeout_urbs++;
  224. uhci_switch_timer_int(s);
  225. }
  226. /*-------------------------------------------------------------------*/
  227. _static void queue_urb (uhci_t *s, urb_t *urb)
  228. {
  229. unsigned long flags=0;
  231. spin_lock_irqsave (&s->urb_list_lock, flags);
  232. queue_urb_unlocked(s,urb);
  233. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  234. }
  235. /*-------------------------------------------------------------------*/
  236. _static void dequeue_urb (uhci_t *s, urb_t *urb)
  237. {
  238. #ifdef CONFIG_USB_UHCI_HIGH_BANDWIDTH
  239. int type;
  241. type=usb_pipetype (urb->pipe);
  243. if ((type == PIPE_BULK) || (type == PIPE_CONTROL))
  244. disable_desc_loop(s, urb);
  245. #endif
  247. list_del (&urb->urb_list);
  248. if (urb->timeout && s->timeout_urbs)
  249. s->timeout_urbs--;
  251. }
  252. /*-------------------------------------------------------------------*/
  253. _static int alloc_td (uhci_t *s, uhci_desc_t ** new, int flags)
  254. {
  255. dma_addr_t dma_handle;
  257. *new = pci_pool_alloc(s->desc_pool, GFP_DMA | GFP_ATOMIC, &dma_handle);
  258. if (!*new)
  259. return -ENOMEM;
  260. memset (*new, 0, sizeof (uhci_desc_t));
  261. (*new)->dma_addr = dma_handle;
  262. set_td_link((*new), UHCI_PTR_TERM | (flags & UHCI_PTR_BITS)); // last by default
  263. (*new)->type = TD_TYPE;
  264. mb();
  265. INIT_LIST_HEAD (&(*new)->vertical);
  266. INIT_LIST_HEAD (&(*new)->horizontal);
  268. return 0;
  269. }
  270. /*-------------------------------------------------------------------*/
  271. // append a qh to td.link physically, the SW linkage is not affected
  272. _static void append_qh(uhci_t *s, uhci_desc_t *td, uhci_desc_t* qh, int  flags)
  273. {
  274. unsigned long xxx;
  276. spin_lock_irqsave (&s->td_lock, xxx);
  278. set_td_link(td, qh->dma_addr | (flags & UHCI_PTR_DEPTH) | UHCI_PTR_QH);
  279.        
  280. mb();
  281. spin_unlock_irqrestore (&s->td_lock, xxx);
  282. }
  283. /*-------------------------------------------------------------------*/
  284. /* insert td at last position in td-list of qh (vertical) */
  285. _static int insert_td (uhci_t *s, uhci_desc_t *qh, uhci_desc_t* new, int flags)
  286. {
  287. uhci_desc_t *prev;
  288. unsigned long xxx;
  290. spin_lock_irqsave (&s->td_lock, xxx);
  292. list_add_tail (&new->vertical, &qh->vertical);
  294. prev = list_entry (new->vertical.prev, uhci_desc_t, vertical);
  296. if (qh == prev ) {
  297. // virgin qh without any tds
  298. set_qh_element(qh, new->dma_addr | UHCI_PTR_TERM);
  299. }
  300. else {
  301. // already tds inserted, implicitely remove TERM bit of prev
  302. set_td_link(prev, new->dma_addr | (flags & UHCI_PTR_DEPTH));
  303. }
  304. mb();
  305. spin_unlock_irqrestore (&s->td_lock, xxx);
  307. return 0;
  308. }
  309. /*-------------------------------------------------------------------*/
  310. /* insert new_td after td (horizontal) */
  311. _static int insert_td_horizontal (uhci_t *s, uhci_desc_t *td, uhci_desc_t* new)
  312. {
  313. uhci_desc_t *next;
  314. unsigned long flags;
  316. spin_lock_irqsave (&s->td_lock, flags);
  318. next = list_entry (td->horizontal.next, uhci_desc_t, horizontal);
  319. list_add (&new->horizontal, &td->horizontal);
  320. new->hw.td.link = td->hw.td.link;
  321. set_td_link(td, new->dma_addr);
  322. mb();
  323. spin_unlock_irqrestore (&s->td_lock, flags);
  325. return 0;
  326. }
  327. /*-------------------------------------------------------------------*/
  328. _static int unlink_td (uhci_t *s, uhci_desc_t *element, int phys_unlink)
  329. {
  330. uhci_desc_t *next, *prev;
  331. int dir = 0;
  332. unsigned long flags;
  334. spin_lock_irqsave (&s->td_lock, flags);
  336. next = list_entry (element->vertical.next, uhci_desc_t, vertical);
  338. if (next == element) {
  339. dir = 1;
  340. prev = list_entry (element->horizontal.prev, uhci_desc_t, horizontal);
  341. }
  342. else 
  343. prev = list_entry (element->vertical.prev, uhci_desc_t, vertical);
  345. if (phys_unlink) {
  346. // really remove HW linking
  347. if (prev->type == TD_TYPE)
  348. prev->hw.td.link = element->hw.td.link;
  349. else
  350. prev->hw.qh.element = element->hw.td.link;
  351. }
  353. mb ();
  355. if (dir == 0)
  356. list_del (&element->vertical);
  357. else
  358. list_del (&element->horizontal);
  360. spin_unlock_irqrestore (&s->td_lock, flags);
  362. return 0;
  363. }
  365. /*-------------------------------------------------------------------*/
  366. _static int delete_desc (uhci_t *s, uhci_desc_t *element)
  367. {
  368. pci_pool_free(s->desc_pool, element, element->dma_addr);
  369. return 0;
  370. }
  371. /*-------------------------------------------------------------------*/
  372. // Allocates qh element
  373. _static int alloc_qh (uhci_t *s, uhci_desc_t ** new)
  374. {
  375. dma_addr_t dma_handle;
  377. *new = pci_pool_alloc(s->desc_pool, GFP_DMA | GFP_ATOMIC, &dma_handle);
  378. if (!*new)
  379. return -ENOMEM;
  380. memset (*new, 0, sizeof (uhci_desc_t));
  381. (*new)->dma_addr = dma_handle;
  382. set_qh_head(*new, UHCI_PTR_TERM);
  383. set_qh_element(*new, UHCI_PTR_TERM);
  384. (*new)->type = QH_TYPE;
  386. mb();
  387. INIT_LIST_HEAD (&(*new)->horizontal);
  388. INIT_LIST_HEAD (&(*new)->vertical);
  390. dbg("Allocated qh @ %p", *new);
  392. return 0;
  393. }
  394. /*-------------------------------------------------------------------*/
  395. // inserts new qh before/after the qh at pos
  396. // flags: 0: insert before pos, 1: insert after pos (for low speed transfers)
  397. _static int insert_qh (uhci_t *s, uhci_desc_t *pos, uhci_desc_t *new, int order)
  398. {
  399. uhci_desc_t *old;
  400. unsigned long flags;
  402. spin_lock_irqsave (&s->qh_lock, flags);
  404. if (!order) {
  405. // (OLD) (POS) -> (OLD) (NEW) (POS)
  406. old = list_entry (pos->horizontal.prev, uhci_desc_t, horizontal);
  407. list_add_tail (&new->horizontal, &pos->horizontal);
  408. set_qh_head(new, MAKE_QH_ADDR (pos)) ;
  409. if (!(old->hw.qh.head & cpu_to_le32(UHCI_PTR_TERM)))
  410. set_qh_head(old, MAKE_QH_ADDR (new)) ;
  411. }
  412. else {
  413. // (POS) (OLD) -> (POS) (NEW) (OLD)
  414. old = list_entry (pos->horizontal.next, uhci_desc_t, horizontal);
  415. list_add (&new->horizontal, &pos->horizontal);
  416. set_qh_head(new, MAKE_QH_ADDR (old));
  417. set_qh_head(pos, MAKE_QH_ADDR (new)) ;
  418. }
  420. mb ();
  422. spin_unlock_irqrestore (&s->qh_lock, flags);
  424. return 0;
  425. }
  427. /*-------------------------------------------------------------------*/
  428. _static int unlink_qh (uhci_t *s, uhci_desc_t *element)
  429. {
  430. uhci_desc_t  *prev;
  431. unsigned long flags;
  433. spin_lock_irqsave (&s->qh_lock, flags);
  435. prev = list_entry (element->horizontal.prev, uhci_desc_t, horizontal);
  436. prev->hw.qh.head = element->hw.qh.head;
  438. dbg("unlink qh %p, pqh %p, nxqh %p, to %08x", element, prev, 
  439.     list_entry (element->horizontal.next, uhci_desc_t, horizontal),le32_to_cpu(element->hw.qh.head) &~15);
  441. list_del(&element->horizontal);
  443. mb ();
  444. spin_unlock_irqrestore (&s->qh_lock, flags);
  446. return 0;
  447. }
  448. /*-------------------------------------------------------------------*/
  449. _static int delete_qh (uhci_t *s, uhci_desc_t *qh)
  450. {
  451. uhci_desc_t *td;
  452. struct list_head *p;
  454. list_del (&qh->horizontal);
  456. while ((p = qh->vertical.next) != &qh->vertical) {
  457. td = list_entry (p, uhci_desc_t, vertical);
  458. dbg("unlink td @ %p",td);
  459. unlink_td (s, td, 0); // no physical unlink
  460. delete_desc (s, td);
  461. }
  463. delete_desc (s, qh);
  465. return 0;
  466. }
  467. /*-------------------------------------------------------------------*/
  468. _static void clean_td_chain (uhci_t *s, uhci_desc_t *td)
  469. {
  470. struct list_head *p;
  471. uhci_desc_t *td1;
  473. if (!td)
  474. return;
  476. while ((p = td->horizontal.next) != &td->horizontal) {
  477. td1 = list_entry (p, uhci_desc_t, horizontal);
  478. delete_desc (s, td1);
  479. }
  481. delete_desc (s, td);
  482. }
  484. /*-------------------------------------------------------------------*/
  485. _static void fill_td (uhci_desc_t *td, int status, int info, __u32 buffer)
  486. {
  487. td->hw.td.status = cpu_to_le32(status);
  488. td->hw.td.info = cpu_to_le32(info);
  489. td->hw.td.buffer = cpu_to_le32(buffer);
  490. }
  491. /*-------------------------------------------------------------------*/
  492. // Removes ALL qhs in chain (paranoia!)
  493. _static void cleanup_skel (uhci_t *s)
  494. {
  495. unsigned int n;
  496. uhci_desc_t *td;
  498. dbg("cleanup_skel");
  500. clean_descs(s,1);
  503. if (s->td32ms) {
  505. unlink_td(s,s->td32ms,1);
  506. delete_desc(s, s->td32ms);
  507. }
  509. for (n = 0; n < 8; n++) {
  510. td = s->int_chain[n];
  511. clean_td_chain (s, td);
  512. }
  514. if (s->iso_td) {
  515. for (n = 0; n < 1024; n++) {
  516. td = s->iso_td[n];
  517. clean_td_chain (s, td);
  518. }
  519. kfree (s->iso_td);
  520. }
  522. if (s->framelist)
  523. pci_free_consistent(s->uhci_pci, PAGE_SIZE,
  524.     s->framelist, s->framelist_dma);
  526. if (s->control_chain) {
  527. // completed init_skel?
  528. struct list_head *p;
  529. uhci_desc_t *qh, *qh1;
  531. qh = s->control_chain;
  532. while ((p = qh->horizontal.next) != &qh->horizontal) {
  533. qh1 = list_entry (p, uhci_desc_t, horizontal);
  534. delete_qh (s, qh1);
  535. }
  537. delete_qh (s, qh);
  538. }
  539. else {
  540. if (s->ls_control_chain)
  541. delete_desc (s, s->ls_control_chain);
  542. if (s->control_chain)
  543. delete_desc (s, s->control_chain);
  544. if (s->bulk_chain)
  545. delete_desc (s, s->bulk_chain);
  546. if (s->chain_end)
  547. delete_desc (s, s->chain_end);
  548. }
  550. if (s->desc_pool) {
  551. pci_pool_destroy(s->desc_pool);
  552. s->desc_pool = NULL;
  553. }
  555. dbg("cleanup_skel finished");
  556. }
  557. /*-------------------------------------------------------------------*/
  558. // allocates framelist and qh-skeletons
  559. // only HW-links provide continous linking, SW-links stay in their domain (ISO/INT)
  560. _static int init_skel (uhci_t *s)
  561. {
  562. int n, ret;
  563. uhci_desc_t *qh, *td;
  565. dbg("init_skel");
  567. s->framelist = pci_alloc_consistent(s->uhci_pci, PAGE_SIZE,
  568.     &s->framelist_dma);
  570. if (!s->framelist)
  571. return -ENOMEM;
  573. memset (s->framelist, 0, 4096);
  575. dbg("creating descriptor pci_pool");
  577. s->desc_pool = pci_pool_create("uhci_desc", s->uhci_pci,
  578.        sizeof(uhci_desc_t), 16, 0,
  579.        GFP_DMA | GFP_ATOMIC);
  580. if (!s->desc_pool)
  581. goto init_skel_cleanup;
  583. dbg("allocating iso desc pointer list");
  584. s->iso_td = (uhci_desc_t **) kmalloc (1024 * sizeof (uhci_desc_t*), GFP_KERNEL);
  586. if (!s->iso_td)
  587. goto init_skel_cleanup;
  589. s->ls_control_chain = NULL;
  590. s->control_chain = NULL;
  591. s->bulk_chain = NULL;
  592. s->chain_end = NULL;
  594. dbg("allocating iso descs");
  595. for (n = 0; n < 1024; n++) {
  596.   // allocate skeleton iso/irq-tds
  597. if (alloc_td (s, &td, 0))
  598. goto init_skel_cleanup;
  600. s->iso_td[n] = td;
  601. s->framelist[n] = cpu_to_le32((__u32) td->dma_addr);
  602. }
  604. dbg("allocating qh: chain_end");
  605. if (alloc_qh (s, &qh))
  606. goto init_skel_cleanup;
  608. s->chain_end = qh;
  610. if (alloc_td (s, &td, 0))
  611. goto init_skel_cleanup;
  613. fill_td (td, 0 * TD_CTRL_IOC, 0, 0); // generate 1ms interrupt (enabled on demand)
  614. insert_td (s, qh, td, 0);
  615. qh->hw.qh.element &= cpu_to_le32(~UHCI_PTR_TERM); // remove TERM bit
  616. s->td1ms=td;
  618. dbg("allocating qh: bulk_chain");
  619. if (alloc_qh (s, &qh))
  620. goto init_skel_cleanup;
  622. insert_qh (s, s->chain_end, qh, 0);
  623. s->bulk_chain = qh;
  625. dbg("allocating qh: control_chain");
  626. ret = alloc_qh (s, &qh);
  627. if (ret)
  628. goto init_skel_cleanup;
  630. insert_qh (s, s->bulk_chain, qh, 0);
  631. s->control_chain = qh;
  633. #ifdef CONFIG_USB_UHCI_HIGH_BANDWIDTH
  634. // disabled reclamation loop
  635. set_qh_head(s->chain_end, s->control_chain->dma_addr | UHCI_PTR_QH | UHCI_PTR_TERM);
  636. #endif
  638. dbg("allocating qh: ls_control_chain");
  639. if (alloc_qh (s, &qh))
  640. goto init_skel_cleanup;
  642. insert_qh (s, s->control_chain, qh, 0);
  643. s->ls_control_chain = qh;
  645. for (n = 0; n < 8; n++)
  646. s->int_chain[n] = 0;
  648. dbg("allocating skeleton INT-TDs");
  650. for (n = 0; n < 8; n++) {
  651. uhci_desc_t *td;
  653. if (alloc_td (s, &td, 0))
  654. goto init_skel_cleanup;
  656. s->int_chain[n] = td;
  657. if (n == 0) {
  658. set_td_link(s->int_chain[0], s->ls_control_chain->dma_addr | UHCI_PTR_QH);
  659. }
  660. else {
  661. set_td_link(s->int_chain[n], s->int_chain[0]->dma_addr);
  662. }
  663. }
  665. dbg("Linking skeleton INT-TDs");
  667. for (n = 0; n < 1024; n++) {
  668. // link all iso-tds to the interrupt chains
  669. int m, o;
  670. dbg("framelist[%i]=%x",n,le32_to_cpu(s->framelist[n]));
  671. if ((n&127)==127) 
  672. ((uhci_desc_t*) s->iso_td[n])->hw.td.link = cpu_to_le32(s->int_chain[0]->dma_addr);
  673. else 
  674. for (o = 1, m = 2; m <= 128; o++, m += m)
  675. if ((n & (m - 1)) == ((m - 1) / 2))
  676. set_td_link(((uhci_desc_t*) s->iso_td[n]), s->int_chain[o]->dma_addr);
  677. }
  679. if (alloc_td (s, &td, 0))
  680. goto init_skel_cleanup;
  682. fill_td (td, 0 * TD_CTRL_IOC, 0, 0); // generate 32ms interrupt (activated later)
  683. s->td32ms=td;
  685. insert_td_horizontal (s, s->int_chain[5], td);
  687. mb();
  688. //uhci_show_queue(s->control_chain);   
  689. dbg("init_skel exit");
  690. return 0;
  692.       init_skel_cleanup:
  693. cleanup_skel (s);
  694. return -ENOMEM;
  695. }
  697. /*-------------------------------------------------------------------*/
  698. //                         LOW LEVEL STUFF
  699. //          assembles QHs und TDs for control, bulk and iso
  700. /*-------------------------------------------------------------------*/
  701. _static int uhci_submit_control_urb (urb_t *urb)
  702. {
  703. uhci_desc_t *qh, *td;
  704. uhci_t *s = (uhci_t*) urb->dev->bus->hcpriv;
  705. urb_priv_t *urb_priv = urb->hcpriv;
  706. unsigned long destination, status;
  707. int maxsze = usb_maxpacket (urb->dev, urb->pipe, usb_pipeout (urb->pipe));
  708. unsigned long len;
  709. char *data;
  710. int depth_first=USE_CTRL_DEPTH_FIRST;  // UHCI descriptor chasing method
  712. dbg("uhci_submit_control start");
  713. if (alloc_qh (s, &qh)) // alloc qh for this request
  714. return -ENOMEM;
  716. if (alloc_td (s, &td, UHCI_PTR_DEPTH * depth_first)) // get td for setup stage
  717. {
  718. delete_qh (s, qh);
  719. return -ENOMEM;
  720. }
  722. /* The "pipe" thing contains the destination in bits 8--18 */
  723. destination = (urb->pipe & PIPE_DEVEP_MASK) | USB_PID_SETUP;
  725. /* 3 errors */
  726. status = (urb->pipe & TD_CTRL_LS) | TD_CTRL_ACTIVE |
  727. (urb->transfer_flags & USB_DISABLE_SPD ? 0 : TD_CTRL_SPD) | (3 << 27);
  729. /*  Build the TD for the control request, try forever, 8 bytes of data */
  730. fill_td (td, status, destination | (7 << 21), urb_priv->setup_packet_dma);
  732. insert_td (s, qh, td, 0); // queue 'setup stage'-td in qh
  733. #if 0
  734. {
  735. char *sp=urb->setup_packet;
  736. dbg("SETUP to pipe %x: %x %x %x %x %x %x %x %x", urb->pipe,
  737.     sp[0],sp[1],sp[2],sp[3],sp[4],sp[5],sp[6],sp[7]);
  738. }
  739. //uhci_show_td(td);
  740. #endif
  742. len = urb->transfer_buffer_length;
  743. data = urb->transfer_buffer;
  745. /* If direction is "send", change the frame from SETUP (0x2D)
  746.    to OUT (0xE1). Else change it from SETUP to IN (0x69). */
  748. destination = (urb->pipe & PIPE_DEVEP_MASK) | (usb_pipeout (urb->pipe)?USB_PID_OUT:USB_PID_IN);
  750. while (len > 0) {
  751. int pktsze = len;
  753. if (alloc_td (s, &td, UHCI_PTR_DEPTH * depth_first))
  754. goto fail_unmap_enomem;
  756. if (pktsze > maxsze)
  757. pktsze = maxsze;
  759. destination ^= 1 << TD_TOKEN_TOGGLE; // toggle DATA0/1
  761. // Status, pktsze bytes of data
  762. fill_td (td, status, destination | ((pktsze - 1) << 21),
  763.  urb_priv->transfer_buffer_dma + (data - (char *)urb->transfer_buffer));
  765. insert_td (s, qh, td, UHCI_PTR_DEPTH * depth_first); // queue 'data stage'-td in qh
  767. data += pktsze;
  768. len -= pktsze;
  769. }
  771. /* Build the final TD for control status */
  772. /* It's only IN if the pipe is out AND we aren't expecting data */
  774. destination &= ~UHCI_PID;
  776. if (usb_pipeout (urb->pipe) || (urb->transfer_buffer_length == 0))
  777. destination |= USB_PID_IN;
  778. else
  779. destination |= USB_PID_OUT;
  781. destination |= 1 << TD_TOKEN_TOGGLE; /* End in Data1 */
  783. if (alloc_td (s, &td, UHCI_PTR_DEPTH))
  784. goto fail_unmap_enomem;
  786. status &=~TD_CTRL_SPD;
  788. /* no limit on errors on final packet , 0 bytes of data */
  789. fill_td (td, status | TD_CTRL_IOC, destination | (UHCI_NULL_DATA_SIZE << 21),
  790.  0);
  792. insert_td (s, qh, td, UHCI_PTR_DEPTH * depth_first); // queue status td
  794. list_add (&qh->desc_list, &urb_priv->desc_list);
  796. queue_urb (s, urb); // queue before inserting in desc chain
  798. qh->hw.qh.element &= cpu_to_le32(~UHCI_PTR_TERM);
  800. //uhci_show_queue(qh);
  801. /* Start it up... put low speed first */
  802. if (urb->pipe & TD_CTRL_LS)
  803. insert_qh (s, s->control_chain, qh, 0);
  804. else
  805. insert_qh (s, s->bulk_chain, qh, 0);
  807. dbg("uhci_submit_control end");
  808. return 0;
  810. fail_unmap_enomem:
  811. delete_qh(s, qh);
  812. return -ENOMEM;
  813. }
  814. /*-------------------------------------------------------------------*/
  815. // For queued bulk transfers, two additional QH helpers are allocated (nqh, bqh)
  816. // Due to the linking with other bulk urbs, it has to be locked with urb_list_lock!
  818. _static int uhci_submit_bulk_urb (urb_t *urb, urb_t *bulk_urb)
  819. {
  820. uhci_t *s = (uhci_t*) urb->dev->bus->hcpriv;
  821. urb_priv_t *urb_priv = urb->hcpriv, *upriv, *bpriv=NULL;
  822. uhci_desc_t *qh, *td, *nqh=NULL, *bqh=NULL, *first_td=NULL;
  823. unsigned long destination, status;
  824. char *data;
  825. unsigned int pipe = urb->pipe;
  826. int maxsze = usb_maxpacket (urb->dev, pipe, usb_pipeout (pipe));
  827. int info, len, last;
  828. int depth_first=USE_BULK_DEPTH_FIRST;  // UHCI descriptor chasing method
  830. if (usb_endpoint_halted (urb->dev, usb_pipeendpoint (pipe), usb_pipeout (pipe)))
  831. return -EPIPE;
  833. queue_dbg("uhci_submit_bulk_urb: urb %p, old %p, pipe %08x, len %i",
  834.   urb,bulk_urb,urb->pipe,urb->transfer_buffer_length);
  836. upriv = (urb_priv_t*)urb->hcpriv;
  838. if (!bulk_urb) {
  839. if (alloc_qh (s, &qh)) // get qh for this request
  840. return -ENOMEM;
  842. if (urb->transfer_flags & USB_QUEUE_BULK) {
  843. if (alloc_qh(s, &nqh)) // placeholder for clean unlink
  844. {
  845. delete_desc (s, qh);
  846. return -ENOMEM;
  847. }
  848. upriv->next_qh = nqh;
  849. queue_dbg("new next qh %p",nqh);
  850. }
  851. }
  852. else { 
  853. bpriv = (urb_priv_t*)bulk_urb->hcpriv;
  854. qh = bpriv->bottom_qh;  // re-use bottom qh and next qh
  855. nqh = bpriv->next_qh;
  856. upriv->next_qh=nqh;
  857. upriv->prev_queued_urb=bulk_urb;
  858. }
  860. if (urb->transfer_flags & USB_QUEUE_BULK) {
  861. if (alloc_qh (s, &bqh))  // "bottom" QH
  862. {
  863. if (!bulk_urb) { 
  864. delete_desc(s, qh);
  865. delete_desc(s, nqh);
  866. }
  867. return -ENOMEM;
  868. }
  869. set_qh_element(bqh, UHCI_PTR_TERM);
  870. set_qh_head(bqh, nqh->dma_addr | UHCI_PTR_QH); // element
  871. upriv->bottom_qh = bqh;
  872. }
  873. queue_dbg("uhci_submit_bulk: qh %p bqh %p nqh %p",qh, bqh, nqh);
  875. /* The "pipe" thing contains the destination in bits 8--18. */
  876. destination = (pipe & PIPE_DEVEP_MASK) | usb_packetid (pipe);
  878. /* 3 errors */
  879. status = (pipe & TD_CTRL_LS) | TD_CTRL_ACTIVE |
  880. ((urb->transfer_flags & USB_DISABLE_SPD) ? 0 : TD_CTRL_SPD) | (3 << 27);
  882. /* Build the TDs for the bulk request */
  883. len = urb->transfer_buffer_length;
  884. data = urb->transfer_buffer;
  886. do { // TBD: Really allow zero-length packets?
  887. int pktsze = len;
  889. if (alloc_td (s, &td, UHCI_PTR_DEPTH * depth_first))
  890. {
  891. delete_qh (s, qh);
  892. return -ENOMEM;
  893. }
  895. if (pktsze > maxsze)
  896. pktsze = maxsze;
  898. // pktsze bytes of data 
  899. info = destination | (((pktsze - 1)&UHCI_NULL_DATA_SIZE) << 21) |
  900. (usb_gettoggle (urb->dev, usb_pipeendpoint (pipe), usb_pipeout (pipe)) << TD_TOKEN_TOGGLE);
  902. fill_td (td, status, info,
  903.  urb_priv->transfer_buffer_dma + (data - (char *)urb->transfer_buffer));
  905. data += pktsze;
  906. len -= pktsze;
  907. // Use USB_ZERO_PACKET to finish bulk OUTs always with a zero length packet
  908. last = (len == 0 && (usb_pipein(pipe) || pktsze < maxsze || !(urb->transfer_flags & USB_ZERO_PACKET)));
  910. if (last)
  911. set_td_ioc(td); // last one generates INT
  913. insert_td (s, qh, td, UHCI_PTR_DEPTH * depth_first);
  914. if (!first_td)
  915. first_td=td;
  916. usb_dotoggle (urb->dev, usb_pipeendpoint (pipe), usb_pipeout (pipe));
  918. } while (!last);
  920. if (bulk_urb && bpriv)   // everything went OK, link with old bulk URB
  921. bpriv->next_queued_urb=urb;
  923. list_add (&qh->desc_list, &urb_priv->desc_list);
  925. if (urb->transfer_flags & USB_QUEUE_BULK)
  926. append_qh(s, td, bqh, UHCI_PTR_DEPTH * depth_first);
  928. queue_urb_unlocked (s, urb);
  930. if (urb->transfer_flags & USB_QUEUE_BULK)
  931. set_qh_element(qh, first_td->dma_addr);
  932. else
  933. qh->hw.qh.element &= cpu_to_le32(~UHCI_PTR_TERM);    // arm QH
  935. if (!bulk_urb) {  // new bulk queue
  936. if (urb->transfer_flags & USB_QUEUE_BULK) {
  937. spin_lock (&s->td_lock); // both QHs in one go
  938. insert_qh (s, s->chain_end, qh, 0); // Main QH
  939. insert_qh (s, s->chain_end, nqh, 0); // Helper QH
  940. spin_unlock (&s->td_lock);
  941. }
  942. else
  943. insert_qh (s, s->chain_end, qh, 0);
  944. }
  946. //uhci_show_queue(s->bulk_chain);
  947. //dbg("uhci_submit_bulk_urb: exitn");
  948. return 0;
  949. }
  950. /*-------------------------------------------------------------------*/
  951. _static void uhci_clean_iso_step1(uhci_t *s, urb_priv_t *urb_priv)
  952. {
  953. struct list_head *p;
  954. uhci_desc_t *td;
  956. for (p = urb_priv->desc_list.next; p != &urb_priv->desc_list; p = p->next) {
  957. td = list_entry (p, uhci_desc_t, desc_list);
  958. unlink_td (s, td, 1);
  959. }
  960. }
  961. /*-------------------------------------------------------------------*/
  962. _static void uhci_clean_iso_step2(uhci_t *s, urb_priv_t *urb_priv)
  963. {
  964. struct list_head *p;
  965. uhci_desc_t *td;
  967. while ((p = urb_priv->desc_list.next) != &urb_priv->desc_list) {
  968. td = list_entry (p, uhci_desc_t, desc_list);
  969. list_del (p);
  970. delete_desc (s, td);
  971. }
  972. }
  973. /*-------------------------------------------------------------------*/
  974. /* mode: CLEAN_TRANSFER_NO_DELETION: unlink but no deletion mark (step 1 of async_unlink)
  975.          CLEAN_TRANSFER_REGULAR: regular (unlink/delete-mark)
  976.          CLEAN_TRANSFER_DELETION_MARK: deletion mark for QH (step 2 of async_unlink)
  977.  looks a bit complicated because of all the bulk queueing goodies
  978. */
  980. _static void uhci_clean_transfer (uhci_t *s, urb_t *urb, uhci_desc_t *qh, int mode)
  981. {
  982. uhci_desc_t *bqh, *nqh, *prevqh, *prevtd;
  983. int now;
  984. urb_priv_t *priv=(urb_priv_t*)urb->hcpriv;
  986. now=UHCI_GET_CURRENT_FRAME(s);
  988. bqh=priv->bottom_qh;
  990. if (!priv->next_queued_urb)  { // no more appended bulk queues
  992. queue_dbg("uhci_clean_transfer: No more bulks for urb %p, qh %p, bqh %p, nqh %p", urb, qh, bqh, priv->next_qh);
  994. if (priv->prev_queued_urb && mode != CLEAN_TRANSFER_DELETION_MARK) {  // qh not top of the queue
  995. unsigned long flags; 
  996. urb_priv_t* ppriv=(urb_priv_t*)priv->prev_queued_urb->hcpriv;
  998. spin_lock_irqsave (&s->qh_lock, flags);
  999. prevqh = list_entry (ppriv->desc_list.next, uhci_desc_t, desc_list);
  1000. prevtd = list_entry (prevqh->vertical.prev, uhci_desc_t, vertical);
  1001. set_td_link(prevtd, priv->bottom_qh->dma_addr | UHCI_PTR_QH); // skip current qh
  1002. mb();
  1003. queue_dbg("uhci_clean_transfer: relink pqh %p, ptd %p",prevqh, prevtd);
  1004. spin_unlock_irqrestore (&s->qh_lock, flags);
  1006. ppriv->bottom_qh = priv->bottom_qh;
  1007. ppriv->next_queued_urb = NULL;
  1008. }
  1009. else {   // queue is dead, qh is top of the queue
  1011. if (mode != CLEAN_TRANSFER_DELETION_MARK) 
  1012. unlink_qh(s, qh); // remove qh from horizontal chain
  1014. if (bqh) {  // remove remainings of bulk queue
  1015. nqh=priv->next_qh;
  1017. if (mode != CLEAN_TRANSFER_DELETION_MARK) 
  1018. unlink_qh(s, nqh);  // remove nqh from horizontal chain
  1020. if (mode != CLEAN_TRANSFER_NO_DELETION) {  // add helper QHs to free desc list
  1021. nqh->last_used = bqh->last_used = now;
  1022. list_add_tail (&nqh->horizontal, &s->free_desc);
  1023. list_add_tail (&bqh->horizontal, &s->free_desc);
  1024. }
  1025. }
  1026. }
  1027. }
  1028. else { // there are queued urbs following
  1030.   queue_dbg("uhci_clean_transfer: urb %p, prevurb %p, nexturb %p, qh %p, bqh %p, nqh %p",
  1031.        urb, priv->prev_queued_urb,  priv->next_queued_urb, qh, bqh, priv->next_qh);
  1032.        
  1033. if (mode != CLEAN_TRANSFER_DELETION_MARK) { // no work for cleanup at unlink-completion
  1034. urb_t *nurb;
  1035. unsigned long flags;
  1037. nurb = priv->next_queued_urb;
  1038. spin_lock_irqsave (&s->qh_lock, flags);
  1040. if (!priv->prev_queued_urb) { // top QH
  1042. prevqh = list_entry (qh->horizontal.prev, uhci_desc_t, horizontal);
  1043. set_qh_head(prevqh, bqh->dma_addr | UHCI_PTR_QH);
  1044. list_del (&qh->horizontal);  // remove this qh form horizontal chain
  1045. list_add (&bqh->horizontal, &prevqh->horizontal); // insert next bqh in horizontal chain
  1046. }
  1047. else { // intermediate QH
  1048. urb_priv_t* ppriv=(urb_priv_t*)priv->prev_queued_urb->hcpriv;
  1049. urb_priv_t* npriv=(urb_priv_t*)nurb->hcpriv;
  1050. uhci_desc_t * bnqh;
  1052. bnqh = list_entry (npriv->desc_list.next, uhci_desc_t, desc_list);
  1053. ppriv->bottom_qh = bnqh;
  1054. ppriv->next_queued_urb = nurb;
  1055. prevqh = list_entry (ppriv->desc_list.next, uhci_desc_t, desc_list);
  1056. set_qh_head(prevqh, bqh->dma_addr | UHCI_PTR_QH);
  1057. }
  1059. mb();
  1060. ((urb_priv_t*)nurb->hcpriv)->prev_queued_urb=priv->prev_queued_urb;
  1061. spin_unlock_irqrestore (&s->qh_lock, flags);
  1062. }
  1063. }
  1065. if (mode != CLEAN_TRANSFER_NO_DELETION) {
  1066. qh->last_used = now;
  1067. list_add_tail (&qh->horizontal, &s->free_desc); // mark qh for later deletion/kfree
  1068. }
  1069. }
  1070. /*-------------------------------------------------------------------*/
  1071. // Release bandwidth for Interrupt or Isoc. transfers 
  1072. _static void uhci_release_bandwidth(urb_t *urb)
  1073. {       
  1074. if (urb->bandwidth) {
  1075. switch (usb_pipetype(urb->pipe)) {
  1076. case PIPE_INTERRUPT:
  1077. usb_release_bandwidth (urb->dev, urb, 0);
  1078. break;
  1079. case PIPE_ISOCHRONOUS:
  1080. usb_release_bandwidth (urb->dev, urb, 1);
  1081. break;
  1082. default:
  1083. break;
  1084. }
  1085. }
  1086. }
  1088. _static void uhci_urb_dma_sync(uhci_t *s, urb_t *urb, urb_priv_t *urb_priv)
  1089. {
  1090. if (urb_priv->setup_packet_dma)
  1091. pci_dma_sync_single(s->uhci_pci, urb_priv->setup_packet_dma,
  1092.     sizeof(devrequest), PCI_DMA_TODEVICE);
  1094. if (urb_priv->transfer_buffer_dma)
  1095. pci_dma_sync_single(s->uhci_pci, urb_priv->transfer_buffer_dma,
  1096.     urb->transfer_buffer_length,
  1097.     usb_pipein(urb->pipe) ?
  1098.     PCI_DMA_FROMDEVICE :
  1099.     PCI_DMA_TODEVICE);
  1100. }
  1102. _static void uhci_urb_dma_unmap(uhci_t *s, urb_t *urb, urb_priv_t *urb_priv)
  1103. {
  1104. if (urb_priv->setup_packet_dma) {
  1105. pci_unmap_single(s->uhci_pci, urb_priv->setup_packet_dma,
  1106.  sizeof(devrequest), PCI_DMA_TODEVICE);
  1107. urb_priv->setup_packet_dma = 0;
  1108. }
  1109. if (urb_priv->transfer_buffer_dma) {
  1110. pci_unmap_single(s->uhci_pci, urb_priv->transfer_buffer_dma,
  1111.  urb->transfer_buffer_length,
  1112.  usb_pipein(urb->pipe) ?
  1113.  PCI_DMA_FROMDEVICE :
  1114.  PCI_DMA_TODEVICE);
  1115. urb_priv->transfer_buffer_dma = 0;
  1116. }
  1117. }
  1118. /*-------------------------------------------------------------------*/
  1119. /* needs urb_list_lock!
  1120.    mode: UNLINK_ASYNC_STORE_URB: unlink and move URB into unlinked list
  1121.          UNLINK_ASYNC_DONT_STORE: unlink, don't move URB into unlinked list
  1122. */
  1123. _static int uhci_unlink_urb_async (uhci_t *s,urb_t *urb, int mode)
  1124. {
  1125. uhci_desc_t *qh;
  1126. urb_priv_t *urb_priv;
  1128. async_dbg("unlink_urb_async called %p",urb);
  1130. if ((urb->status == -EINPROGRESS) ||
  1131.     ((usb_pipetype (urb->pipe) ==  PIPE_INTERRUPT) && ((urb_priv_t*)urb->hcpriv)->flags))
  1132. {
  1133. ((urb_priv_t*)urb->hcpriv)->started = ~0;  // mark
  1134. dequeue_urb (s, urb);
  1136. if (mode==UNLINK_ASYNC_STORE_URB)
  1137. list_add_tail (&urb->urb_list, &s->urb_unlinked); // store urb
  1139. uhci_switch_timer_int(s);
  1140.         s->unlink_urb_done = 1;
  1141. uhci_release_bandwidth(urb);
  1143. urb->status = -ECONNABORTED; // mark urb as "waiting to be killed"
  1144. urb_priv = (urb_priv_t*)urb->hcpriv;
  1146. switch (usb_pipetype (urb->pipe)) {
  1147. case PIPE_INTERRUPT:
  1148. usb_dotoggle (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe));
  1150. case PIPE_ISOCHRONOUS:
  1151. uhci_clean_iso_step1 (s, urb_priv);
  1152. break;
  1154. case PIPE_BULK:
  1155. case PIPE_CONTROL:
  1156. qh = list_entry (urb_priv->desc_list.next, uhci_desc_t, desc_list);
  1157. uhci_clean_transfer (s, urb, qh, CLEAN_TRANSFER_NO_DELETION);
  1158. break;
  1159. }
  1160. ((urb_priv_t*)urb->hcpriv)->started = UHCI_GET_CURRENT_FRAME(s);
  1161. return -EINPROGRESS;  // completion will follow
  1162. }
  1164. return 0;    // URB already dead
  1165. }
  1166. /*-------------------------------------------------------------------*/
  1167. // kills an urb by unlinking descriptors and waiting for at least one frame
  1168. _static int uhci_unlink_urb_sync (uhci_t *s, urb_t *urb)
  1169. {
  1170. uhci_desc_t *qh;
  1171. urb_priv_t *urb_priv;
  1172. unsigned long flags=0;
  1173. struct usb_device *usb_dev;
  1175. spin_lock_irqsave (&s->urb_list_lock, flags);
  1177. if (urb->status == -EINPROGRESS) {
  1179. // move descriptors out the the running chains, dequeue urb
  1180. uhci_unlink_urb_async(s, urb, UNLINK_ASYNC_DONT_STORE);
  1182. urb_priv = urb->hcpriv;
  1183. urb->status = -ENOENT; // prevent from double deletion after unlock
  1184. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  1186. // cleanup the rest
  1187. switch (usb_pipetype (urb->pipe)) {
  1189. case PIPE_INTERRUPT:
  1190. case PIPE_ISOCHRONOUS:
  1191. uhci_wait_ms(1);
  1192. uhci_clean_iso_step2(s, urb_priv);
  1193. break;
  1195. case PIPE_BULK:
  1196. case PIPE_CONTROL:
  1197. qh = list_entry (urb_priv->desc_list.next, uhci_desc_t, desc_list);
  1198. uhci_clean_transfer(s, urb, qh, CLEAN_TRANSFER_DELETION_MARK);
  1199. uhci_wait_ms(1);
  1200. }
  1201. urb->status = -ENOENT; // mark urb as killed
  1203. uhci_urb_dma_unmap(s, urb, urb->hcpriv);
  1205. #ifdef DEBUG_SLAB
  1206. kmem_cache_free (urb_priv_kmem, urb->hcpriv);
  1207. #else
  1208. kfree (urb->hcpriv);
  1209. #endif
  1210. usb_dev = urb->dev;
  1211. if (urb->complete) {
  1212. dbg("unlink_urb: calling completion");
  1213. urb->dev = NULL;
  1214. urb->complete ((struct urb *) urb);
  1215. }
  1216. usb_dec_dev_use (usb_dev);
  1217. }
  1218. else
  1219. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  1221. return 0;
  1222. }
  1223. /*-------------------------------------------------------------------*/
  1224. // async unlink_urb completion/cleanup work
  1225. // has to be protected by urb_list_lock!
  1226. // features: if set in transfer_flags, the resulting status of the killed
  1227. // transaction is not overwritten
  1229. _static void uhci_cleanup_unlink(uhci_t *s, int force)
  1230. {
  1231. struct list_head *q;
  1232. urb_t *urb;
  1233. struct usb_device *dev;
  1234. int now, type;
  1235. urb_priv_t *urb_priv;
  1237. q=s->urb_unlinked.next;
  1238. now=UHCI_GET_CURRENT_FRAME(s);
  1240. while (q != &s->urb_unlinked) {
  1242. urb = list_entry (q, urb_t, urb_list);
  1244. urb_priv = (urb_priv_t*)urb->hcpriv;
  1245. q = urb->urb_list.next;
  1247. if (!urb_priv) // avoid crash when URB is corrupted
  1248. break;
  1250. if (force || ((urb_priv->started != ~0) && (urb_priv->started != now))) {
  1251. async_dbg("async cleanup %p",urb);
  1252. type=usb_pipetype (urb->pipe);
  1254. switch (type) { // process descriptors
  1255. case PIPE_CONTROL:
  1256. process_transfer (s, urb, CLEAN_TRANSFER_DELETION_MARK);  // don't unlink (already done)
  1257. break;
  1258. case PIPE_BULK:
  1259. if (!s->avoid_bulk.counter)
  1260. process_transfer (s, urb, CLEAN_TRANSFER_DELETION_MARK); // don't unlink (already done)
  1261. else
  1262. continue;
  1263. break;
  1264. case PIPE_ISOCHRONOUS:
  1265. process_iso (s, urb, PROCESS_ISO_FORCE); // force, don't unlink
  1266. break;
  1267. case PIPE_INTERRUPT:
  1268. process_interrupt (s, urb);
  1269. break;
  1270. }
  1272. if (!(urb->transfer_flags & USB_TIMEOUT_KILLED))
  1273.    urb->status = -ECONNRESET; // mark as asynchronously killed
  1275. dev = urb->dev; // completion may destroy all...
  1276. urb_priv = urb->hcpriv;
  1277. list_del (&urb->urb_list);
  1279. uhci_urb_dma_sync(s, urb, urb_priv);
  1280. if (urb->complete) {
  1281. spin_unlock(&s->urb_list_lock);
  1282. urb->dev = NULL;
  1283. urb->complete ((struct urb *) urb);
  1284. spin_lock(&s->urb_list_lock);
  1285. }
  1287. if (!(urb->transfer_flags & USB_TIMEOUT_KILLED))
  1288. urb->status = -ENOENT;  // now the urb is really dead
  1290. switch (type) {
  1291. case PIPE_ISOCHRONOUS:
  1292. case PIPE_INTERRUPT:
  1293. uhci_clean_iso_step2(s, urb_priv);
  1294. break;
  1295. }
  1297. uhci_urb_dma_unmap(s, urb, urb_priv);
  1299. usb_dec_dev_use (dev);
  1300. #ifdef DEBUG_SLAB
  1301. kmem_cache_free (urb_priv_kmem, urb_priv);
  1302. #else
  1303. kfree (urb_priv);
  1304. #endif
  1306. }
  1307. }
  1308. }
  1309.  
  1310. /*-------------------------------------------------------------------*/
  1311. _static int uhci_unlink_urb (urb_t *urb)
  1312. {
  1313. uhci_t *s;
  1314. unsigned long flags=0;
  1315. dbg("uhci_unlink_urb called for %p",urb);
  1316. if (!urb || !urb->dev) // you never know...
  1317. return -EINVAL;
  1319. s = (uhci_t*) urb->dev->bus->hcpriv;
  1321. if (usb_pipedevice (urb->pipe) == s->rh.devnum)
  1322. return rh_unlink_urb (urb);
  1324. if (!urb->hcpriv)
  1325. return -EINVAL;
  1327. if (urb->transfer_flags & USB_ASYNC_UNLINK) {
  1328. int ret;
  1329.         spin_lock_irqsave (&s->urb_list_lock, flags);
  1330.        
  1331. uhci_release_bandwidth(urb);
  1332. ret = uhci_unlink_urb_async(s, urb, UNLINK_ASYNC_STORE_URB);
  1334. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  1335. return ret;
  1336. }
  1337. else
  1338. return uhci_unlink_urb_sync(s, urb);
  1339. }
  1340. /*-------------------------------------------------------------------*/
  1341. // In case of ASAP iso transfer, search the URB-list for already queued URBs
  1342. // for this EP and calculate the earliest start frame for the new
  1343. // URB (easy seamless URB continuation!)
  1344. _static int find_iso_limits (urb_t *urb, unsigned int *start, unsigned int *end)
  1345. {
  1346. urb_t *u, *last_urb = NULL;
  1347. uhci_t *s = (uhci_t*) urb->dev->bus->hcpriv;
  1348. struct list_head *p;
  1349. int ret=-1;
  1350. unsigned long flags;
  1352. spin_lock_irqsave (&s->urb_list_lock, flags);
  1353. p=s->urb_list.prev;
  1355. for (; p != &s->urb_list; p = p->prev) {
  1356. u = list_entry (p, urb_t, urb_list);
  1357. // look for pending URBs with identical pipe handle
  1358. // works only because iso doesn't toggle the data bit!
  1359. if ((urb->pipe == u->pipe) && (urb->dev == u->dev) && (u->status == -EINPROGRESS)) {
  1360. if (!last_urb)
  1361. *start = u->start_frame;
  1362. last_urb = u;
  1363. }
  1364. }
  1366. if (last_urb) {
  1367. *end = (last_urb->start_frame + last_urb->number_of_packets) & 1023;
  1368. ret=0;
  1369. }
  1371. spin_unlock_irqrestore(&s->urb_list_lock, flags);
  1373. return ret;
  1374. }
  1375. /*-------------------------------------------------------------------*/
  1376. // adjust start_frame according to scheduling constraints (ASAP etc)
  1378. _static int iso_find_start (urb_t *urb)
  1379. {
  1380. uhci_t *s = (uhci_t*) urb->dev->bus->hcpriv;
  1381. unsigned int now;
  1382. unsigned int start_limit = 0, stop_limit = 0, queued_size;
  1383. int limits;
  1385. now = UHCI_GET_CURRENT_FRAME (s) & 1023;
  1387. if ((unsigned) urb->number_of_packets > 900)
  1388. return -EFBIG;
  1390. limits = find_iso_limits (urb, &start_limit, &stop_limit);
  1391. queued_size = (stop_limit - start_limit) & 1023;
  1393. if (urb->transfer_flags & USB_ISO_ASAP) {
  1394. // first iso
  1395. if (limits) {
  1396. // 10ms setup should be enough //FIXME!
  1397. urb->start_frame = (now + 10) & 1023;
  1398. }
  1399. else {
  1400. urb->start_frame = stop_limit; //seamless linkage
  1402. if (((now - urb->start_frame) & 1023) <= (unsigned) urb->number_of_packets) {
  1403. info("iso_find_start: gap in seamless isochronous scheduling");
  1404. dbg("iso_find_start: now %u start_frame %u number_of_packets %u pipe 0x%08x",
  1405. now, urb->start_frame, urb->number_of_packets, urb->pipe);
  1406. urb->start_frame = (now + 5) & 1023; // 5ms setup should be enough //FIXME!
  1407. }
  1408. }
  1409. }
  1410. else {
  1411. urb->start_frame &= 1023;
  1412. if (((now - urb->start_frame) & 1023) < (unsigned) urb->number_of_packets) {
  1413. dbg("iso_find_start: now between start_frame and end");
  1414. return -EAGAIN;
  1415. }
  1416. }
  1418. /* check if either start_frame or start_frame+number_of_packets-1 lies between start_limit and stop_limit */
  1419. if (limits)
  1420. return 0;
  1422. if (((urb->start_frame - start_limit) & 1023) < queued_size ||
  1423.     ((urb->start_frame + urb->number_of_packets - 1 - start_limit) & 1023) < queued_size) {
  1424. dbg("iso_find_start: start_frame %u number_of_packets %u start_limit %u stop_limit %u",
  1425. urb->start_frame, urb->number_of_packets, start_limit, stop_limit);
  1426. return -EAGAIN;
  1427. }
  1429. return 0;
  1430. }
  1431. /*-------------------------------------------------------------------*/
  1432. // submits USB interrupt (ie. polling ;-) 
  1433. // ASAP-flag set implicitely
  1434. // if period==0, the transfer is only done once
  1436. _static int uhci_submit_int_urb (urb_t *urb)
  1437. {
  1438. uhci_t *s = (uhci_t*) urb->dev->bus->hcpriv;
  1439. urb_priv_t *urb_priv = urb->hcpriv;
  1440. int nint, n;
  1441. uhci_desc_t *td;
  1442. int status, destination;
  1443. int info;
  1444. unsigned int pipe = urb->pipe;
  1446. if (urb->interval < 0 || urb->interval >= 256)
  1447. return -EINVAL;
  1449. if (urb->interval == 0)
  1450. nint = 0;
  1451. else {
  1452. for (nint = 0, n = 1; nint <= 8; nint++, n += n) // round interval down to 2^n
  1453.  {
  1454. if (urb->interval < n) {
  1455. urb->interval = n / 2;
  1456. break;
  1457. }
  1458. }
  1459. nint--;
  1460. }
  1462. dbg("Rounded interval to %i, chain  %i", urb->interval, nint);
  1464. urb->start_frame = UHCI_GET_CURRENT_FRAME (s) & 1023; // remember start frame, just in case...
  1466. urb->number_of_packets = 1;
  1468. // INT allows only one packet
  1469. if (urb->transfer_buffer_length > usb_maxpacket (urb->dev, pipe, usb_pipeout (pipe)))
  1470. return -EINVAL;
  1472. if (alloc_td (s, &td, UHCI_PTR_DEPTH))
  1473. return -ENOMEM;
  1475. status = (pipe & TD_CTRL_LS) | TD_CTRL_ACTIVE | TD_CTRL_IOC |
  1476. (urb->transfer_flags & USB_DISABLE_SPD ? 0 : TD_CTRL_SPD) | (3 << 27);
  1478. destination = (urb->pipe & PIPE_DEVEP_MASK) | usb_packetid (urb->pipe) |
  1479. (((urb->transfer_buffer_length - 1) & 0x7ff) << 21);
  1482. info = destination | (usb_gettoggle (urb->dev, usb_pipeendpoint (pipe), usb_pipeout (pipe)) << TD_TOKEN_TOGGLE);
  1484. fill_td (td, status, info, urb_priv->transfer_buffer_dma);
  1485. list_add_tail (&td->desc_list, &urb_priv->desc_list);
  1487. queue_urb (s, urb);
  1489. insert_td_horizontal (s, s->int_chain[nint], td); // store in INT-TDs
  1491. usb_dotoggle (urb->dev, usb_pipeendpoint (pipe), usb_pipeout (pipe));
  1493. return 0;
  1494. }
  1495. /*-------------------------------------------------------------------*/
  1496. _static int uhci_submit_iso_urb (urb_t *urb)
  1497. {
  1498. uhci_t *s = (uhci_t*) urb->dev->bus->hcpriv;
  1499. urb_priv_t *urb_priv = urb->hcpriv;
  1500. #ifdef ISO_SANITY_CHECK
  1501. int pipe=urb->pipe;
  1502. int maxsze = usb_maxpacket (urb->dev, pipe, usb_pipeout (pipe));
  1503. #endif
  1504. int n, ret, last=0;
  1505. uhci_desc_t *td, **tdm;
  1506. int status, destination;
  1507. unsigned long flags;
  1509. __save_flags(flags);
  1510. __cli();       // Disable IRQs to schedule all ISO-TDs in time
  1511. ret = iso_find_start (urb); // adjusts urb->start_frame for later use
  1513. if (ret)
  1514. goto err;
  1516. tdm = (uhci_desc_t **) kmalloc (urb->number_of_packets * sizeof (uhci_desc_t*), KMALLOC_FLAG);
  1518. if (!tdm) {
  1519. ret = -ENOMEM;
  1520. goto err;
  1521. }
  1523. memset(tdm, 0, urb->number_of_packets * sizeof (uhci_desc_t*));
  1525. // First try to get all TDs. Cause: Removing already inserted TDs can only be done 
  1526. // racefree in three steps: unlink TDs, wait one frame, delete TDs. 
  1527. // So, this solutions seems simpler...
  1529. for (n = 0; n < urb->number_of_packets; n++) {
  1530. dbg("n:%d urb->iso_frame_desc[n].length:%d", n, urb->iso_frame_desc[n].length);
  1531. if (!urb->iso_frame_desc[n].length)
  1532. continue;  // allows ISO striping by setting length to zero in iso_descriptor
  1535. #ifdef ISO_SANITY_CHECK
  1536. if(urb->iso_frame_desc[n].length > maxsze) {
  1538. err("submit_iso: urb->iso_frame_desc[%d].length(%d)>%d",n , urb->iso_frame_desc[n].length, maxsze);
  1539. ret=-EINVAL;
  1540. }
  1541. else
  1542. #endif
  1543. if (alloc_td (s, &td, UHCI_PTR_DEPTH)) {
  1544. int i; // Cleanup allocated TDs
  1546. for (i = 0; i < n; n++)
  1547. if (tdm[i])
  1548.  delete_desc(s, tdm[i]);
  1549. kfree (tdm);
  1550. goto err;
  1551. }
  1552. last=n;
  1553. tdm[n] = td;
  1554. }
  1556. status = TD_CTRL_ACTIVE | TD_CTRL_IOS;
  1558. destination = (urb->pipe & PIPE_DEVEP_MASK) | usb_packetid (urb->pipe);
  1560. // Queue all allocated TDs
  1561. for (n = 0; n < urb->number_of_packets; n++) {
  1562. td = tdm[n];
  1563. if (!td)
  1564. continue;
  1566. if (n  == last) {
  1567. status |= TD_CTRL_IOC;
  1568. queue_urb (s, urb);
  1569. }
  1571. fill_td (td, status, destination | (((urb->iso_frame_desc[n].length - 1) & 0x7ff) << 21),
  1572.  urb_priv->transfer_buffer_dma + urb->iso_frame_desc[n].offset);
  1573. list_add_tail (&td->desc_list, &urb_priv->desc_list);
  1575. insert_td_horizontal (s, s->iso_td[(urb->start_frame + n) & 1023], td); // store in iso-tds
  1576. }
  1578. kfree (tdm);
  1579. dbg("ISO-INT# %i, start %i, now %i", urb->number_of_packets, urb->start_frame, UHCI_GET_CURRENT_FRAME (s) & 1023);
  1580. ret = 0;
  1582.       err:
  1583. __restore_flags(flags);
  1584. return ret;
  1585. }
  1586. /*-------------------------------------------------------------------*/
  1587. // returns: 0 (no transfer queued), urb* (this urb already queued)
  1588.  
  1589. _static urb_t* search_dev_ep (uhci_t *s, urb_t *urb)
  1590. {
  1591. struct list_head *p;
  1592. urb_t *tmp;
  1593. unsigned int mask = usb_pipecontrol(urb->pipe) ? (~USB_DIR_IN) : (~0);
  1595. dbg("search_dev_ep:");
  1597. p=s->urb_list.next;
  1599. for (; p != &s->urb_list; p = p->next) {
  1600. tmp = list_entry (p, urb_t, urb_list);
  1601. dbg("urb: %p", tmp);
  1602. // we can accept this urb if it is not queued at this time 
  1603. // or if non-iso transfer requests should be scheduled for the same device and pipe
  1604. if ((!usb_pipeisoc(urb->pipe) && (tmp->dev == urb->dev) && !((tmp->pipe ^ urb->pipe) & mask)) ||
  1605.     (urb == tmp)) {
  1606. return tmp; // found another urb already queued for processing
  1607. }
  1608. }
  1610. return 0;
  1611. }
  1612. /*-------------------------------------------------------------------*/
  1613. _static int uhci_submit_urb (urb_t *urb)
  1614. {
  1615. uhci_t *s;
  1616. urb_priv_t *urb_priv;
  1617. int ret = 0, type;
  1618. unsigned long flags;
  1619. urb_t *queued_urb=NULL;
  1620. int bustime;
  1622. if (!urb->dev || !urb->dev->bus)
  1623. return -ENODEV;
  1625. s = (uhci_t*) urb->dev->bus->hcpriv;
  1626. //dbg("submit_urb: %p type %d",urb,usb_pipetype(urb->pipe));
  1628. if (!s->running)
  1629. return -ENODEV;
  1631. type = usb_pipetype (urb->pipe);
  1633. if (usb_pipedevice (urb->pipe) == s->rh.devnum)
  1634. return rh_submit_urb (urb); /* virtual root hub */
  1636. // Sanity checks
  1637. if (usb_maxpacket (urb->dev, urb->pipe, usb_pipeout (urb->pipe)) <= 0) {
  1638. err("uhci_submit_urb: pipesize for pipe %x is zero", urb->pipe);
  1639. return -EMSGSIZE;
  1640. }
  1642. if (urb->transfer_buffer_length < 0 && type != PIPE_ISOCHRONOUS) {
  1643. err("uhci_submit_urb: Negative transfer length for urb %p", urb);
  1644. return -EINVAL;
  1645. }
  1647. usb_inc_dev_use (urb->dev);
  1649. spin_lock_irqsave (&s->urb_list_lock, flags);
  1651. queued_urb = search_dev_ep (s, urb); // returns already queued urb for that pipe
  1653. if (queued_urb) {
  1655. queue_dbg("found bulk urb %pn", queued_urb);
  1657. if (( type != PIPE_BULK) ||
  1658.     ((type == PIPE_BULK) &&
  1659.      (!(urb->transfer_flags & USB_QUEUE_BULK) || !(queued_urb->transfer_flags & USB_QUEUE_BULK)))) {
  1660. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  1661. usb_dec_dev_use (urb->dev);
  1662. err("ENXIO %08x, flags %x, urb %p, burb %p",urb->pipe,urb->transfer_flags,urb,queued_urb);
  1663. return -ENXIO; // urb already queued
  1664. }
  1665. }
  1667. #ifdef DEBUG_SLAB
  1668. urb_priv = kmem_cache_alloc(urb_priv_kmem, SLAB_FLAG);
  1669. #else
  1670. urb_priv = kmalloc (sizeof (urb_priv_t), KMALLOC_FLAG);
  1671. #endif
  1672. if (!urb_priv) {
  1673. usb_dec_dev_use (urb->dev);
  1674. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  1675. return -ENOMEM;
  1676. }
  1678. memset(urb_priv, 0, sizeof(urb_priv_t));
  1679. urb->hcpriv = urb_priv;
  1680. INIT_LIST_HEAD (&urb_priv->desc_list);
  1682. dbg("submit_urb: scheduling %p", urb);
  1684. if (type == PIPE_CONTROL)
  1685. urb_priv->setup_packet_dma = pci_map_single(s->uhci_pci, urb->setup_packet,
  1686.     sizeof(devrequest), PCI_DMA_TODEVICE);
  1688. if (urb->transfer_buffer_length)
  1689. urb_priv->transfer_buffer_dma = pci_map_single(s->uhci_pci,
  1690.        urb->transfer_buffer,
  1691.        urb->transfer_buffer_length,
  1692.        usb_pipein(urb->pipe) ?
  1693.        PCI_DMA_FROMDEVICE :
  1694.        PCI_DMA_TODEVICE);
  1696. if (type == PIPE_BULK) {
  1698. if (queued_urb) {
  1699. while (((urb_priv_t*)queued_urb->hcpriv)->next_queued_urb)  // find last queued bulk
  1700. queued_urb=((urb_priv_t*)queued_urb->hcpriv)->next_queued_urb;
  1702. ((urb_priv_t*)queued_urb->hcpriv)->next_queued_urb=urb;
  1703. }
  1704. atomic_inc (&s->avoid_bulk);
  1705. ret = uhci_submit_bulk_urb (urb, queued_urb);
  1706. atomic_dec (&s->avoid_bulk);
  1707. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  1708. }
  1709. else {
  1710. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  1711. switch (type) {
  1712. case PIPE_ISOCHRONOUS:
  1713. if (urb->bandwidth == 0) {      /* not yet checked/allocated */
  1714. if (urb->number_of_packets <= 0) {
  1715. ret = -EINVAL;
  1716. break;
  1717. }
  1719. bustime = usb_check_bandwidth (urb->dev, urb);
  1720. if (bustime < 0) 
  1721. ret = bustime;
  1722. else {
  1723. ret = uhci_submit_iso_urb(urb);
  1724. if (ret == 0)
  1725. usb_claim_bandwidth (urb->dev, urb, bustime, 1);
  1726. }
  1727. } else {        /* bandwidth is already set */
  1728. ret = uhci_submit_iso_urb(urb);
  1729. }
  1730. break;
  1731. case PIPE_INTERRUPT:
  1732. if (urb->bandwidth == 0) {      /* not yet checked/allocated */
  1733. bustime = usb_check_bandwidth (urb->dev, urb);
  1734. if (bustime < 0)
  1735. ret = bustime;
  1736. else {
  1737. ret = uhci_submit_int_urb(urb);
  1738. if (ret == 0)
  1739. usb_claim_bandwidth (urb->dev, urb, bustime, 0);
  1740. }
  1741. } else {        /* bandwidth is already set */
  1742. ret = uhci_submit_int_urb(urb);
  1743. }
  1744. break;
  1745. case PIPE_CONTROL:
  1746. ret = uhci_submit_control_urb (urb);
  1747. break;
  1748. default:
  1749. ret = -EINVAL;
  1750. }
  1751. }
  1753. dbg("submit_urb: scheduled with ret: %d", ret);
  1755. if (ret != 0) {
  1756. uhci_urb_dma_unmap(s, urb, urb_priv);
  1757. usb_dec_dev_use (urb->dev);
  1758. #ifdef DEBUG_SLAB
  1759. kmem_cache_free(urb_priv_kmem, urb_priv);
  1760. #else
  1761. kfree (urb_priv);
  1762. #endif
  1763. return ret;
  1764. }
  1766. return 0;
  1767. }
  1769. // Checks for URB timeout and removes bandwidth reclamation if URB idles too long
  1770. _static void uhci_check_timeouts(uhci_t *s)
  1771. {
  1772. struct list_head *p,*p2;
  1773. urb_t *urb;
  1774. int type;
  1776. p = s->urb_list.prev;
  1778. while (p != &s->urb_list) {
  1779. urb_priv_t *hcpriv;
  1781. p2 = p;
  1782. p = p->prev;
  1783. urb = list_entry (p2, urb_t, urb_list);
  1784. type = usb_pipetype (urb->pipe);
  1786. hcpriv = (urb_priv_t*)urb->hcpriv;
  1788. if ( urb->timeout && time_after(jiffies, hcpriv->started + urb->timeout)) {
  1789. urb->transfer_flags |= USB_TIMEOUT_KILLED | USB_ASYNC_UNLINK;
  1790. async_dbg("uhci_check_timeout: timeout for %p",urb);
  1791. uhci_unlink_urb_async(s, urb, UNLINK_ASYNC_STORE_URB);
  1792. }
  1793. #ifdef CONFIG_USB_UHCI_HIGH_BANDWIDTH
  1794. else if (((type == PIPE_BULK) || (type == PIPE_CONTROL)) &&  
  1795.  (hcpriv->use_loop) && time_after(jiffies, hcpriv->started + IDLE_TIMEOUT))
  1796. disable_desc_loop(s, urb);
  1797. #endif
  1799. }
  1800. s->timeout_check=jiffies;
  1801. }
  1803. /*-------------------------------------------------------------------
  1804.  Virtual Root Hub
  1805.  -------------------------------------------------------------------*/
  1807. _static __u8 root_hub_dev_des[] =
  1808. {
  1809. 0x12, /*  __u8  bLength; */
  1810. 0x01, /*  __u8  bDescriptorType; Device */
  1811. 0x00, /*  __u16 bcdUSB; v1.0 */
  1812. 0x01,
  1813. 0x09, /*  __u8  bDeviceClass; HUB_CLASSCODE */
  1814. 0x00, /*  __u8  bDeviceSubClass; */
  1815. 0x00, /*  __u8  bDeviceProtocol; */
  1816. 0x08, /*  __u8  bMaxPacketSize0; 8 Bytes */
  1817. 0x00, /*  __u16 idVendor; */
  1818. 0x00,
  1819. 0x00, /*  __u16 idProduct; */
  1820. 0x00,
  1821. 0x00, /*  __u16 bcdDevice; */
  1822. 0x00,
  1823. 0x00, /*  __u8  iManufacturer; */
  1824. 0x02, /*  __u8  iProduct; */
  1825. 0x01, /*  __u8  iSerialNumber; */
  1826. 0x01 /*  __u8  bNumConfigurations; */
  1827. };
  1830. /* Configuration descriptor */
  1831. _static __u8 root_hub_config_des[] =
  1832. {
  1833. 0x09, /*  __u8  bLength; */
  1834. 0x02, /*  __u8  bDescriptorType; Configuration */
  1835. 0x19, /*  __u16 wTotalLength; */
  1836. 0x00,
  1837. 0x01, /*  __u8  bNumInterfaces; */
  1838. 0x01, /*  __u8  bConfigurationValue; */
  1839. 0x00, /*  __u8  iConfiguration; */
  1840. 0x40, /*  __u8  bmAttributes; 
  1841.    Bit 7: Bus-powered, 6: Self-powered, 5 Remote-wakwup, 4..0: resvd */
  1842. 0x00, /*  __u8  MaxPower; */
  1844.      /* interface */
  1845. 0x09, /*  __u8  if_bLength; */
  1846. 0x04, /*  __u8  if_bDescriptorType; Interface */
  1847. 0x00, /*  __u8  if_bInterfaceNumber; */
  1848. 0x00, /*  __u8  if_bAlternateSetting; */
  1849. 0x01, /*  __u8  if_bNumEndpoints; */
  1850. 0x09, /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
  1851. 0x00, /*  __u8  if_bInterfaceSubClass; */
  1852. 0x00, /*  __u8  if_bInterfaceProtocol; */
  1853. 0x00, /*  __u8  if_iInterface; */
  1855.      /* endpoint */
  1856. 0x07, /*  __u8  ep_bLength; */
  1857. 0x05, /*  __u8  ep_bDescriptorType; Endpoint */
  1858. 0x81, /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
  1859. 0x03, /*  __u8  ep_bmAttributes; Interrupt */
  1860. 0x08, /*  __u16 ep_wMaxPacketSize; 8 Bytes */
  1861. 0x00,
  1862. 0xff /*  __u8  ep_bInterval; 255 ms */
  1863. };
  1866. _static __u8 root_hub_hub_des[] =
  1867. {
  1868. 0x09, /*  __u8  bLength; */
  1869. 0x29, /*  __u8  bDescriptorType; Hub-descriptor */
  1870. 0x02, /*  __u8  bNbrPorts; */
  1871. 0x00, /* __u16  wHubCharacteristics; */
  1872. 0x00,
  1873. 0x01, /*  __u8  bPwrOn2pwrGood; 2ms */
  1874. 0x00, /*  __u8  bHubContrCurrent; 0 mA */
  1875. 0x00, /*  __u8  DeviceRemovable; *** 7 Ports max *** */
  1876. 0xff /*  __u8  PortPwrCtrlMask; *** 7 ports max *** */
  1877. };
  1879. /*-------------------------------------------------------------------------*/
  1880. /* prepare Interrupt pipe transaction data; HUB INTERRUPT ENDPOINT */
  1881. _static int rh_send_irq (urb_t *urb)
  1882. {
  1883. int len = 1;
  1884. int i;
  1885. uhci_t *uhci = urb->dev->bus->hcpriv;
  1886. unsigned int io_addr = uhci->io_addr;
  1887. __u16 data = 0;
  1889. for (i = 0; i < uhci->rh.numports; i++) {
  1890. data |= ((inw (io_addr + USBPORTSC1 + i * 2) & 0xa) > 0 ? (1 << (i + 1)) : 0);
  1891. len = (i + 1) / 8 + 1;
  1892. }
  1894. *(__u16 *) urb->transfer_buffer = cpu_to_le16 (data);
  1895. urb->actual_length = len;
  1896. urb->status = 0;
  1898. if ((data > 0) && (uhci->rh.send != 0)) {
  1899. dbg("Root-Hub INT complete: port1: %x port2: %x data: %x",
  1900.      inw (io_addr + USBPORTSC1), inw (io_addr + USBPORTSC2), data);
  1901. urb->complete (urb);
  1902. }
  1903. return 0;
  1904. }
  1906. /*-------------------------------------------------------------------------*/
  1907. /* Virtual Root Hub INTs are polled by this timer every "intervall" ms */
  1908. _static int rh_init_int_timer (urb_t *urb);
  1910. _static void rh_int_timer_do (unsigned long ptr)
  1911. {
  1912. int len;
  1913. urb_t *urb = (urb_t*) ptr;
  1914. uhci_t *uhci = urb->dev->bus->hcpriv;
  1916. if (uhci->rh.send) {
  1917. len = rh_send_irq (urb);
  1918. if (len > 0) {
  1919. urb->actual_length = len;
  1920. if (urb->complete)
  1921. urb->complete (urb);
  1922. }
  1923. }
  1924. rh_init_int_timer (urb);
  1925. }
  1927. /*-------------------------------------------------------------------------*/
  1928. /* Root Hub INTs are polled by this timer, polling interval 20ms */
  1930. _static int rh_init_int_timer (urb_t *urb)
  1931. {
  1932. uhci_t *uhci = urb->dev->bus->hcpriv;
  1934. uhci->rh.interval = urb->interval;
  1935. init_timer (&uhci->rh.rh_int_timer);
  1936. uhci->rh.rh_int_timer.function = rh_int_timer_do;
  1937. uhci->rh.rh_int_timer.data = (unsigned long) urb;
  1938. uhci->rh.rh_int_timer.expires = jiffies + (HZ * 20) / 1000;
  1939. add_timer (&uhci->rh.rh_int_timer);
  1941. return 0;
  1942. }
  1944. /*-------------------------------------------------------------------------*/
  1945. #define OK(x)  len = (x); break
  1947. #define CLR_RH_PORTSTAT(x) 
  1948. status = inw(io_addr+USBPORTSC1+2*(wIndex-1)); 
  1949. status = (status & 0xfff5) & ~(x); 
  1950. outw(status, io_addr+USBPORTSC1+2*(wIndex-1))
  1952. #define SET_RH_PORTSTAT(x) 
  1953. status = inw(io_addr+USBPORTSC1+2*(wIndex-1)); 
  1954. status = (status & 0xfff5) | (x); 
  1955. outw(status, io_addr+USBPORTSC1+2*(wIndex-1))
  1958. /*-------------------------------------------------------------------------*/
  1959. /****
  1960.  ** Root Hub Control Pipe
  1961.  *************************/
  1964. _static int rh_submit_urb (urb_t *urb)
  1965. {
  1966. struct usb_device *usb_dev = urb->dev;
  1967. uhci_t *uhci = usb_dev->bus->hcpriv;
  1968. unsigned int pipe = urb->pipe;
  1969. devrequest *cmd = (devrequest *) urb->setup_packet;
  1970. void *data = urb->transfer_buffer;
  1971. int leni = urb->transfer_buffer_length;
  1972. int len = 0;
  1973. int status = 0;
  1974. int stat = 0;
  1975. int i;
  1976. unsigned int io_addr = uhci->io_addr;
  1977. __u16 cstatus;
  1979. __u16 bmRType_bReq;
  1980. __u16 wValue;
  1981. __u16 wIndex;
  1982. __u16 wLength;
  1984. if (usb_pipetype (pipe) == PIPE_INTERRUPT) {
  1985. dbg("Root-Hub submit IRQ: every %d ms", urb->interval);
  1986. uhci->rh.urb = urb;
  1987. uhci->rh.send = 1;
  1988. uhci->rh.interval = urb->interval;
  1989. rh_init_int_timer (urb);
  1991. return 0;
  1992. }
  1995. bmRType_bReq = cmd->requesttype | cmd->request << 8;
  1996. wValue = le16_to_cpu (cmd->value);
  1997. wIndex = le16_to_cpu (cmd->index);
  1998. wLength = le16_to_cpu (cmd->length);
  2000. for (i = 0; i < 8; i++)
  2001. uhci->rh.c_p_r[i] = 0;
  2003. dbg("Root-Hub: adr: %2x cmd(%1x): %04x %04x %04x %04x",
  2004.      uhci->rh.devnum, 8, bmRType_bReq, wValue, wIndex, wLength);
  2006. switch (bmRType_bReq) {
  2007. /* Request Destination:
  2008.    without flags: Device, 
  2009.    RH_INTERFACE: interface, 
  2010.    RH_ENDPOINT: endpoint,
  2011.    RH_CLASS means HUB here, 
  2012.    RH_OTHER | RH_CLASS  almost ever means HUB_PORT here 
  2013.  */
  2015. case RH_GET_STATUS:
  2016. *(__u16 *) data = cpu_to_le16 (1);
  2017. OK (2);
  2018. case RH_GET_STATUS | RH_INTERFACE:
  2019. *(__u16 *) data = cpu_to_le16 (0);
  2020. OK (2);
  2021. case RH_GET_STATUS | RH_ENDPOINT:
  2022. *(__u16 *) data = cpu_to_le16 (0);
  2023. OK (2);
  2024. case RH_GET_STATUS | RH_CLASS:
  2025. *(__u32 *) data = cpu_to_le32 (0);
  2026. OK (4); /* hub power ** */
  2027. case RH_GET_STATUS | RH_OTHER | RH_CLASS:
  2028. status = inw (io_addr + USBPORTSC1 + 2 * (wIndex - 1));
  2029. cstatus = ((status & USBPORTSC_CSC) >> (1 - 0)) |
  2030. ((status & USBPORTSC_PEC) >> (3 - 1)) |
  2031. (uhci->rh.c_p_r[wIndex - 1] << (0 + 4));
  2032. status = (status & USBPORTSC_CCS) |
  2033. ((status & USBPORTSC_PE) >> (2 - 1)) |
  2034. ((status & USBPORTSC_SUSP) >> (12 - 2)) |
  2035. ((status & USBPORTSC_PR) >> (9 - 4)) |
  2036. (1 << 8) | /* power on ** */
  2037. ((status & USBPORTSC_LSDA) << (-8 + 9));
  2039. *(__u16 *) data = cpu_to_le16 (status);
  2040. *(__u16 *) (data + 2) = cpu_to_le16 (cstatus);
  2041. OK (4);
  2043. case RH_CLEAR_FEATURE | RH_ENDPOINT:
  2044. switch (wValue) {
  2045. case (RH_ENDPOINT_STALL):
  2046. OK (0);
  2047. }
  2048. break;
  2050. case RH_CLEAR_FEATURE | RH_CLASS:
  2051. switch (wValue) {
  2052. case (RH_C_HUB_OVER_CURRENT):
  2053. OK (0); /* hub power over current ** */
  2054. }
  2055. break;
  2057. case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
  2058. switch (wValue) {
  2059. case (RH_PORT_ENABLE):
  2060. CLR_RH_PORTSTAT (USBPORTSC_PE);
  2061. OK (0);
  2062. case (RH_PORT_SUSPEND):
  2063. CLR_RH_PORTSTAT (USBPORTSC_SUSP);
  2064. OK (0);
  2065. case (RH_PORT_POWER):
  2066. OK (0); /* port power ** */
  2067. case (RH_C_PORT_CONNECTION):
  2068. SET_RH_PORTSTAT (USBPORTSC_CSC);
  2069. OK (0);
  2070. case (RH_C_PORT_ENABLE):
  2071. SET_RH_PORTSTAT (USBPORTSC_PEC);
  2072. OK (0);
  2073. case (RH_C_PORT_SUSPEND):
  2074. /*** WR_RH_PORTSTAT(RH_PS_PSSC); */
  2075. OK (0);
  2076. case (RH_C_PORT_OVER_CURRENT):
  2077. OK (0); /* port power over current ** */
  2078. case (RH_C_PORT_RESET):
  2079. uhci->rh.c_p_r[wIndex - 1] = 0;
  2080. OK (0);
  2081. }
  2082. break;
  2084. case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
  2085. switch (wValue) {
  2086. case (RH_PORT_SUSPEND):
  2087. SET_RH_PORTSTAT (USBPORTSC_SUSP);
  2088. OK (0);
  2089. case (RH_PORT_RESET):
  2090. SET_RH_PORTSTAT (USBPORTSC_PR);
  2091. uhci_wait_ms (10);
  2092. uhci->rh.c_p_r[wIndex - 1] = 1;
  2093. CLR_RH_PORTSTAT (USBPORTSC_PR);
  2094. udelay (10);
  2095. SET_RH_PORTSTAT (USBPORTSC_PE);
  2096. uhci_wait_ms (10);
  2097. SET_RH_PORTSTAT (0xa);
  2098. OK (0);
  2099. case (RH_PORT_POWER):
  2100. OK (0); /* port power ** */
  2101. case (RH_PORT_ENABLE):
  2102. SET_RH_PORTSTAT (USBPORTSC_PE);
  2103. OK (0);
  2104. }
  2105. break;
  2107. case RH_SET_ADDRESS:
  2108. uhci->rh.devnum = wValue;
  2109. OK (0);
  2111. case RH_GET_DESCRIPTOR:
  2112. switch ((wValue & 0xff00) >> 8) {
  2113. case (0x01): /* device descriptor */
  2114. len = min_t(unsigned int, leni,
  2115.   min_t(unsigned int,
  2116.       sizeof (root_hub_dev_des), wLength));
  2117. memcpy (data, root_hub_dev_des, len);
  2118. OK (len);
  2119. case (0x02): /* configuration descriptor */
  2120. len = min_t(unsigned int, leni,
  2121.   min_t(unsigned int,
  2122.       sizeof (root_hub_config_des), wLength));
  2123. memcpy (data, root_hub_config_des, len);
  2124. OK (len);
  2125. case (0x03): /* string descriptors */
  2126. len = usb_root_hub_string (wValue & 0xff,
  2127.         uhci->io_addr, "UHCI",
  2128. data, wLength);
  2129. if (len > 0) {
  2130. OK(min_t(int, leni, len));
  2131. } else 
  2132. stat = -EPIPE;
  2133. }
  2134. break;
  2136. case RH_GET_DESCRIPTOR | RH_CLASS:
  2137. root_hub_hub_des[2] = uhci->rh.numports;
  2138. len = min_t(unsigned int, leni,
  2139.   min_t(unsigned int, sizeof (root_hub_hub_des), wLength));
  2140. memcpy (data, root_hub_hub_des, len);
  2141. OK (len);
  2143. case RH_GET_CONFIGURATION:
  2144. *(__u8 *) data = 0x01;
  2145. OK (1);
  2147. case RH_SET_CONFIGURATION:
  2148. OK (0);
  2149. default:
  2150. stat = -EPIPE;
  2151. }
  2153. dbg("Root-Hub stat port1: %x port2: %x",
  2154.      inw (io_addr + USBPORTSC1), inw (io_addr + USBPORTSC2));
  2156. urb->actual_length = len;
  2157. urb->status = stat;
  2158. urb->dev=NULL;
  2159. if (urb->complete)
  2160. urb->complete (urb);
  2161. return 0;
  2162. }
  2163. /*-------------------------------------------------------------------------*/
  2165. _static int rh_unlink_urb (urb_t *urb)
  2166. {
  2167. uhci_t *uhci = urb->dev->bus->hcpriv;
  2169. if (uhci->rh.urb==urb) {
  2170. dbg("Root-Hub unlink IRQ");
  2171. uhci->rh.send = 0;
  2172. del_timer (&uhci->rh.rh_int_timer);
  2173. }
  2174. return 0;
  2175. }
  2176. /*-------------------------------------------------------------------*/
  2178. /*
  2179.  * Map status to standard result codes
  2180.  *
  2181.  * <status> is (td->status & 0xFE0000) [a.k.a. uhci_status_bits(td->status)
  2182.  * <dir_out> is True for output TDs and False for input TDs.
  2183.  */
  2184. _static int uhci_map_status (int status, int dir_out)
  2185. {
  2186. if (!status)
  2187. return 0;
  2188. if (status & TD_CTRL_BITSTUFF) /* Bitstuff error */
  2189. return -EPROTO;
  2190. if (status & TD_CTRL_CRCTIMEO) { /* CRC/Timeout */
  2191. if (dir_out)
  2192. return -ETIMEDOUT;
  2193. else
  2194. return -EILSEQ;
  2195. }
  2196. if (status & TD_CTRL_NAK) /* NAK */
  2197. return -ETIMEDOUT;
  2198. if (status & TD_CTRL_BABBLE) /* Babble */
  2199. return -EOVERFLOW;
  2200. if (status & TD_CTRL_DBUFERR) /* Buffer error */
  2201. return -ENOSR;
  2202. if (status & TD_CTRL_STALLED) /* Stalled */
  2203. return -EPIPE;
  2204. if (status & TD_CTRL_ACTIVE) /* Active */
  2205. return 0;
  2207. return -EPROTO;
  2208. }
  2210. /*
  2211.  * Only the USB core should call uhci_alloc_dev and uhci_free_dev
  2212.  */
  2213. _static int uhci_alloc_dev (struct usb_device *usb_dev)
  2214. {
  2215. return 0;
  2216. }
  2218. _static void uhci_unlink_urbs(uhci_t *s, struct usb_device *usb_dev, int remove_all)
  2219. {
  2220. unsigned long flags;
  2221. struct list_head *p;
  2222. struct list_head *p2;
  2223. urb_t *urb;
  2225. spin_lock_irqsave (&s->urb_list_lock, flags);
  2226. p = s->urb_list.prev;
  2227. while (p != &s->urb_list) {
  2228. p2 = p;
  2229. p = p->prev ;
  2230. urb = list_entry (p2, urb_t, urb_list);
  2231. dbg("urb: %p, dev %p, %p", urb, usb_dev,urb->dev);
  2233. //urb->transfer_flags |=USB_ASYNC_UNLINK; 
  2235. if (remove_all || (usb_dev == urb->dev)) {
  2236. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  2237. warn("forced removing of queued URB %p due to disconnect",urb);
  2238. uhci_unlink_urb(urb);
  2239. urb->dev = NULL; // avoid further processing of this URB
  2240. spin_lock_irqsave (&s->urb_list_lock, flags);
  2241. p = s->urb_list.prev;
  2242. }
  2243. }
  2244. spin_unlock_irqrestore (&s->urb_list_lock, flags);
  2245. }
  2247. _static int uhci_free_dev (struct usb_device *usb_dev)
  2248. {
  2249. uhci_t *s;
  2252. if(!usb_dev || !usb_dev->bus || !usb_dev->bus->hcpriv)
  2253. return -EINVAL;
  2255. s=(uhci_t*) usb_dev->bus->hcpriv;
  2256. uhci_unlink_urbs(s, usb_dev, 0);
  2258. return 0;
  2259. }
  2261. /*
  2262.  * uhci_get_current_frame_number()
  2263.  *
  2264.  * returns the current frame number for a USB bus/controller.
  2265.  */
  2266. _static int uhci_get_current_frame_number (struct usb_device *usb_dev)
  2267. {
  2268. return UHCI_GET_CURRENT_FRAME ((uhci_t*) usb_dev->bus->hcpriv);
  2269. }
  2271. struct usb_operations uhci_device_operations =
  2272. {
  2273. uhci_alloc_dev,
  2274. uhci_free_dev,
  2275. uhci_get_current_frame_number,
  2276. uhci_submit_urb,
  2277. uhci_unlink_urb
  2278. };
  2280. _static void correct_data_toggles(urb_t *urb)
  2281. {
  2282. usb_settoggle (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe), 
  2283.        !usb_gettoggle (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe)));
  2285. while(urb) {
  2286. urb_priv_t *priv=urb->hcpriv;
  2287. uhci_desc_t *qh = list_entry (priv->desc_list.next, uhci_desc_t, desc_list);
  2288. struct list_head *p = qh->vertical.next;
  2289. uhci_desc_t *td;
  2290. dbg("URB to correct %pn", urb);
  2292. for (; p != &qh->vertical; p = p->next) {
  2293. td = list_entry (p, uhci_desc_t, vertical);
  2294. td->hw.td.info^=cpu_to_le32(1<<TD_TOKEN_TOGGLE);
  2295. }
  2296. urb=priv->next_queued_urb;
  2297. }
  2298. }
  2300. /* 
  2301.  * For IN-control transfers, process_transfer gets a bit more complicated,
  2302.  * since there are devices that return less data (eg. strings) than they
  2303.  * have announced. This leads to a queue abort due to the short packet,
  2304.  * the status stage is not executed. If this happens, the status stage
  2305.  * is manually re-executed.
  2306.  * mode: PROCESS_TRANSFER_REGULAR: regular (unlink QH)
  2307.  *       PROCESS_TRANSFER_DONT_UNLINK: QHs already unlinked (for async unlink_urb)
  2308.  */
  2310. _static int process_transfer (uhci_t *s, urb_t *urb, int mode)
  2311. {
  2312. int ret = 0;
  2313. urb_priv_t *urb_priv = urb->hcpriv;
  2314. struct list_head *qhl = urb_priv->desc_list.next;
  2315. uhci_desc_t *qh = list_entry (qhl, uhci_desc_t, desc_list);
  2316. struct list_head *p = qh->vertical.next;
  2317. uhci_desc_t *desc= list_entry (urb_priv->desc_list.prev, uhci_desc_t, desc_list);
  2318. uhci_desc_t *last_desc = list_entry (desc->vertical.prev, uhci_desc_t, vertical);
  2319. int data_toggle = usb_gettoggle (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe)); // save initial data_toggle
  2320. int maxlength;  // extracted and remapped info from TD
  2321. int actual_length;
  2322. int status = 0;
  2324. //dbg("process_transfer: urb %p, urb_priv %p, qh %p last_desc %pn",urb,urb_priv, qh, last_desc);
  2326. /* if the status phase has been retriggered and the
  2327.    queue is empty or the last status-TD is inactive, the retriggered
  2328.    status stage is completed
  2329.  */
  2331. if (urb_priv->flags && 
  2332.     ((qh->hw.qh.element == cpu_to_le32(UHCI_PTR_TERM)) || !is_td_active(desc)))
  2333. goto transfer_finished;
  2335. urb->actual_length=0;
  2337. for (; p != &qh->vertical; p = p->next) {
  2338. desc = list_entry (p, uhci_desc_t, vertical);
  2340. if (is_td_active(desc)) { // do not process active TDs
  2341. if (mode == CLEAN_TRANSFER_DELETION_MARK) // if called from async_unlink
  2342. uhci_clean_transfer(s, urb, qh, CLEAN_TRANSFER_DELETION_MARK);
  2343. return ret;
  2344. }
  2346. actual_length = uhci_actual_length(le32_to_cpu(desc->hw.td.status)); // extract transfer parameters from TD
  2347. maxlength = (((le32_to_cpu(desc->hw.td.info) >> 21) & 0x7ff) + 1) & 0x7ff;
  2348. status = uhci_map_status (uhci_status_bits (le32_to_cpu(desc->hw.td.status)), usb_pipeout (urb->pipe));
  2350. if (status == -EPIPE) {  // see if EP is stalled
  2351. // set up stalled condition
  2352. usb_endpoint_halt (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe));
  2353. }
  2355. if (status && (status != -EPIPE)) { // if any error occurred stop processing of further TDs
  2356. // only set ret if status returned an error
  2357.   is_error:
  2358. ret = status;
  2359. urb->error_count++;
  2360. break;
  2361. }
  2362. else if ((le32_to_cpu(desc->hw.td.info) & 0xff) != USB_PID_SETUP)
  2363. urb->actual_length += actual_length;
  2365. // got less data than requested
  2366. if ( (actual_length < maxlength)) {
  2367. if (urb->transfer_flags & USB_DISABLE_SPD) {
  2368. status = -EREMOTEIO; // treat as real error
  2369. dbg("process_transfer: SPD!!");
  2370. break; // exit after this TD because SP was detected
  2371. }
  2373. // short read during control-IN: re-start status stage
  2374. if ((usb_pipetype (urb->pipe) == PIPE_CONTROL)) {
  2375. if (uhci_packetid(le32_to_cpu(last_desc->hw.td.info)) == USB_PID_OUT) {
  2377. set_qh_element(qh, last_desc->dma_addr);  // re-trigger status stage
  2378. dbg("short packet during control transfer, retrigger status stage @ %p",last_desc);
  2379. urb_priv->flags = 1; // mark as short control packet
  2380. return 0;
  2381. }
  2382. }
  2383. // all other cases: short read is OK
  2384. data_toggle = uhci_toggle (le32_to_cpu(desc->hw.td.info));
  2385. break;
  2386. }
  2387. else if (status)
  2388. goto is_error;
  2390. data_toggle = uhci_toggle (le32_to_cpu(desc->hw.td.info));
  2391. queue_dbg("process_transfer: len:%d status:%x mapped:%x toggle:%d", actual_length, le32_to_cpu(desc->hw.td.status),status, data_toggle);      
  2393. }
  2395. if (usb_pipetype (urb->pipe) == PIPE_BULK ) {  /* toggle correction for short bulk transfers (nonqueued/queued) */
  2397. urb_priv_t *priv=(urb_priv_t*)urb->hcpriv;
  2398. urb_t *next_queued_urb=priv->next_queued_urb;
  2400. if (next_queued_urb) {
  2401. urb_priv_t *next_priv=(urb_priv_t*)next_queued_urb->hcpriv;
  2402. uhci_desc_t *qh = list_entry (next_priv->desc_list.next, uhci_desc_t, desc_list);
  2403. uhci_desc_t *first_td=list_entry (qh->vertical.next, uhci_desc_t, vertical);
  2405. if (data_toggle == uhci_toggle (le32_to_cpu(first_td->hw.td.info))) {
  2406. err("process_transfer: fixed toggle");
  2407. correct_data_toggles(next_queued_urb);
  2408. }
  2409. }
  2410. else
  2411. usb_settoggle (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe), !data_toggle);
  2412. }
  2414.  transfer_finished:
  2416. uhci_clean_transfer(s, urb, qh, mode);
  2418. urb->status = status;
  2420. #ifdef CONFIG_USB_UHCI_HIGH_BANDWIDTH
  2421. disable_desc_loop(s,urb);
  2422. #endif
  2424. queue_dbg("process_transfer: (end) urb %p, wanted len %d, len %d status %x err %d",
  2425. urb,urb->transfer_buffer_length,urb->actual_length, urb->status, urb->error_count);
  2426. return ret;
  2427. }
  2429. _static int process_interrupt (uhci_t *s, urb_t *urb)
  2430. {
  2431. int i, ret = -EINPROGRESS;
  2432. urb_priv_t *urb_priv = urb->hcpriv;
  2433. struct list_head *p = urb_priv->desc_list.next;
  2434. uhci_desc_t *desc = list_entry (urb_priv->desc_list.prev, uhci_desc_t, desc_list);
  2436. int actual_length;
  2437. int status = 0;
  2439. //dbg("urb contains interrupt request");
  2441. for (i = 0; p != &urb_priv->desc_list; p = p->next, i++) // Maybe we allow more than one TD later ;-)
  2442. {
  2443. desc = list_entry (p, uhci_desc_t, desc_list);
  2445. if (is_td_active(desc)) {
  2446. // do not process active TDs
  2447. //dbg("TD ACT Status @%p %08x",desc,le32_to_cpu(desc->hw.td.status));
  2448. break;
  2449. }
  2451. if (!(desc->hw.td.status & cpu_to_le32(TD_CTRL_IOC))) {
  2452. // do not process one-shot TDs, no recycling
  2453. break;
  2454. }
  2455. // extract transfer parameters from TD
  2457. actual_length = uhci_actual_length(le32_to_cpu(desc->hw.td.status));
  2458. status = uhci_map_status (uhci_status_bits (le32_to_cpu(desc->hw.td.status)), usb_pipeout (urb->pipe));
  2460. // see if EP is stalled
  2461. if (status == -EPIPE) {
  2462. // set up stalled condition
  2463. usb_endpoint_halt (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe));
  2464. }
  2466. // if any error occurred: ignore this td, and continue
  2467. if (status != 0) {
  2468. //uhci_show_td (desc);
  2469. urb->error_count++;
  2470. goto recycle;
  2471. }
  2472. else
  2473. urb->actual_length = actual_length;
  2475. recycle:
  2476. uhci_urb_dma_sync(s, urb, urb->hcpriv);
  2477. if (urb->complete) {
  2478. //dbg("process_interrupt: calling completion, status %i",status);
  2479. urb->status = status;
  2480. ((urb_priv_t*)urb->hcpriv)->flags=1; // if unlink_urb is called during completion
  2482. spin_unlock(&s->urb_list_lock);
  2484. urb->complete ((struct urb *) urb);
  2486. spin_lock(&s->urb_list_lock);
  2488. ((urb_priv_t*)urb->hcpriv)->flags=0;        
  2489. }
  2491. if ((urb->status != -ECONNABORTED) && (urb->status != ECONNRESET) &&
  2492.     (urb->status != -ENOENT)) {
  2494. urb->status = -EINPROGRESS;
  2496. // Recycle INT-TD if interval!=0, else mark TD as one-shot
  2497. if (urb->interval) {
  2499. desc->hw.td.info &= cpu_to_le32(~(1 << TD_TOKEN_TOGGLE));
  2500. if (status==0) {
  2501. ((urb_priv_t*)urb->hcpriv)->started=jiffies;
  2502. desc->hw.td.info |= cpu_to_le32((usb_gettoggle (urb->dev, usb_pipeendpoint (urb->pipe),
  2503.     usb_pipeout (urb->pipe)) << TD_TOKEN_TOGGLE));
  2504. usb_dotoggle (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe));
  2505. } else {
  2506. desc->hw.td.info |= cpu_to_le32((!usb_gettoggle (urb->dev, usb_pipeendpoint (urb->pipe),
  2507.      usb_pipeout (urb->pipe)) << TD_TOKEN_TOGGLE));
  2508. }
  2509. desc->hw.td.status= cpu_to_le32((urb->pipe & TD_CTRL_LS) | TD_CTRL_ACTIVE | TD_CTRL_IOC |
  2510. (urb->transfer_flags & USB_DISABLE_SPD ? 0 : TD_CTRL_SPD) | (3 << 27));
  2511. mb();
  2512. }
  2513. else {
  2514. uhci_unlink_urb_async(s, urb, UNLINK_ASYNC_STORE_URB);
  2515. // correct toggle after unlink
  2516. usb_dotoggle (urb->dev, usb_pipeendpoint (urb->pipe), usb_pipeout (urb->pipe));
  2517. clr_td_ioc(desc); // inactivate TD
  2518. }
  2519. }
  2520. }
  2522. return ret;
  2523. }
  2525. // mode: PROCESS_ISO_REGULAR: processing only for done TDs, unlink TDs
  2526. // mode: PROCESS_ISO_FORCE: force processing, don't unlink TDs (already unlinked)
  2528. _static int process_iso (uhci_t *s, urb_t *urb, int mode)
  2529. {
  2530. int i;
  2531. int ret = 0;
  2532. urb_priv_t *urb_priv = urb->hcpriv;
  2533. struct list_head *p = urb_priv->desc_list.next, *p_tmp;
  2534. uhci_desc_t *desc = list_entry (urb_priv->desc_list.prev, uhci_desc_t, desc_list);
  2536. dbg("urb contains iso request");
  2537. if (is_td_active(desc) && mode==PROCESS_ISO_REGULAR)
  2538. return -EXDEV; // last TD not finished
  2540. urb->error_count = 0;
  2541. urb->actual_length = 0;
  2542. urb->status = 0;
  2543. dbg("process iso urb %p, %li, %i, %i, %i %08x",urb,jiffies,UHCI_GET_CURRENT_FRAME(s),
  2544.     urb->number_of_packets,mode,le32_to_cpu(desc->hw.td.status));
  2546. for (i = 0; p != &urb_priv->desc_list;  i++) {
  2547. desc = list_entry (p, uhci_desc_t, desc_list);
  2549. //uhci_show_td(desc);
  2550. if (is_td_active(desc)) {
  2551. // means we have completed the last TD, but not the TDs before
  2552. desc->hw.td.status &= cpu_to_le32(~TD_CTRL_ACTIVE);
  2553. dbg("TD still active (%x)- grrr. paranoia!", le32_to_cpu(desc->hw.td.status));
  2554. ret = -EXDEV;
  2555. urb->iso_frame_desc[i].status = ret;
  2556. unlink_td (s, desc, 1);
  2557. // FIXME: immediate deletion may be dangerous
  2558. goto err;
  2559. }
  2561. if (mode == PROCESS_ISO_REGULAR)
  2562. unlink_td (s, desc, 1);
  2564. if (urb->number_of_packets <= i) {
  2565. dbg("urb->number_of_packets (%d)<=(%d)", urb->number_of_packets, i);
  2566. ret = -EINVAL;
  2567. goto err;
  2568. }
  2570. urb->iso_frame_desc[i].actual_length = uhci_actual_length(le32_to_cpu(desc->hw.td.status));
  2571. urb->iso_frame_desc[i].status = uhci_map_status (uhci_status_bits (le32_to_cpu(desc->hw.td.status)), usb_pipeout (urb->pipe));
  2572. urb->actual_length += urb->iso_frame_desc[i].actual_length;
  2574.       err:
  2576. if (urb->iso_frame_desc[i].status != 0) {
  2577. urb->error_count++;
  2578. urb->status = urb->iso_frame_desc[i].status;
  2579. }
  2580. dbg("process_iso: %i: len:%d %08x status:%x",
  2581.      i, urb->iso_frame_desc[i].actual_length, le32_to_cpu(desc->hw.td.status),urb->iso_frame_desc[i].status);
  2583. p_tmp = p;
  2584. p = p->next;
  2585. list_del (p_tmp);
  2586. delete_desc (s, desc);
  2587. }
  2589. dbg("process_iso: exit %i (%d), actual_len %i", i, ret,urb->actual_length);
  2590. return ret;
  2591. }
  2594. _static int process_urb (uhci_t *s, struct list_head *p)
  2595. {
  2596. int ret = 0;
  2597. urb_t *urb;
  2599. urb=list_entry (p, urb_t, urb_list);
  2600. //dbg("process_urb: found queued urb: %p", urb);
  2602. switch (usb_pipetype (urb->pipe)) {
  2603. case PIPE_CONTROL:
  2604. ret = process_transfer (s, urb, CLEAN_TRANSFER_REGULAR);
  2605. break;
  2606. case PIPE_BULK:
  2607. if (!s->avoid_bulk.counter)
  2608. ret = process_transfer (s, urb, CLEAN_TRANSFER_REGULAR);
  2609. else
  2610. return 0;
  2611. break;
  2612. case PIPE_ISOCHRONOUS:
  2613. ret = process_iso (s, urb, PROCESS_ISO_REGULAR);
  2614. break;
  2615. case PIPE_INTERRUPT:
  2616. ret = process_interrupt (s, urb);
  2617. break;
  2618. }
  2620. if (urb->status != -EINPROGRESS) {
  2621. urb_priv_t *urb_priv;
  2622. struct usb_device *usb_dev;
  2624. usb_dev=urb->dev;
  2626. /* Release bandwidth for Interrupt or Iso transfers */
  2627. if (urb->bandwidth) {
  2628. if (usb_pipetype(urb->pipe)==PIPE_ISOCHRONOUS)
  2629. usb_release_bandwidth (urb->dev, urb, 1);
  2630. else if (usb_pipetype(urb->pipe)==PIPE_INTERRUPT && urb->interval)
  2631. usb_release_bandwidth (urb->dev, urb, 0);
  2632. }
  2634. dbg("dequeued urb: %p", urb);
  2635. dequeue_urb (s, urb);
  2637. urb_priv = urb->hcpriv;
  2639. uhci_urb_dma_unmap(s, urb, urb_priv);
  2641. #ifdef DEBUG_SLAB
  2642. kmem_cache_free(urb_priv_kmem, urb_priv);
  2643. #else
  2644. kfree (urb_priv);
  2645. #endif
  2647. if ((usb_pipetype (urb->pipe) != PIPE_INTERRUPT)) {  // process_interrupt does completion on its own
  2648. urb_t *next_urb = urb->next;
  2649. int is_ring = 0;
  2650. int contains_killed = 0;
  2651. int loop_count=0;
  2653. if (next_urb) {
  2654. // Find out if the URBs are linked to a ring
  2655. while  (next_urb != NULL && next_urb != urb && loop_count < MAX_NEXT_COUNT) {
  2656. if (next_urb->status == -ENOENT) {// killed URBs break ring structure & resubmission
  2657. contains_killed = 1;
  2658. break;
  2659. }
  2660. next_urb = next_urb->next;
  2661. loop_count++;
  2662. }
  2664. if (loop_count == MAX_NEXT_COUNT)
  2665. err("process_urb: Too much linked URBs in ring detection!");
  2667. if (next_urb == urb)
  2668. is_ring=1;
  2669. }
  2671. // Submit idle/non-killed URBs linked with urb->next
  2672. // Stop before the current URB
  2674. next_urb = urb->next;
  2675. if (next_urb && !contains_killed) {
  2676. int ret_submit;
  2677. next_urb = urb->next;
  2679. loop_count=0;
  2680. while (next_urb != NULL && next_urb != urb && loop_count < MAX_NEXT_COUNT) {
  2681. if (next_urb->status != -EINPROGRESS) {
  2683. if (next_urb->status == -ENOENT) 
  2684. break;
  2686. spin_unlock(&s->urb_list_lock);
  2688. ret_submit=uhci_submit_urb(next_urb);
  2689. spin_lock(&s->urb_list_lock);
  2691. if (ret_submit)
  2692. break;
  2693. }
  2694. loop_count++;
  2695. next_urb = next_urb->next;
  2696. }
  2697. if (loop_count == MAX_NEXT_COUNT)
  2698. err("process_urb: Too much linked URBs in resubmission!");
  2699. }
  2701. // Completion
  2702. if (urb->complete) {
  2703. int was_unlinked = (urb->status == -ENOENT);
  2704. urb->dev = NULL;
  2705. spin_unlock(&s->urb_list_lock);
  2707. urb->complete ((struct urb *) urb);
  2709. // Re-submit the URB if ring-linked
  2710. if (is_ring && !was_unlinked && !contains_killed) {
  2711. urb->dev=usb_dev;
  2712. uhci_submit_urb (urb);
  2713. }
  2714. spin_lock(&s->urb_list_lock);
  2715. }
  2717. usb_dec_dev_use (usb_dev);
  2718. }
  2719. }
  2721. return ret;
  2722. }
  2724. _static void uhci_interrupt (int irq, void *__uhci, struct pt_regs *regs)
  2725. {
  2726. uhci_t *s = __uhci;
  2727. unsigned int io_addr = s->io_addr;
  2728. unsigned short status;
  2729. struct list_head *p, *p2;
  2730. int restarts, work_done;
  2732. /*
  2733.  * Read the interrupt status, and write it back to clear the
  2734.  * interrupt cause
  2735.  */
  2737. status = inw (io_addr + USBSTS);
  2739. if (!status) /* shared interrupt, not mine */
  2740. return;
  2742. dbg("interrupt");
  2744. if (status != 1) {
  2745. // Avoid too much error messages at a time
  2746. if (time_after(jiffies, s->last_error_time + ERROR_SUPPRESSION_TIME)) {
  2747. warn("interrupt, status %x, frame# %i", status, 
  2748.      UHCI_GET_CURRENT_FRAME(s));
  2749. s->last_error_time = jiffies;
  2750. }
  2752. // remove host controller halted state
  2753. if ((status&0x20) && (s->running)) {
  2754. err("Host controller halted, trying to restart.");
  2755. outw (USBCMD_RS | inw(io_addr + USBCMD), io_addr + USBCMD);
  2756. }
  2757. //uhci_show_status (s);
  2758. }
  2759. /*
  2760.  * traverse the list in *reverse* direction, because new entries
  2761.  * may be added at the end.
  2762.  * also, because process_urb may unlink the current urb,
  2763.  * we need to advance the list before
  2764.  * New: check for max. workload and restart count
  2765.  */
  2767. spin_lock (&s->urb_list_lock);
  2769. restarts=0;
  2770. work_done=0;
  2772. restart:
  2773. s->unlink_urb_done=0;
  2774. p = s->urb_list.prev;
  2776. while (p != &s->urb_list && (work_done < 1024)) {
  2777. p2 = p;
  2778. p = p->prev;
  2780. process_urb (s, p2);
  2782. work_done++;
  2784. if (s->unlink_urb_done) {
  2785. s->unlink_urb_done=0;
  2786. restarts++;
  2788. if (restarts<16) // avoid endless restarts
  2789. goto restart;
  2790. else 
  2791. break;
  2792. }
  2793. }
  2794. if (time_after(jiffies, s->timeout_check + (HZ/30)))
  2795. uhci_check_timeouts(s);
  2797. clean_descs(s, CLEAN_NOT_FORCED);
  2798. uhci_cleanup_unlink(s, CLEAN_NOT_FORCED);
  2799. uhci_switch_timer_int(s);
  2801. spin_unlock (&s->urb_list_lock);
  2803. outw (status, io_addr + USBSTS);
  2805. //dbg("uhci_interrupt: done");
  2806. }
  2808. _static void reset_hc (uhci_t *s)
  2809. {
  2810. unsigned int io_addr = s->io_addr;
  2812. s->apm_state = 0;
  2813. /* Global reset for 50ms */
  2814. outw (USBCMD_GRESET, io_addr + USBCMD);
  2815. uhci_wait_ms (50);
  2816. outw (0, io_addr + USBCMD);
  2817. uhci_wait_ms (10);
  2818. }
  2820. _static void start_hc (uhci_t *s)
  2821. {
  2822. unsigned int io_addr = s->io_addr;
  2823. int timeout = 10;
  2825. /*
  2826.  * Reset the HC - this will force us to get a
  2827.  * new notification of any already connected
  2828.  * ports due to the virtual disconnect that it
  2829.  * implies.
  2830.  */
  2831. outw (USBCMD_HCRESET, io_addr + USBCMD);
  2833. while (inw (io_addr + USBCMD) & USBCMD_HCRESET) {
  2834. if (!--timeout) {
  2835. err("USBCMD_HCRESET timed out!");
  2836. break;
  2837. }
  2838. udelay(1);
  2839. }
  2841. /* Turn on all interrupts */
  2842. outw (USBINTR_TIMEOUT | USBINTR_RESUME | USBINTR_IOC | USBINTR_SP, io_addr + USBINTR);
  2844. /* Start at frame 0 */
  2845. outw (0, io_addr + USBFRNUM);
  2846. outl (s->framelist_dma, io_addr + USBFLBASEADD);
  2848. /* Run and mark it configured with a 64-byte max packet */
  2849. outw (USBCMD_RS | USBCMD_CF | USBCMD_MAXP, io_addr + USBCMD);
  2850. s->apm_state = 1;
  2851. s->running = 1;
  2852. }
  2854. /* No  __devexit, since it maybe called from alloc_uhci() */
  2855. _static void
  2856. uhci_pci_remove (struct pci_dev *dev)
  2857. {
  2858. uhci_t *s = pci_get_drvdata(dev);
  2859. struct usb_device *root_hub = s->bus->root_hub;
  2861. s->running = 0;     // Don't allow submit_urb
  2863. if (root_hub)
  2864. usb_disconnect (&root_hub);
  2866. reset_hc (s);
  2867. wait_ms (1);
  2869. uhci_unlink_urbs (s, 0, CLEAN_FORCED);  // Forced unlink of remaining URBs
  2870. uhci_cleanup_unlink (s, CLEAN_FORCED);  // force cleanup of async killed URBs
  2872. usb_deregister_bus (s->bus);
  2874. release_region (s->io_addr, s->io_size);
  2875. free_irq (s->irq, s);
  2876. usb_free_bus (s->bus);
  2877. cleanup_skel (s);
  2878. kfree (s);
  2879. }
  2881. _static int __init uhci_start_usb (uhci_t *s)
  2882. { /* start it up */
  2883. /* connect the virtual root hub */
  2884. struct usb_device *usb_dev;
  2886. usb_dev = usb_alloc_dev (NULL, s->bus);
  2887. if (!usb_dev)
  2888. return -1;
  2890. s->bus->root_hub = usb_dev;
  2891. usb_connect (usb_dev);
  2893. if (usb_new_device (usb_dev) != 0) {
  2894. usb_free_dev (usb_dev);
  2895. return -1;
  2896. }
  2898. return 0;
  2899. }
  2901. #ifdef CONFIG_PM
  2902. _static int
  2903. uhci_pci_suspend (struct pci_dev *dev, u32 state)
  2904. {
  2905. reset_hc((uhci_t *) pci_get_drvdata(dev));
  2906. return 0;
  2907. }
  2909. _static int
  2910. uhci_pci_resume (struct pci_dev *dev)
  2911. {
  2912. start_hc((uhci_t *) pci_get_drvdata(dev));
  2913. return 0;
  2914. }
  2915. #endif
  2917. _static int __devinit alloc_uhci (struct pci_dev *dev, int irq, unsigned int io_addr, unsigned int io_size)
  2918. {
  2919. uhci_t *s;
  2920. struct usb_bus *bus;
  2921. char buf[8], *bufp = buf;
  2923. #ifndef __sparc__
  2924. sprintf(buf, "%d", irq);
  2925. #else
  2926. bufp = __irq_itoa(irq);
  2927. #endif
  2928. printk(KERN_INFO __FILE__ ": USB UHCI at I/O 0x%x, IRQ %sn",
  2929. io_addr, bufp);
  2931. s = kmalloc (sizeof (uhci_t), GFP_KERNEL);
  2932. if (!s)
  2933. return -1;
  2935. memset (s, 0, sizeof (uhci_t));
  2936. INIT_LIST_HEAD (&s->free_desc);
  2937. INIT_LIST_HEAD (&s->urb_list);
  2938. INIT_LIST_HEAD (&s->urb_unlinked);
  2939. spin_lock_init (&s->urb_list_lock);
  2940. spin_lock_init (&s->qh_lock);
  2941. spin_lock_init (&s->td_lock);
  2942. atomic_set(&s->avoid_bulk, 0);
  2943. s->irq = -1;
  2944. s->io_addr = io_addr;
  2945. s->io_size = io_size;
  2946. s->uhci_pci=dev;
  2948. bus = usb_alloc_bus (&uhci_device_operations);
  2949. if (!bus) {
  2950. kfree (s);
  2951. return -1;
  2952. }
  2954. s->bus = bus;
  2955. bus->hcpriv = s;
  2957. /* UHCI specs says devices must have 2 ports, but goes on to say */
  2958. /* they may have more but give no way to determine how many they */
  2959. /* have, so default to 2 */
  2960. /* According to the UHCI spec, Bit 7 is always set to 1. So we try */
  2961. /* to use this to our advantage */
  2963. for (s->maxports = 0; s->maxports < (io_size - 0x10) / 2; s->maxports++) {
  2964. unsigned int portstatus;
  2966. portstatus = inw (io_addr + 0x10 + (s->maxports * 2));
  2967. dbg("port %i, adr %x status %x", s->maxports,
  2968. io_addr + 0x10 + (s->maxports * 2), portstatus);
  2969. if (!(portstatus & 0x0080))
  2970. break;
  2971. }
  2972. warn("Detected %d ports", s->maxports);
  2974. /* This is experimental so anything less than 2 or greater than 8 is */
  2975. /*  something weird and we'll ignore it */
  2976. if (s->maxports < 2 || s->maxports > 8) {
  2977. dbg("Port count misdetected, forcing to 2 ports");
  2978. s->maxports = 2;
  2979. }
  2981. s->rh.numports = s->maxports;
  2982. s->loop_usage=0;
  2983. if (init_skel (s)) {
  2984. usb_free_bus (bus);
  2985. kfree(s);
  2986. return -1;
  2987. }
  2989. request_region (s->io_addr, io_size, MODNAME);
  2990. reset_hc (s);
  2991. usb_register_bus (s->bus);
  2993. start_hc (s);
  2995. if (request_irq (irq, uhci_interrupt, SA_SHIRQ, MODNAME, s)) {
  2996. err("request_irq %d failed!",irq);
  2997. usb_free_bus (bus);
  2998. reset_hc (s);
  2999. release_region (s->io_addr, s->io_size);
  3000. cleanup_skel(s);
  3001. kfree(s);
  3002. return -1;
  3003. }
  3005. /* Enable PIRQ */
  3006. pci_write_config_word (dev, USBLEGSUP, USBLEGSUP_DEFAULT);
  3008. s->irq = irq;
  3010. if(uhci_start_usb (s) < 0) {
  3011. uhci_pci_remove(dev);
  3012. return -1;
  3013. }
  3015. //chain new uhci device into global list
  3016. pci_set_drvdata(dev, s);
  3017. devs=s;
  3019. return 0;
  3020. }
  3022. _static int __devinit
  3023. uhci_pci_probe (struct pci_dev *dev, const struct pci_device_id *id)
  3024. {
  3025. int i;
  3027. if (pci_enable_device(dev) < 0)
  3028. return -ENODEV;
  3030. if (!dev->irq) {
  3031. err("found UHCI device with no IRQ assigned. check BIOS settings!");
  3032. return -ENODEV;
  3033. }
  3035. pci_set_master(dev);
  3037. /* Search for the IO base address.. */
  3038. for (i = 0; i < 6; i++) {
  3040. unsigned int io_addr = pci_resource_start(dev, i);
  3041. unsigned int io_size = pci_resource_len(dev, i);
  3042. if (!(pci_resource_flags(dev,i) & IORESOURCE_IO))
  3043. continue;
  3045. /* Is it already in use? */
  3046. if (check_region (io_addr, io_size))
  3047. break;
  3048. /* disable legacy emulation */
  3049. pci_write_config_word (dev, USBLEGSUP, 0);
  3051. return alloc_uhci(dev, dev->irq, io_addr, io_size);
  3052. }
  3053. return -ENODEV;
  3054. }
  3056. /*-------------------------------------------------------------------------*/
  3058. static const struct pci_device_id __devinitdata uhci_pci_ids [] = { {
  3060. /* handle any USB UHCI controller */
  3061. class:  ((PCI_CLASS_SERIAL_USB << 8) | 0x00),
  3062. class_mask:  ~0,
  3064. /* no matter who makes it */
  3065. vendor: PCI_ANY_ID,
  3066. device: PCI_ANY_ID,
  3067. subvendor: PCI_ANY_ID,
  3068. subdevice: PCI_ANY_ID,
  3070. }, { /* end: all zeroes */ }
  3071. };
  3073. MODULE_DEVICE_TABLE (pci, uhci_pci_ids);
  3075. static struct pci_driver uhci_pci_driver = {
  3076. name: "usb-uhci",
  3077. id_table: &uhci_pci_ids [0],
  3079. probe: uhci_pci_probe,
  3080. remove: uhci_pci_remove,
  3082. #ifdef CONFIG_PM
  3083. suspend: uhci_pci_suspend,
  3084. resume: uhci_pci_resume,
  3085. #endif /* PM */
  3087. };
  3089. /*-------------------------------------------------------------------------*/
  3091. static int __init uhci_hcd_init (void) 
  3092. {
  3093. int retval;
  3095. #ifdef DEBUG_SLAB
  3096. urb_priv_kmem = kmem_cache_create("urb_priv", sizeof(urb_priv_t), 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
  3098. if(!urb_priv_kmem) {
  3099. err("kmem_cache_create for urb_priv_t failed (out of memory)");
  3100. return -ENOMEM;
  3101. }
  3102. #endif
  3103. info(VERSTR);
  3105. #ifdef CONFIG_USB_UHCI_HIGH_BANDWIDTH
  3106. info("High bandwidth mode enabled");
  3107. #endif
  3109. retval = pci_module_init (&uhci_pci_driver);
  3111. #ifdef DEBUG_SLAB
  3112. if (retval < 0 ) {
  3113. if (kmem_cache_destroy(urb_priv_kmem))
  3114. err("urb_priv_kmem remained");
  3115. }
  3116. #endif
  3118. info(DRIVER_VERSION ":" DRIVER_DESC);
  3120. return retval;
  3121. }
  3123. static void __exit uhci_hcd_cleanup (void) 
  3124. {      
  3125. pci_unregister_driver (&uhci_pci_driver);
  3127. #ifdef DEBUG_SLAB
  3128. if(kmem_cache_destroy(urb_priv_kmem))
  3129. err("urb_priv_kmem remained");
  3130. #endif
  3131. }
  3133. module_init (uhci_hcd_init);
  3134. module_exit (uhci_hcd_cleanup);
  3137. MODULE_AUTHOR( DRIVER_AUTHOR );
  3138. MODULE_DESCRIPTION( DRIVER_DESC );
  3139. MODULE_LICENSE("GPL");