Subversion Repositories shark

Compare Revisions

Regard whitespace Rev 846 → Rev 1049

/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;