ChangeSet 1.1557.49.17, 2004/02/17 17:16:30-08:00, [EMAIL PROTECTED]
[PATCH] USB: Fix USB host code to use generic DMA API
drivers/usb/core/buffer.c | 23 ++++++++++++--------
drivers/usb/core/hcd-pci.c | 31 ++++++++++++++--------------
drivers/usb/core/hcd.c | 38 ++++++++++++++++++----------------
drivers/usb/core/hcd.h | 7 +-----
drivers/usb/host/ehci-dbg.c | 10 ++++-----
drivers/usb/host/ehci-hcd.c | 18 +++++++++-------
drivers/usb/host/ehci-mem.c | 40 ++++++++++++++++++++----------------
drivers/usb/host/ehci-q.c | 2 -
drivers/usb/host/ehci-sched.c | 4 +--
drivers/usb/host/ehci.h | 10 ++++-----
drivers/usb/host/ohci-hcd.c | 8 +++++--
drivers/usb/host/ohci-mem.c | 20 +++++++++---------
drivers/usb/host/ohci-omap.c | 12 +++-------
drivers/usb/host/ohci-pci.c | 45 +++++++++++++++++++++--------------------
drivers/usb/host/ohci-q.c | 4 +--
drivers/usb/host/ohci-sa1111.c | 16 +++++---------
drivers/usb/host/ohci.h | 12 +++++-----
drivers/usb/host/uhci-hcd.c | 45 ++++++++++++++++++++++-------------------
drivers/usb/host/uhci-hcd.h | 4 +--
19 files changed, 182 insertions(+), 167 deletions(-)
diff -Nru a/drivers/usb/core/buffer.c b/drivers/usb/core/buffer.c
--- a/drivers/usb/core/buffer.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/core/buffer.c Thu Feb 19 17:21:42 2004
@@ -2,14 +2,19 @@
* DMA memory management for framework level HCD code (hc_driver)
*
* This implementation plugs in through generic "usb_bus" level methods,
- * and works with real PCI, or when "pci device == null" makes sense.
+ * and should work with all USB controllers, regardles of bus type.
*/
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
-#include <linux/pci.h>
+#include <linux/device.h>
+#include <linux/mm.h>
+#include <asm/io.h>
+#include <asm/scatterlist.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
#ifdef CONFIG_USB_DEBUG
@@ -62,7 +67,7 @@
if (!(size = pool_max [i]))
continue;
snprintf (name, sizeof name, "buffer-%d", size);
- hcd->pool [i] = pci_pool_create (name, hcd->pdev,
+ hcd->pool [i] = dma_pool_create (name, hcd->self.controller,
size, size, 0);
if (!hcd->pool [i]) {
hcd_buffer_destroy (hcd);
@@ -86,9 +91,9 @@
int i;
for (i = 0; i < HCD_BUFFER_POOLS; i++) {
- struct pci_pool *pool = hcd->pool [i];
+ struct dma_pool *pool = hcd->pool [i];
if (pool) {
- pci_pool_destroy (pool);
+ dma_pool_destroy (pool);
hcd->pool [i] = 0;
}
}
@@ -112,9 +117,9 @@
for (i = 0; i < HCD_BUFFER_POOLS; i++) {
if (size <= pool_max [i])
- return pci_pool_alloc (hcd->pool [i], mem_flags, dma);
+ return dma_pool_alloc (hcd->pool [i], mem_flags, dma);
}
- return pci_alloc_consistent (hcd->pdev, size, dma);
+ return dma_alloc_coherent (hcd->self.controller, size, dma, 0);
}
void hcd_buffer_free (
@@ -131,9 +136,9 @@
return;
for (i = 0; i < HCD_BUFFER_POOLS; i++) {
if (size <= pool_max [i]) {
- pci_pool_free (hcd->pool [i], addr, dma);
+ dma_pool_free (hcd->pool [i], addr, dma);
return;
}
}
- pci_free_consistent (hcd->pdev, size, addr, dma);
+ dma_free_coherent (hcd->self.controller, size, addr, dma);
}
diff -Nru a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
--- a/drivers/usb/core/hcd-pci.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/core/hcd-pci.c Thu Feb 19 17:21:42 2004
@@ -146,12 +146,10 @@
pci_set_drvdata (dev, hcd);
hcd->driver = driver;
hcd->description = driver->description;
- hcd->pdev = dev;
hcd->self.bus_name = pci_name(dev);
if (hcd->product_desc == NULL)
hcd->product_desc = "USB Host Controller";
hcd->self.controller = &dev->dev;
- hcd->controller = hcd->self.controller;
if ((retval = hcd_buffer_create (hcd)) != 0) {
clean_3:
@@ -159,11 +157,11 @@
goto clean_2;
}
- dev_info (hcd->controller, "%s\n", hcd->product_desc);
+ dev_info (hcd->self.controller, "%s\n", hcd->product_desc);
/* till now HC has been in an indeterminate state ... */
if (driver->reset && (retval = driver->reset (hcd)) < 0) {
- dev_err (hcd->controller, "can't reset\n");
+ dev_err (hcd->self.controller, "can't reset\n");
goto clean_3;
}
hcd->state = USB_STATE_HALT;
@@ -177,13 +175,13 @@
retval = request_irq (dev->irq, usb_hcd_irq, SA_SHIRQ,
hcd->description, hcd);
if (retval != 0) {
- dev_err (hcd->controller,
+ dev_err (hcd->self.controller,
"request interrupt %s failed\n", bufp);
goto clean_3;
}
hcd->irq = dev->irq;
- dev_info (hcd->controller, "irq %s, %s %p\n", bufp,
+ dev_info (hcd->self.controller, "irq %s, %s %p\n", bufp,
(driver->flags & HCD_MEMORY) ? "pci mem" : "io base",
base);
@@ -226,7 +224,7 @@
hcd = pci_get_drvdata(dev);
if (!hcd)
return;
- dev_info (hcd->controller, "remove, state %x\n", hcd->state);
+ dev_info (hcd->self.controller, "remove, state %x\n", hcd->state);
if (in_interrupt ())
BUG ();
@@ -235,7 +233,7 @@
if (HCD_IS_RUNNING (hcd->state))
hcd->state = USB_STATE_QUIESCING;
- dev_dbg (hcd->controller, "roothub graceful disconnect\n");
+ dev_dbg (hcd->self.controller, "roothub graceful disconnect\n");
usb_disconnect (&hub);
hcd->driver->stop (hcd);
@@ -273,15 +271,15 @@
int retval = 0;
hcd = pci_get_drvdata(dev);
- dev_dbg (hcd->controller, "suspend D%d --> D%d\n",
+ dev_dbg (hcd->self.controller, "suspend D%d --> D%d\n",
dev->current_state, state);
switch (hcd->state) {
case USB_STATE_HALT:
- dev_dbg (hcd->controller, "halted; hcd not suspended\n");
+ dev_dbg (hcd->self.controller, "halted; hcd not suspended\n");
break;
case USB_STATE_SUSPENDED:
- dev_dbg (hcd->controller, "hcd already suspended\n");
+ dev_dbg (hcd->self.controller, "hcd already suspended\n");
break;
default:
/* remote wakeup needs hub->suspend() cooperation */
@@ -293,7 +291,8 @@
hcd->state = USB_STATE_QUIESCING;
retval = hcd->driver->suspend (hcd, state);
if (retval)
- dev_dbg (hcd->controller, "suspend fail, retval %d\n",
+ dev_dbg (hcd->self.controller,
+ "suspend fail, retval %d\n",
retval);
else
hcd->state = USB_STATE_SUSPENDED;
@@ -316,11 +315,12 @@
int retval;
hcd = pci_get_drvdata(dev);
- dev_dbg (hcd->controller, "resume from state D%d\n",
+ dev_dbg (hcd->self.controller, "resume from state D%d\n",
dev->current_state);
if (hcd->state != USB_STATE_SUSPENDED) {
- dev_dbg (hcd->controller, "can't resume, not suspended!\n");
+ dev_dbg (hcd->self.controller,
+ "can't resume, not suspended!\n");
return -EL3HLT;
}
hcd->state = USB_STATE_RESUMING;
@@ -333,7 +333,8 @@
retval = hcd->driver->resume (hcd);
if (!HCD_IS_RUNNING (hcd->state)) {
- dev_dbg (hcd->controller, "resume fail, retval %d\n", retval);
+ dev_dbg (hcd->self.controller,
+ "resume fail, retval %d\n", retval);
usb_hc_died (hcd);
}
diff -Nru a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
--- a/drivers/usb/core/hcd.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/core/hcd.c Thu Feb 19 17:21:42 2004
@@ -351,7 +351,7 @@
/* FALLTHROUGH */
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
case DeviceOutRequest | USB_REQ_SET_FEATURE:
- dev_dbg (hcd->controller, "no device features yet yet\n");
+ dev_dbg (hcd->self.controller, "no device features yet yet\n");
break;
case DeviceRequest | USB_REQ_GET_CONFIGURATION:
ubuf [0] = 1;
@@ -394,7 +394,7 @@
break;
case DeviceOutRequest | USB_REQ_SET_ADDRESS:
// wValue == urb->dev->devaddr
- dev_dbg (hcd->controller, "root hub device address %d\n",
+ dev_dbg (hcd->self.controller, "root hub device address %d\n",
wValue);
break;
@@ -409,7 +409,7 @@
/* FALLTHROUGH */
case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
case EndpointOutRequest | USB_REQ_SET_FEATURE:
- dev_dbg (hcd->controller, "no endpoint features yet\n");
+ dev_dbg (hcd->self.controller, "no endpoint features yet\n");
break;
/* CLASS REQUESTS (and errors) */
@@ -423,12 +423,12 @@
error:
/* "protocol stall" on error */
urb->status = -EPIPE;
- dev_dbg (hcd->controller, "unsupported hub control message (maxchild
%d)\n",
+ dev_dbg (hcd->self.controller, "unsupported hub control message
(maxchild %d)\n",
urb->dev->maxchild);
}
if (urb->status) {
urb->actual_length = 0;
- dev_dbg (hcd->controller, "CTRL: TypeReq=0x%x val=0x%x idx=0x%x len=%d
==> %d\n",
+ dev_dbg (hcd->self.controller, "CTRL: TypeReq=0x%x val=0x%x idx=0x%x
len=%d ==> %d\n",
typeReq, wValue, wIndex, wLength, urb->status);
}
if (bufp) {
@@ -464,7 +464,7 @@
|| urb->status != -EINPROGRESS
|| urb->transfer_buffer_length < len
|| !HCD_IS_RUNNING (hcd->state)) {
- dev_dbg (hcd->controller,
+ dev_dbg (hcd->self.controller,
"not queuing rh status urb, stat %d\n",
urb->status);
return -EINVAL;
@@ -1068,18 +1068,18 @@
/* lower level hcd code should use *_dma exclusively,
* unless it uses pio or talks to another transport.
*/
- if (hcd->controller->dma_mask) {
+ if (hcd->self.controller->dma_mask) {
if (usb_pipecontrol (urb->pipe)
&& !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
urb->setup_dma = dma_map_single (
- hcd->controller,
+ hcd->self.controller,
urb->setup_packet,
sizeof (struct usb_ctrlrequest),
DMA_TO_DEVICE);
if (urb->transfer_buffer_length != 0
&& !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
urb->transfer_dma = dma_map_single (
- hcd->controller,
+ hcd->self.controller,
urb->transfer_buffer,
urb->transfer_buffer_length,
usb_pipein (urb->pipe)
@@ -1125,7 +1125,7 @@
/* failures "should" be harmless */
value = hcd->driver->urb_dequeue (hcd, urb);
if (value != 0)
- dev_dbg (hcd->controller,
+ dev_dbg (hcd->self.controller,
"dequeue %p --> %d\n",
urb, value);
}
@@ -1232,7 +1232,7 @@
* finish unlinking the initial failed usb_set_address().
*/
if (!hcd->saw_irq) {
- dev_warn (hcd->controller, "Unlink after no-IRQ? "
+ dev_warn (hcd->self.controller, "Unlink after no-IRQ? "
"Different ACPI or APIC settings may help."
"\n");
hcd->saw_irq = 1;
@@ -1244,7 +1244,8 @@
*/
if (!(urb->transfer_flags & URB_ASYNC_UNLINK)) {
if (in_interrupt ()) {
- dev_dbg (hcd->controller, "non-async unlink in_interrupt");
+ dev_dbg (hcd->self.controller,
+ "non-async unlink in_interrupt");
retval = -EWOULDBLOCK;
goto done;
}
@@ -1363,7 +1364,7 @@
if (tmp == -EINPROGRESS) {
tmp = urb->pipe;
unlink1 (hcd, urb);
- dev_dbg (hcd->controller,
+ dev_dbg (hcd->self.controller,
"shutdown urb %p pipe %08x ep%d%s%s\n",
urb, tmp, usb_pipeendpoint (tmp),
(tmp & USB_DIR_IN) ? "in" : "out",
@@ -1417,7 +1418,7 @@
/* device driver problem with refcounts? */
if (!list_empty (&dev->urb_list)) {
- dev_dbg (hcd->controller, "free busy dev, %s devnum %d (bug!)\n",
+ dev_dbg (hcd->self.controller, "free busy dev, %s devnum %d (bug!)\n",
hcd->self.bus_name, udev->devnum);
return -EINVAL;
}
@@ -1474,15 +1475,16 @@
// It would catch exit/unlink paths for all urbs.
/* lower level hcd code should use *_dma exclusively */
- if (hcd->controller->dma_mask) {
+ if (hcd->self.controller->dma_mask) {
if (usb_pipecontrol (urb->pipe)
&& !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
- dma_unmap_single (hcd->controller, urb->setup_dma,
+ dma_unmap_single (hcd->self.controller, urb->setup_dma,
sizeof (struct usb_ctrlrequest),
DMA_TO_DEVICE);
if (urb->transfer_buffer_length != 0
&& !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
- dma_unmap_single (hcd->controller, urb->transfer_dma,
+ dma_unmap_single (hcd->self.controller,
+ urb->transfer_dma,
urb->transfer_buffer_length,
usb_pipein (urb->pipe)
? DMA_FROM_DEVICE
@@ -1551,7 +1553,7 @@
*/
void usb_hc_died (struct usb_hcd *hcd)
{
- dev_err (hcd->controller, "HC died; cleaning up\n");
+ dev_err (hcd->self.controller, "HC died; cleaning up\n");
/* clean up old urbs and devices; needs a task context */
INIT_WORK (&hcd->work, hcd_panic, hcd);
diff -Nru a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
--- a/drivers/usb/core/hcd.h Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/core/hcd.h Thu Feb 19 17:21:42 2004
@@ -76,17 +76,14 @@
unsigned saw_irq : 1;
int irq; /* irq allocated */
void *regs; /* device memory/io */
- struct device *controller; /* handle to hardware */
- /* a few non-PCI controllers exist, mostly for OHCI */
- struct pci_dev *pdev; /* pci is typical */
#ifdef CONFIG_PCI
int region; /* pci region for regs */
u32 pci_state [16]; /* for PM state save */
#endif
#define HCD_BUFFER_POOLS 4
- struct pci_pool *pool [HCD_BUFFER_POOLS];
+ struct dma_pool *pool [HCD_BUFFER_POOLS];
int state;
# define __ACTIVE 0x01
@@ -355,7 +352,7 @@
static inline int hcd_register_root (struct usb_hcd *hcd)
{
return usb_register_root_hub (
- hcd_to_bus (hcd)->root_hub, hcd->controller);
+ hcd_to_bus (hcd)->root_hub, hcd->self.controller);
}
/*-------------------------------------------------------------------------*/
diff -Nru a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
--- a/drivers/usb/host/ehci-dbg.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ehci-dbg.c Thu Feb 19 17:21:42 2004
@@ -19,13 +19,13 @@
/* this file is part of ehci-hcd.c */
#define ehci_dbg(ehci, fmt, args...) \
- dev_dbg ((ehci)->hcd.controller , fmt , ## args )
+ dev_dbg ((ehci)->hcd.self.controller , fmt , ## args )
#define ehci_err(ehci, fmt, args...) \
- dev_err ((ehci)->hcd.controller , fmt , ## args )
+ dev_err ((ehci)->hcd.self.controller , fmt , ## args )
#define ehci_info(ehci, fmt, args...) \
- dev_info ((ehci)->hcd.controller , fmt , ## args )
+ dev_info ((ehci)->hcd.self.controller , fmt , ## args )
#define ehci_warn(ehci, fmt, args...) \
- dev_warn ((ehci)->hcd.controller , fmt , ## args )
+ dev_warn ((ehci)->hcd.self.controller , fmt , ## args )
#ifdef EHCI_VERBOSE_DEBUG
# define vdbg dbg
@@ -625,7 +625,7 @@
i = HC_VERSION(readl (&ehci->caps->hc_capbase));
temp = snprintf (next, size,
"PCI device %s\nEHCI %x.%02x, hcd state %d (driver " DRIVER_VERSION
")\n",
- pci_name(hcd->pdev),
+ pci_name(to_pci_dev(hcd->self.controller)),
i >> 8, i & 0x0ff, ehci->hcd.state);
size -= temp;
next += temp;
diff -Nru a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
--- a/drivers/usb/host/ehci-hcd.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ehci-hcd.c Thu Feb 19 17:21:42 2004
@@ -26,6 +26,7 @@
#include <linux/module.h>
#include <linux/pci.h>
+#include <linux/dmapool.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ioport.h>
@@ -67,6 +68,7 @@
*
* HISTORY:
*
+ * 2004-02-24 Replace pci_* with generic dma_* API calls ([EMAIL PROTECTED])
* 2003-12-29 Rewritten high speed iso transfer support (by Michal Sojka,
* <[EMAIL PROTECTED]>, updates by DB).
*
@@ -288,13 +290,13 @@
/* request handoff to OS */
cap &= 1 << 24;
- pci_write_config_dword (ehci->hcd.pdev, where, cap);
+ pci_write_config_dword (to_pci_dev(ehci->hcd.self.controller), where,
cap);
/* and wait a while for it to happen */
do {
wait_ms (10);
msec -= 10;
- pci_read_config_dword (ehci->hcd.pdev, where, &cap);
+ pci_read_config_dword (to_pci_dev(ehci->hcd.self.controller),
where, &cap);
} while ((cap & (1 << 16)) && msec);
if (cap & (1 << 16)) {
ehci_err (ehci, "BIOS handoff failed (%d, %04x)\n",
@@ -339,7 +341,7 @@
while (temp) {
u32 cap;
- pci_read_config_dword (ehci->hcd.pdev, temp, &cap);
+ pci_read_config_dword (to_pci_dev(ehci->hcd.self.controller), temp,
&cap);
ehci_dbg (ehci, "capability %04x at %02x\n", cap, temp);
switch (cap & 0xff) {
case 1: /* BIOS/SMM/... handoff */
@@ -378,7 +380,7 @@
* periodic_size can shrink by USBCMD update if hcc_params allows.
*/
ehci->periodic_size = DEFAULT_I_TDPS;
- if ((retval = ehci_mem_init (ehci, SLAB_KERNEL)) < 0)
+ if ((retval = ehci_mem_init (ehci, GFP_KERNEL)) < 0)
return retval;
/* controllers may cache some of the periodic schedule ... */
@@ -433,13 +435,13 @@
writel (0, &ehci->regs->segment);
#if 0
// this is deeply broken on almost all architectures
- if (!pci_set_dma_mask (ehci->hcd.pdev, 0xffffffffffffffffULL))
+ if (!pci_set_dma_mask (to_pci_dev(ehci->hcd.self.controller),
0xffffffffffffffffULL))
ehci_info (ehci, "enabled 64bit PCI DMA\n");
#endif
}
/* help hc dma work well with cachelines */
- pci_set_mwi (ehci->hcd.pdev);
+ pci_set_mwi (to_pci_dev(ehci->hcd.self.controller));
/* clear interrupt enables, set irq latency */
temp = readl (&ehci->regs->command) & 0x0fff;
@@ -493,7 +495,7 @@
readl (&ehci->regs->command); /* unblock posted write */
/* PCI Serial Bus Release Number is at 0x60 offset */
- pci_read_config_byte (hcd->pdev, 0x60, &tempbyte);
+ pci_read_config_byte(to_pci_dev(hcd->self.controller), 0x60, &tempbyte);
temp = HC_VERSION(readl (&ehci->caps->hc_capbase));
ehci_info (ehci,
"USB %x.%x enabled, EHCI %x.%02x, driver %s\n",
@@ -758,7 +760,7 @@
* non-error returns are a promise to giveback() the urb later
* we drop ownership so next owner (or urb unlink) can get it
*
- * urb + dev is in hcd_dev.urb_list
+ * urb + dev is in hcd.self.controller.urb_list
* we're queueing TDs onto software and hardware lists
*
* hcd-specific init for hcpriv hasn't been done yet
diff -Nru a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
--- a/drivers/usb/host/ehci-mem.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ehci-mem.c Thu Feb 19 17:21:42 2004
@@ -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 dma_pool or dma_alloc_coherent
* - 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 = dma_pool_alloc (ehci->qtd_pool, flags, &dma);
if (qtd != 0) {
ehci_qtd_init (qtd, dma);
}
@@ -83,7 +83,7 @@
static inline void ehci_qtd_free (struct ehci_hcd *ehci, struct ehci_qtd *qtd)
{
- pci_pool_free (ehci->qtd_pool, qtd, qtd->qtd_dma);
+ dma_pool_free (ehci->qtd_pool, qtd, qtd->qtd_dma);
}
@@ -93,7 +93,7 @@
dma_addr_t dma;
qh = (struct ehci_qh *)
- pci_pool_alloc (ehci->qh_pool, flags, &dma);
+ dma_pool_alloc (ehci->qh_pool, flags, &dma);
if (!qh)
return qh;
@@ -107,7 +107,7 @@
qh->dummy = ehci_qtd_alloc (ehci, flags);
if (qh->dummy == 0) {
ehci_dbg (ehci, "no dummy td\n");
- pci_pool_free (ehci->qh_pool, qh, qh->qh_dma);
+ dma_pool_free (ehci->qh_pool, qh, qh->qh_dma);
qh = 0;
}
return qh;
@@ -132,7 +132,7 @@
if (qh->dummy)
ehci_qtd_free (ehci, qh->dummy);
usb_put_dev (qh->dev);
- pci_pool_free (ehci->qh_pool, qh, qh->qh_dma);
+ dma_pool_free (ehci->qh_pool, qh, qh->qh_dma);
}
/*-------------------------------------------------------------------------*/
@@ -148,26 +148,26 @@
qh_put (ehci, ehci->async);
ehci->async = 0;
- /* PCI consistent memory and pools */
+ /* DMA consistent memory and pools */
if (ehci->qtd_pool)
- pci_pool_destroy (ehci->qtd_pool);
+ dma_pool_destroy (ehci->qtd_pool);
ehci->qtd_pool = 0;
if (ehci->qh_pool) {
- pci_pool_destroy (ehci->qh_pool);
+ dma_pool_destroy (ehci->qh_pool);
ehci->qh_pool = 0;
}
if (ehci->itd_pool)
- pci_pool_destroy (ehci->itd_pool);
+ dma_pool_destroy (ehci->itd_pool);
ehci->itd_pool = 0;
if (ehci->sitd_pool)
- pci_pool_destroy (ehci->sitd_pool);
+ dma_pool_destroy (ehci->sitd_pool);
ehci->sitd_pool = 0;
if (ehci->periodic)
- pci_free_consistent (ehci->hcd.pdev,
+ dma_free_coherent (ehci->hcd.self.controller,
ehci->periodic_size * sizeof (u32),
ehci->periodic, ehci->periodic_dma);
ehci->periodic = 0;
@@ -184,7 +184,8 @@
int i;
/* QTDs for control/bulk/intr transfers */
- ehci->qtd_pool = pci_pool_create ("ehci_qtd", ehci->hcd.pdev,
+ ehci->qtd_pool = dma_pool_create ("ehci_qtd",
+ ehci->hcd.self.controller,
sizeof (struct ehci_qtd),
32 /* byte alignment (for hw parts) */,
4096 /* can't cross 4K */);
@@ -193,7 +194,8 @@
}
/* QHs for control/bulk/intr transfers */
- ehci->qh_pool = pci_pool_create ("ehci_qh", ehci->hcd.pdev,
+ ehci->qh_pool = dma_pool_create ("ehci_qh",
+ ehci->hcd.self.controller,
sizeof (struct ehci_qh),
32 /* byte alignment (for hw parts) */,
4096 /* can't cross 4K */);
@@ -206,7 +208,8 @@
}
/* ITD for high speed ISO transfers */
- ehci->itd_pool = pci_pool_create ("ehci_itd", ehci->hcd.pdev,
+ ehci->itd_pool = dma_pool_create ("ehci_itd",
+ ehci->hcd.self.controller,
sizeof (struct ehci_itd),
32 /* byte alignment (for hw parts) */,
4096 /* can't cross 4K */);
@@ -215,7 +218,8 @@
}
/* SITD for full/low speed split ISO transfers */
- ehci->sitd_pool = pci_pool_create ("ehci_sitd", ehci->hcd.pdev,
+ ehci->sitd_pool = dma_pool_create ("ehci_sitd",
+ ehci->hcd.self.controller,
sizeof (struct ehci_sitd),
32 /* byte alignment (for hw parts) */,
4096 /* can't cross 4K */);
@@ -225,9 +229,9 @@
/* Hardware periodic table */
ehci->periodic = (u32 *)
- pci_alloc_consistent (ehci->hcd.pdev,
+ dma_alloc_coherent (ehci->hcd.self.controller,
ehci->periodic_size * sizeof (u32),
- &ehci->periodic_dma);
+ &ehci->periodic_dma, 0);
if (ehci->periodic == 0) {
goto fail;
}
diff -Nru a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
--- a/drivers/usb/host/ehci-q.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ehci-q.c Thu Feb 19 17:21:42 2004
@@ -776,7 +776,7 @@
qh = (struct ehci_qh *) *ptr;
if (unlikely (qh == 0)) {
/* can't sleep here, we have ehci->lock... */
- qh = qh_make (ehci, urb, SLAB_ATOMIC);
+ qh = qh_make (ehci, urb, GFP_ATOMIC);
*ptr = qh;
}
if (likely (qh != 0)) {
diff -Nru a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
--- a/drivers/usb/host/ehci-sched.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ehci-sched.c Thu Feb 19 17:21:42 2004
@@ -578,7 +578,7 @@
itd = list_entry (stream->free_itd_list.next,
struct ehci_itd, itd_list);
list_del (&itd->itd_list);
- pci_pool_free (ehci->itd_pool, itd, itd->itd_dma);
+ dma_pool_free (ehci->itd_pool, itd, itd->itd_dma);
}
is_in = (stream->bEndpointAddress & USB_DIR_IN) ? 0x10 : 0;
@@ -760,7 +760,7 @@
list_del (&itd->itd_list);
itd_dma = itd->itd_dma;
} else
- itd = pci_pool_alloc (ehci->itd_pool, mem_flags,
+ itd = dma_pool_alloc (ehci->itd_pool, mem_flags,
&itd_dma);
if (unlikely (0 == itd)) {
diff -Nru a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
--- a/drivers/usb/host/ehci.h Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ehci.h Thu Feb 19 17:21:42 2004
@@ -74,11 +74,11 @@
struct ehci_regs *regs;
u32 hcs_params; /* cached register copy */
- /* per-HC memory pools (could be per-PCI-bus, but ...) */
- struct pci_pool *qh_pool; /* qh per active urb */
- struct pci_pool *qtd_pool; /* one or more per qh */
- struct pci_pool *itd_pool; /* itd per iso urb */
- struct pci_pool *sitd_pool; /* sitd per split iso urb */
+ /* per-HC memory pools (could be per-bus, but ...) */
+ struct dma_pool *qh_pool; /* qh per active urb */
+ struct dma_pool *qtd_pool; /* one or more per qh */
+ struct dma_pool *itd_pool; /* itd per iso urb */
+ struct dma_pool *sitd_pool; /* sitd per split iso urb */
struct timer_list watchdog;
struct notifier_block reboot_notifier;
diff -Nru a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
--- a/drivers/usb/host/ohci-hcd.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ohci-hcd.c Thu Feb 19 17:21:42 2004
@@ -17,6 +17,7 @@
*
* History:
*
+ * 2004/02/04 use generic dma_* functions instead of pci_* ([EMAIL PROTECTED])
* 2003/02/24 show registers in sysfs (Kevin Brosius)
*
* 2002/09/03 get rid of ed hashtables, rework periodic scheduling and
@@ -96,6 +97,8 @@
#include <linux/interrupt.h> /* for in_interrupt () */
#include <linux/usb.h>
#include "../core/hcd.h"
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h> /* needed by ohci-mem.c when no PCI */
#include <asm/io.h>
#include <asm/irq.h>
@@ -642,8 +645,9 @@
remove_debug_files (ohci);
ohci_mem_cleanup (ohci);
if (ohci->hcca) {
- pci_free_consistent (ohci->hcd.pdev, sizeof *ohci->hcca,
- ohci->hcca, ohci->hcca_dma);
+ dma_free_coherent (ohci->hcd.self.controller,
+ sizeof *ohci->hcca,
+ ohci->hcca, ohci->hcca_dma);
ohci->hcca = NULL;
ohci->hcca_dma = 0;
}
diff -Nru a/drivers/usb/host/ohci-mem.c b/drivers/usb/host/ohci-mem.c
--- a/drivers/usb/host/ohci-mem.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ohci-mem.c Thu Feb 19 17:21:42 2004
@@ -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 dma_pool or dma_alloc_coherent
* - driver buffers, read/written by HC ... the hcd glue or the
* device driver provides us with dma addresses
*
@@ -45,18 +45,18 @@
static int ohci_mem_init (struct ohci_hcd *ohci)
{
- ohci->td_cache = pci_pool_create ("ohci_td", ohci->hcd.pdev,
+ ohci->td_cache = dma_pool_create ("ohci_td", ohci->hcd.self.controller,
sizeof (struct td),
32 /* byte alignment */,
0 /* no page-crossing issues */);
if (!ohci->td_cache)
return -ENOMEM;
- ohci->ed_cache = pci_pool_create ("ohci_ed", ohci->hcd.pdev,
+ ohci->ed_cache = dma_pool_create ("ohci_ed", ohci->hcd.self.controller,
sizeof (struct ed),
16 /* byte alignment */,
0 /* no page-crossing issues */);
if (!ohci->ed_cache) {
- pci_pool_destroy (ohci->td_cache);
+ dma_pool_destroy (ohci->td_cache);
return -ENOMEM;
}
return 0;
@@ -65,11 +65,11 @@
static void ohci_mem_cleanup (struct ohci_hcd *ohci)
{
if (ohci->td_cache) {
- pci_pool_destroy (ohci->td_cache);
+ dma_pool_destroy (ohci->td_cache);
ohci->td_cache = 0;
}
if (ohci->ed_cache) {
- pci_pool_destroy (ohci->ed_cache);
+ dma_pool_destroy (ohci->ed_cache);
ohci->ed_cache = 0;
}
}
@@ -96,7 +96,7 @@
dma_addr_t dma;
struct td *td;
- td = pci_pool_alloc (hc->td_cache, mem_flags, &dma);
+ td = dma_pool_alloc (hc->td_cache, mem_flags, &dma);
if (td) {
/* in case hc fetches it, make it look dead */
memset (td, 0, sizeof *td);
@@ -118,7 +118,7 @@
*prev = td->td_hash;
else if ((td->hwINFO & TD_DONE) != 0)
ohci_dbg (hc, "no hash for td %p\n", td);
- pci_pool_free (hc->td_cache, td, td->td_dma);
+ dma_pool_free (hc->td_cache, td, td->td_dma);
}
/*-------------------------------------------------------------------------*/
@@ -130,7 +130,7 @@
dma_addr_t dma;
struct ed *ed;
- ed = pci_pool_alloc (hc->ed_cache, mem_flags, &dma);
+ ed = dma_pool_alloc (hc->ed_cache, mem_flags, &dma);
if (ed) {
memset (ed, 0, sizeof (*ed));
INIT_LIST_HEAD (&ed->td_list);
@@ -142,6 +142,6 @@
static void
ed_free (struct ohci_hcd *hc, struct ed *ed)
{
- pci_pool_free (hc->ed_cache, ed, ed->dma);
+ dma_pool_free (hc->ed_cache, ed, ed->dma);
}
diff -Nru a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
--- a/drivers/usb/host/ohci-omap.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ohci-omap.c Thu Feb 19 17:21:42 2004
@@ -388,9 +388,7 @@
hcd->description = driver->description;
hcd->irq = dev->irq[0];
hcd->regs = dev->mapbase;
- hcd->pdev = OMAP_FAKE_PCIDEV;
hcd->self.controller = &dev->dev;
- hcd->controller = hcd->self.controller;
retval = hcd_buffer_create (hcd);
if (retval != 0) {
@@ -494,12 +492,10 @@
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
int ret;
- if (hcd->pdev) {
- ohci->hcca = pci_alloc_consistent (hcd->pdev,
- sizeof *ohci->hcca, &ohci->hcca_dma);
- if (!ohci->hcca)
- return -ENOMEM;
- }
+ ohci->hcca = dma_alloc_consistent (hcd->self.controller,
+ sizeof *ohci->hcca, &ohci->hcca_dma);
+ if (!ohci->hcca)
+ return -ENOMEM;
memset (ohci->hcca, 0, sizeof (struct ohci_hcca));
if ((ret = ohci_mem_init (ohci)) < 0) {
diff -Nru a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
--- a/drivers/usb/host/ohci-pci.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ohci-pci.c Thu Feb 19 17:21:42 2004
@@ -45,17 +45,19 @@
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
int ret;
- if (hcd->pdev) {
- ohci->hcca = pci_alloc_consistent (hcd->pdev,
- sizeof *ohci->hcca, &ohci->hcca_dma);
- if (!ohci->hcca)
- return -ENOMEM;
+ ohci->hcca = dma_alloc_coherent (hcd->self.controller,
+ sizeof *ohci->hcca, &ohci->hcca_dma, 0);
+ if (!ohci->hcca)
+ return -ENOMEM;
+
+ if(hcd->self.controller && hcd->self.controller->bus == &pci_bus_type) {
+ struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
/* AMD 756, for most chips (early revs), corrupts register
* values on read ... so enable the vendor workaround.
*/
- if (hcd->pdev->vendor == PCI_VENDOR_ID_AMD
- && hcd->pdev->device == 0x740c) {
+ if (pdev->vendor == PCI_VENDOR_ID_AMD
+ && pdev->device == 0x740c) {
ohci->flags = OHCI_QUIRK_AMD756;
ohci_info (ohci, "AMD756 erratum 4 workaround\n");
}
@@ -68,8 +70,8 @@
* for this chip. Evidently control and bulk lists
* can get confused. (B&W G3 models, and ...)
*/
- else if (hcd->pdev->vendor == PCI_VENDOR_ID_OPTI
- && hcd->pdev->device == 0xc861) {
+ else if (pdev->vendor == PCI_VENDOR_ID_OPTI
+ && pdev->device == 0xc861) {
ohci_info (ohci,
"WARNING: OPTi workarounds unavailable\n");
}
@@ -78,12 +80,11 @@
* identify the USB (fn2). This quirk might apply to more or
* even all NSC stuff.
*/
- else if (hcd->pdev->vendor == PCI_VENDOR_ID_NS) {
- struct pci_dev *b, *hc;
+ else if (pdev->vendor == PCI_VENDOR_ID_NS) {
+ struct pci_dev *b;
- hc = hcd->pdev;
- b = pci_find_slot (hc->bus->number,
- PCI_DEVFN (PCI_SLOT (hc->devfn), 1));
+ b = pci_find_slot (pdev->bus->number,
+ PCI_DEVFN (PCI_SLOT (pdev->devfn), 1));
if (b && b->device == PCI_DEVICE_ID_NS_87560_LIO
&& b->vendor == PCI_VENDOR_ID_NS) {
ohci->flags |= OHCI_QUIRK_SUPERIO;
@@ -145,7 +146,7 @@
#ifdef CONFIG_PMAC_PBOOK
if (_machine == _MACH_Pmac)
- disable_irq (hcd->pdev->irq);
+ disable_irq ((to_pci_dev(hcd->self.controller))->irq);
/* else, 2.4 assumes shared irqs -- don't disable */
#endif
@@ -179,15 +180,17 @@
* memory during sleep. We disable its bus master bit during
* suspend
*/
- pci_read_config_word (hcd->pdev, PCI_COMMAND, &cmd);
+ pci_read_config_word (to_pci_dev(hcd->self.controller), PCI_COMMAND,
+ &cmd);
cmd &= ~PCI_COMMAND_MASTER;
- pci_write_config_word (hcd->pdev, PCI_COMMAND, cmd);
+ pci_write_config_word (to_pci_dev(hcd->self.controller), PCI_COMMAND,
+ cmd);
#ifdef CONFIG_PMAC_PBOOK
{
struct device_node *of_node;
/* Disable USB PAD & cell clock */
- of_node = pci_device_to_OF_node (hcd->pdev);
+ of_node = pci_device_to_OF_node (to_pci_dev(hcd->self.controller));
if (of_node)
pmac_call_feature(PMAC_FTR_USB_ENABLE, of_node, 0, 0);
}
@@ -207,7 +210,7 @@
struct device_node *of_node;
/* Re-enable USB PAD & cell clock */
- of_node = pci_device_to_OF_node (hcd->pdev);
+ of_node = pci_device_to_OF_node (to_pci_dev(hcd->self.controller));
if (of_node)
pmac_call_feature (PMAC_FTR_USB_ENABLE, of_node, 0, 1);
}
@@ -222,7 +225,7 @@
#endif
/* Re-enable bus mastering */
- pci_set_master (ohci->hcd.pdev);
+ pci_set_master (to_pci_dev(ohci->hcd.self.controller));
switch (temp) {
@@ -282,7 +285,7 @@
#ifdef CONFIG_PMAC_PBOOK
if (_machine == _MACH_Pmac)
- enable_irq (hcd->pdev->irq);
+ enable_irq (to_pci_dev(hcd->self.controller)->irq);
#endif
/* Check for a pending done list */
diff -Nru a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
--- a/drivers/usb/host/ohci-q.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ohci-q.c Thu Feb 19 17:21:42 2004
@@ -375,7 +375,7 @@
if (!(ed = dev->ep [ep])) {
struct td *td;
- ed = ed_alloc (ohci, SLAB_ATOMIC);
+ ed = ed_alloc (ohci, GFP_ATOMIC);
if (!ed) {
/* out of memory */
goto done;
@@ -383,7 +383,7 @@
dev->ep [ep] = ed;
/* dummy td; end of td list for ed */
- td = td_alloc (ohci, SLAB_ATOMIC);
+ td = td_alloc (ohci, GFP_ATOMIC);
if (!td) {
/* out of memory */
ed_free (ohci, ed);
diff -Nru a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
--- a/drivers/usb/host/ohci-sa1111.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ohci-sa1111.c Thu Feb 19 17:21:42 2004
@@ -167,9 +167,7 @@
hcd->description = driver->description;
hcd->irq = dev->irq[1];
hcd->regs = dev->mapbase;
- hcd->pdev = SA1111_FAKE_PCIDEV;
hcd->self.controller = &dev->dev;
- hcd->controller = hcd->self.controller;
retval = hcd_buffer_create (hcd);
if (retval != 0) {
@@ -270,14 +268,12 @@
struct ohci_hcd *ohci = hcd_to_ohci (hcd);
int ret;
- if (hcd->pdev) {
- ohci->hcca = pci_alloc_consistent (hcd->pdev,
- sizeof *ohci->hcca, &ohci->hcca_dma);
- if (!ohci->hcca)
- return -ENOMEM;
- }
-
- memset (ohci->hcca, 0, sizeof (struct ohci_hcca));
+ ohci->hcca = dma_alloc_coherent (hcd->self.controller,
+ sizeof *ohci->hcca, &ohci->hcca_dma, 0);
+ if (!ohci->hcca)
+ return -ENOMEM;
+
+ memset (ohci->hcca, 0, sizeof (struct ohci_hcca));
if ((ret = ohci_mem_init (ohci)) < 0) {
ohci_stop (hcd);
return ret;
diff -Nru a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
--- a/drivers/usb/host/ohci.h Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/ohci.h Thu Feb 19 17:21:42 2004
@@ -361,8 +361,8 @@
/*
* memory management for queue data structures
*/
- struct pci_pool *td_cache;
- struct pci_pool *ed_cache;
+ struct dma_pool *td_cache;
+ struct dma_pool *ed_cache;
struct td *td_hash [TD_HASH_SIZE];
/*
@@ -391,13 +391,13 @@
#endif /* DEBUG */
#define ohci_dbg(ohci, fmt, args...) \
- dev_dbg ((ohci)->hcd.controller , fmt , ## args )
+ dev_dbg ((ohci)->hcd.self.controller , fmt , ## args )
#define ohci_err(ohci, fmt, args...) \
- dev_err ((ohci)->hcd.controller , fmt , ## args )
+ dev_err ((ohci)->hcd.self.controller , fmt , ## args )
#define ohci_info(ohci, fmt, args...) \
- dev_info ((ohci)->hcd.controller , fmt , ## args )
+ dev_info ((ohci)->hcd.self.controller , fmt , ## args )
#define ohci_warn(ohci, fmt, args...) \
- dev_warn ((ohci)->hcd.controller , fmt , ## args )
+ dev_warn ((ohci)->hcd.self.controller , fmt , ## args )
#ifdef OHCI_VERBOSE_DEBUG
# define ohci_vdbg ohci_dbg
diff -Nru a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
--- a/drivers/usb/host/uhci-hcd.c Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/uhci-hcd.c Thu Feb 19 17:21:42 2004
@@ -41,6 +41,8 @@
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/proc_fs.h>
+#include <linux/dmapool.h>
+#include <linux/dma-mapping.h>
#ifdef CONFIG_USB_DEBUG
#define DEBUG
#else
@@ -140,7 +142,7 @@
dma_addr_t dma_handle;
struct uhci_td *td;
- td = pci_pool_alloc(uhci->td_pool, GFP_ATOMIC, &dma_handle);
+ td = dma_pool_alloc(uhci->td_pool, GFP_ATOMIC, &dma_handle);
if (!td)
return NULL;
@@ -292,7 +294,7 @@
if (td->dev)
usb_put_dev(td->dev);
- pci_pool_free(uhci->td_pool, td, td->dma_handle);
+ dma_pool_free(uhci->td_pool, td, td->dma_handle);
}
static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci, struct usb_device *dev)
@@ -300,7 +302,7 @@
dma_addr_t dma_handle;
struct uhci_qh *qh;
- qh = pci_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle);
+ qh = dma_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle);
if (!qh)
return NULL;
@@ -330,7 +332,7 @@
if (qh->dev)
usb_put_dev(qh->dev);
- pci_pool_free(uhci->qh_pool, qh, qh->dma_handle);
+ dma_pool_free(uhci->qh_pool, qh, qh->dma_handle);
}
/*
@@ -2013,7 +2015,8 @@
unsigned int io_addr = uhci->io_addr;
int i;
- if (!uhci->hcd.pdev || uhci->hcd.pdev->vendor != PCI_VENDOR_ID_INTEL)
+ if (!uhci->hcd.self.controller ||
+ to_pci_dev(uhci->hcd.self.controller)->vendor != PCI_VENDOR_ID_INTEL)
return 1;
/* Some of Intel's USB controllers have a bug that causes false
@@ -2127,17 +2130,17 @@
}
if (uhci->qh_pool) {
- pci_pool_destroy(uhci->qh_pool);
+ dma_pool_destroy(uhci->qh_pool);
uhci->qh_pool = NULL;
}
if (uhci->td_pool) {
- pci_pool_destroy(uhci->td_pool);
+ dma_pool_destroy(uhci->td_pool);
uhci->td_pool = NULL;
}
if (uhci->fl) {
- pci_free_consistent(uhci->hcd.pdev, sizeof(*uhci->fl), uhci->fl,
uhci->fl->dma_handle);
+ dma_free_coherent(uhci->hcd.self.controller, sizeof(*uhci->fl),
uhci->fl, uhci->fl->dma_handle);
uhci->fl = NULL;
}
@@ -2162,7 +2165,7 @@
* interrupts from any previous setup.
*/
reset_hc(uhci);
- pci_write_config_word(hcd->pdev, USBLEGSUP, USBLEGSUP_DEFAULT);
+ pci_write_config_word(to_pci_dev(hcd->self.controller), USBLEGSUP,
USBLEGSUP_DEFAULT);
return 0;
}
@@ -2194,7 +2197,7 @@
struct proc_dir_entry *ent;
#endif
- io_size = pci_resource_len(hcd->pdev, hcd->region);
+ io_size = pci_resource_len(to_pci_dev(hcd->self.controller), hcd->region);
#ifdef CONFIG_PROC_FS
ent = create_proc_entry(hcd->self.bus_name, S_IFREG|S_IRUGO|S_IWUSR,
uhci_proc_root);
@@ -2230,7 +2233,8 @@
spin_lock_init(&uhci->frame_list_lock);
- uhci->fl = pci_alloc_consistent(hcd->pdev, sizeof(*uhci->fl), &dma_handle);
+ uhci->fl = dma_alloc_coherent(hcd->self.controller,
+ sizeof(*uhci->fl), &dma_handle, 0);
if (!uhci->fl) {
err("unable to allocate consistent memory for frame list");
goto err_alloc_fl;
@@ -2240,17 +2244,17 @@
uhci->fl->dma_handle = dma_handle;
- uhci->td_pool = pci_pool_create("uhci_td", hcd->pdev,
+ uhci->td_pool = dma_pool_create("uhci_td", hcd->self.controller,
sizeof(struct uhci_td), 16, 0);
if (!uhci->td_pool) {
- err("unable to create td pci_pool");
+ err("unable to create td dma_pool");
goto err_create_td_pool;
}
- uhci->qh_pool = pci_pool_create("uhci_qh", hcd->pdev,
+ uhci->qh_pool = dma_pool_create("uhci_qh", hcd->self.controller,
sizeof(struct uhci_qh), 16, 0);
if (!uhci->qh_pool) {
- err("unable to create qh pci_pool");
+ err("unable to create qh dma_pool");
goto err_create_qh_pool;
}
@@ -2361,7 +2365,7 @@
udev->speed = USB_SPEED_FULL;
- if (usb_register_root_hub(udev, &hcd->pdev->dev) != 0) {
+ if (usb_register_root_hub(udev, hcd->self.controller) != 0) {
err("unable to start root hub");
retval = -ENOMEM;
goto err_start_root_hub;
@@ -2392,15 +2396,16 @@
hcd->self.root_hub = NULL;
err_alloc_root_hub:
- pci_pool_destroy(uhci->qh_pool);
+ dma_pool_destroy(uhci->qh_pool);
uhci->qh_pool = NULL;
err_create_qh_pool:
- pci_pool_destroy(uhci->td_pool);
+ dma_pool_destroy(uhci->td_pool);
uhci->td_pool = NULL;
err_create_td_pool:
- pci_free_consistent(hcd->pdev, sizeof(*uhci->fl), uhci->fl,
uhci->fl->dma_handle);
+ dma_free_coherent(hcd->self.controller,
+ sizeof(*uhci->fl), uhci->fl, uhci->fl->dma_handle);
uhci->fl = NULL;
err_alloc_fl:
@@ -2456,7 +2461,7 @@
{
struct uhci_hcd *uhci = hcd_to_uhci(hcd);
- pci_set_master(uhci->hcd.pdev);
+ pci_set_master(to_pci_dev(uhci->hcd.self.controller));
if (uhci->state == UHCI_SUSPENDED)
uhci->resume_detect = 1;
diff -Nru a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
--- a/drivers/usb/host/uhci-hcd.h Thu Feb 19 17:21:42 2004
+++ b/drivers/usb/host/uhci-hcd.h Thu Feb 19 17:21:42 2004
@@ -326,8 +326,8 @@
/* Grabbed from PCI */
unsigned long io_addr;
- struct pci_pool *qh_pool;
- struct pci_pool *td_pool;
+ struct dma_pool *qh_pool;
+ struct dma_pool *td_pool;
struct usb_bus *bus;
-------------------------------------------------------
SF.Net is sponsored by: Speed Start Your Linux Apps Now.
Build and deploy apps & Web services for Linux with
a free DVD software kit from IBM. Click Now!
http://ads.osdn.com/?ad_id56&alloc_id438&op=click
_______________________________________________
[EMAIL PROTECTED]
To unsubscribe, use the last form field at:
https://lists.sourceforge.net/lists/listinfo/linux-usb-devel
