/shark/trunk/drivers/usb/host/ohci-mem.c |
---|
13,7 → 13,7 |
* There's basically three types of memory: |
* - data used only by the HCD ... kmalloc is fine |
* - async and periodic schedules, shared by HC and HCD ... these |
* need to use pci_pool or pci_alloc_consistent |
* need to use pci_pool or pci_alloc_consistent_usb |
* - driver buffers, read/written by HC ... the hcd glue or the |
* device driver provides us with dma addresses |
* |
96,7 → 96,7 |
dma_addr_t dma; |
struct td *td; |
td = pci_pool_alloc (hc->td_cache, mem_flags, &dma); |
td = pci_pool_alloc_usb (hc->td_cache, mem_flags, &dma); |
if (td) { |
/* in case hc fetches it, make it look dead */ |
memset (td, 0, sizeof *td); |
130,7 → 130,7 |
dma_addr_t dma; |
struct ed *ed; |
ed = pci_pool_alloc (hc->ed_cache, mem_flags, &dma); |
ed = pci_pool_alloc_usb (hc->ed_cache, mem_flags, &dma); |
if (ed) { |
memset (ed, 0, sizeof (*ed)); |
INIT_LIST_HEAD (&ed->td_list); |
/shark/trunk/drivers/usb/host/ehci-hcd.c |
---|
121,8 → 121,10 |
/* Initial IRQ latency: lower than default */ |
static int log2_irq_thresh = 0; // 0 to 6 |
module_param (log2_irq_thresh, int, S_IRUGO); |
/*module_param (log2_irq_thresh, int, S_IRUGO); |
MODULE_PARM_DESC (log2_irq_thresh, "log2 IRQ latency, 1-64 microframes"); |
*/ |
#define INTR_MASK (STS_IAA | STS_FATAL | STS_ERR | STS_INT) |
483,7 → 485,7 |
* involved with the root hub. |
*/ |
ehci->reboot_notifier.notifier_call = ehci_reboot; |
register_reboot_notifier (&ehci->reboot_notifier); |
// register_reboot_notifier (&ehci->reboot_notifier); |
ehci->hcd.state = USB_STATE_RUNNING; |
writel (FLAG_CF, &ehci->regs->configured_flag); |
540,7 → 542,7 |
/* let companion controllers work when we aren't */ |
writel (0, &ehci->regs->configured_flag); |
unregister_reboot_notifier (&ehci->reboot_notifier); |
// unregister_reboot_notifier (&ehci->reboot_notifier); |
remove_debug_files (ehci); |
1011,7 → 1013,7 |
MODULE_AUTHOR (DRIVER_AUTHOR); |
MODULE_LICENSE ("GPL"); |
static int __init init (void) |
/*static*/ int __init ehci_hcd_init (void) |
{ |
if (usb_disabled()) |
return -ENODEV; |
1023,10 → 1025,10 |
return pci_module_init (&ehci_pci_driver); |
} |
module_init (init); |
//module_init (init); |
static void __exit cleanup (void) |
/*static*/ void __exit ehci_hcd_cleanup (void) |
{ |
pci_unregister_driver (&ehci_pci_driver); |
} |
module_exit (cleanup); |
//module_exit (cleanup); |
/shark/trunk/drivers/usb/host/ehci.h |
---|
134,7 → 134,7 |
t = EHCI_SHRINK_JIFFIES; |
break; |
} |
t += jiffies; |
t += jiffies26; |
// all timings except IAA watchdog can be overridden. |
// async queue SHRINK often precedes IAA. while it's ready |
// to go OFF neither can matter, and afterwards the IO |
/shark/trunk/drivers/usb/host/ohci-hcd.c |
---|
40,7 → 40,7 |
* 2001/03/24 td/ed hashing to remove bus_to_virt (Steve Longerbeam); |
pci_map_single (db) |
* 2001/03/21 td and dev/ed allocation uses new pci_pool API (db) |
* 2001/03/07 hcca allocation uses pci_alloc_consistent (Steve Longerbeam) |
* 2001/03/07 hcca allocation uses pci_alloc_consistent_usb (Steve Longerbeam) |
* |
* 2000/09/26 fixed races in removing the private portion of the urb |
* 2000/09/07 disable bulk and control lists when unlinking the last |
/shark/trunk/drivers/usb/host/uhci-hcd.c |
---|
145,7 → 145,7 |
dma_addr_t dma_handle; |
struct uhci_td *td; |
td = pci_pool_alloc(uhci->td_pool, GFP_ATOMIC, &dma_handle); |
td = pci_pool_alloc_usb(uhci->td_pool, GFP_ATOMIC, &dma_handle); |
if (!td) |
return NULL; |
305,7 → 305,7 |
dma_addr_t dma_handle; |
struct uhci_qh *qh; |
qh = pci_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle); |
qh = pci_pool_alloc_usb(uhci->qh_pool, GFP_ATOMIC, &dma_handle); |
if (!qh) |
return NULL; |
2208,6 → 2208,11 |
uhci->io_addr = (unsigned long) hcd->regs; |
/* Turn off all interrupts 2.6.1 */ |
outw(0, uhci->io_addr + USBINTR); |
/* Maybe kick BIOS off this hardware. Then reset, so we won't get |
* interrupts from any previous setup. |
*/ |
2280,7 → 2285,7 |
spin_lock_init(&uhci->frame_list_lock); |
uhci->fl = pci_alloc_consistent(hcd->pdev, sizeof(*uhci->fl), &dma_handle); |
uhci->fl = pci_alloc_consistent_usb(hcd->pdev, sizeof(*uhci->fl), &dma_handle); |
if (!uhci->fl) { |
err("unable to allocate consistent memory for frame list"); |
goto err_alloc_fl; |
/shark/trunk/drivers/usb/host/ehci-mem.c |
---|
24,7 → 24,7 |
* There's basically three types of memory: |
* - data used only by the HCD ... kmalloc is fine |
* - async and periodic schedules, shared by HC and HCD ... these |
* need to use pci_pool or pci_alloc_consistent |
* need to use pci_pool or pci_alloc_consistent_usb |
* - driver buffers, read/written by HC ... single shot DMA mapped |
* |
* There's also PCI "register" data, which is memory mapped. |
74,7 → 74,7 |
struct ehci_qtd *qtd; |
dma_addr_t dma; |
qtd = pci_pool_alloc (ehci->qtd_pool, flags, &dma); |
qtd = pci_pool_alloc_usb (ehci->qtd_pool, flags, &dma); |
if (qtd != 0) { |
ehci_qtd_init (qtd, dma); |
} |
93,7 → 93,7 |
dma_addr_t dma; |
qh = (struct ehci_qh *) |
pci_pool_alloc (ehci->qh_pool, flags, &dma); |
pci_pool_alloc_usb (ehci->qh_pool, flags, &dma); |
if (!qh) |
return qh; |
224,7 → 224,7 |
/* Hardware periodic table */ |
ehci->periodic = (u32 *) |
pci_alloc_consistent (ehci->hcd.pdev, |
pci_alloc_consistent_usb (ehci->hcd.pdev, |
ehci->periodic_size * sizeof (u32), |
&ehci->periodic_dma); |
if (ehci->periodic == 0) { |
/shark/trunk/drivers/usb/host/ohci-pci.c |
---|
46,7 → 46,7 |
int ret; |
if (hcd->pdev) { |
ohci->hcca = pci_alloc_consistent (hcd->pdev, |
ohci->hcca = pci_alloc_consistent_usb (hcd->pdev, |
sizeof *ohci->hcca, &ohci->hcca_dma); |
if (!ohci->hcca) |
/shark/trunk/drivers/usb/host/ehci-sched.c |
---|
626,7 → 626,7 |
for (frame_index = 0, first_itd = 0; |
frame_index < urb->number_of_packets; |
frame_index++) { |
itd = pci_pool_alloc (ehci->itd_pool, mem_flags, &itd_dma); |
itd = pci_pool_alloc_usb (ehci->itd_pool, mem_flags, &itd_dma); |
if (!itd) { |
status = -ENOMEM; |
goto fail; |