* seem to behave quite as expected. Used by default.
*
* OUT dma documents design problems handling the common "short packet"
- * transfer termination policy; it couldn't enabled by default, even
+ * transfer termination policy; it couldn't be enabled by default, even
* if the OUT-dma abort problems had a resolution.
*/
static unsigned use_dma = 1;
static void nuke(struct goku_ep *, int status);
static inline void
-command(struct goku_udc_regs *regs, int command, unsigned epnum)
+command(struct goku_udc_regs __iomem *regs, int command, unsigned epnum)
{
writel(COMMAND_EP(epnum) | command, ®s->Command);
udelay(300);
/* ep1 and ep2 can do double buffering and/or dma */
if (ep->num < 3) {
- struct goku_udc_regs *regs = ep->dev->regs;
- u32 tmp;
+ struct goku_udc_regs __iomem *regs = ep->dev->regs;
+ u32 tmp;
/* double buffer except (for now) with pio in */
tmp = ((ep->dma || !ep->is_in)
return 0;
}
-static void ep_reset(struct goku_udc_regs *regs, struct goku_ep *ep)
+static void ep_reset(struct goku_udc_regs __iomem *regs, struct goku_ep *ep)
{
struct goku_udc *dev = ep->dev;
writel(dev->int_enable, ®s->int_enable);
readl(®s->int_enable);
if (ep->num < 3) {
- struct goku_udc_regs *regs = ep->dev->regs;
- u32 tmp;
+ struct goku_udc_regs __iomem *r = ep->dev->regs;
+ u32 tmp;
- tmp = readl(®s->EPxSingle);
+ tmp = readl(&r->EPxSingle);
tmp &= ~(0x11 << ep->num);
- writel(tmp, ®s->EPxSingle);
+ writel(tmp, &r->EPxSingle);
- tmp = readl(®s->EPxBCS);
+ tmp = readl(&r->EPxBCS);
tmp &= ~(0x11 << ep->num);
- writel(tmp, ®s->EPxBCS);
+ writel(tmp, &r->EPxBCS);
}
/* reset dma in case we're still using it */
if (ep->dma) {
}
ep->ep.maxpacket = MAX_FIFO_SIZE;
- ep->desc = 0;
+ ep->desc = NULL;
ep->stopped = 1;
ep->irqs = 0;
ep->dma = 0;
/*-------------------------------------------------------------------------*/
static struct usb_request *
-goku_alloc_request(struct usb_ep *_ep, int gfp_flags)
+goku_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
{
struct goku_request *req;
if (!_ep)
- return 0;
- req = kmalloc(sizeof *req, gfp_flags);
+ return NULL;
+ req = kzalloc(sizeof *req, gfp_flags);
if (!req)
- return 0;
+ return NULL;
- memset(req, 0, sizeof *req);
req->req.dma = DMA_ADDR_INVALID;
INIT_LIST_HEAD(&req->queue);
return &req->req;
#if defined(CONFIG_X86)
#define USE_KMALLOC
-#elif defined(CONFIG_MIPS) && !defined(CONFIG_NONCOHERENT_IO)
+#elif defined(CONFIG_MIPS) && !defined(CONFIG_DMA_NONCOHERENT)
#define USE_KMALLOC
#elif defined(CONFIG_PPC) && !defined(CONFIG_NOT_COHERENT_CACHE)
*/
static void *
goku_alloc_buffer(struct usb_ep *_ep, unsigned bytes,
- dma_addr_t *dma, int gfp_flags)
+ dma_addr_t *dma, gfp_t gfp_flags)
{
void *retval;
struct goku_ep *ep;
ep = container_of(_ep, struct goku_ep, ep);
if (!_ep)
- return 0;
+ return NULL;
*dma = DMA_ADDR_INVALID;
#if defined(USE_KMALLOC)
/*-------------------------------------------------------------------------*/
static inline int
-write_packet(u32 *fifo, u8 *buf, struct goku_request *req, unsigned max)
+write_packet(u32 __iomem *fifo, u8 *buf, struct goku_request *req, unsigned max)
{
unsigned length, count;
static int read_fifo(struct goku_ep *ep, struct goku_request *req)
{
- struct goku_udc_regs *regs;
- u32 size, set;
- u8 *buf;
- unsigned bufferspace, is_short, dbuff;
+ struct goku_udc_regs __iomem *regs;
+ u32 size, set;
+ u8 *buf;
+ unsigned bufferspace, is_short, dbuff;
regs = ep->dev->regs;
top:
}
static inline void
-pio_irq_enable(struct goku_udc *dev, struct goku_udc_regs *regs, int epnum)
+pio_irq_enable(struct goku_udc *dev,
+ struct goku_udc_regs __iomem *regs, int epnum)
{
dev->int_enable |= INT_EPxDATASET (epnum);
writel(dev->int_enable, ®s->int_enable);
}
static inline void
-pio_irq_disable(struct goku_udc *dev, struct goku_udc_regs *regs, int epnum)
+pio_irq_disable(struct goku_udc *dev,
+ struct goku_udc_regs __iomem *regs, int epnum)
{
dev->int_enable &= ~INT_EPxDATASET (epnum);
writel(dev->int_enable, ®s->int_enable);
// return: 0 = q running, 1 = q stopped, negative = errno
static int start_dma(struct goku_ep *ep, struct goku_request *req)
{
- struct goku_udc_regs *regs = ep->dev->regs;
- u32 master;
- u32 start = req->req.dma;
- u32 end = start + req->req.length - 1;
+ struct goku_udc_regs __iomem *regs = ep->dev->regs;
+ u32 master;
+ u32 start = req->req.dma;
+ u32 end = start + req->req.length - 1;
master = readl(®s->dma_master) & MST_RW_BITS;
static void dma_advance(struct goku_udc *dev, struct goku_ep *ep)
{
- struct goku_request *req;
- struct goku_udc_regs *regs = ep->dev->regs;
- u32 master;
+ struct goku_request *req;
+ struct goku_udc_regs __iomem *regs = ep->dev->regs;
+ u32 master;
master = readl(®s->dma_master);
static void abort_dma(struct goku_ep *ep, int status)
{
- struct goku_udc_regs *regs = ep->dev->regs;
- struct goku_request *req;
- u32 curr, master;
+ struct goku_udc_regs __iomem *regs = ep->dev->regs;
+ struct goku_request *req;
+ u32 curr, master;
/* NAK future host requests, hoping the implicit delay lets the
* dma engine finish reading (or writing) its latest packet and
/*-------------------------------------------------------------------------*/
static int
-goku_queue(struct usb_ep *_ep, struct usb_request *_req, int gfp_flags)
+goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
{
struct goku_request *req;
struct goku_ep *ep;
if (unlikely(status != 0)) {
if (status > 0)
status = 0;
- req = 0;
+ req = NULL;
}
} /* else pio or dma irq handler advances the queue. */
} else if (!list_empty(&req->queue))
done(ep, req, -ECONNRESET);
else
- req = 0;
+ req = NULL;
spin_unlock_irqrestore(&dev->lock, flags);
return req ? 0 : -EOPNOTSUPP;
retval = -EAGAIN;
else if (ep->is_in && value
/* data in (either) packet buffer? */
- && (ep->dev->regs->DataSet & DATASET_AB(ep->num)))
+ && (readl(&ep->dev->regs->DataSet)
+ & DATASET_AB(ep->num)))
retval = -EAGAIN;
else if (!value)
goku_clear_halt(ep);
static int goku_fifo_status(struct usb_ep *_ep)
{
- struct goku_ep *ep;
- struct goku_udc_regs *regs;
- u32 size;
+ struct goku_ep *ep;
+ struct goku_udc_regs __iomem *regs;
+ u32 size;
if (!_ep)
return -ENODEV;
static void goku_fifo_flush(struct usb_ep *_ep)
{
- struct goku_ep *ep;
- struct goku_udc_regs *regs;
- u32 size;
+ struct goku_ep *ep;
+ struct goku_udc_regs __iomem *regs;
+ u32 size;
if (!_ep)
return;
return "(dma IN)";
}
-/* if we're trying to save space, don't bother with this proc file */
-
-#if defined(CONFIG_PROC_FS) && !defined(CONFIG_EMBEDDED)
-# define UDC_PROC_FILE
-#endif
-
-#ifdef UDC_PROC_FILE
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
static const char proc_node_name [] = "driver/udc";
udc_proc_read(char *buffer, char **start, off_t off, int count,
int *eof, void *_dev)
{
- char *buf = buffer;
- struct goku_udc *dev = _dev;
- struct goku_udc_regs *regs = dev->regs;
- char *next = buf;
- unsigned size = count;
- unsigned long flags;
- int i, t, is_usb_connected;
- u32 tmp;
+ char *buf = buffer;
+ struct goku_udc *dev = _dev;
+ struct goku_udc_regs __iomem *regs = dev->regs;
+ char *next = buf;
+ unsigned size = count;
+ unsigned long flags;
+ int i, t, is_usb_connected;
+ u32 tmp;
if (off != 0)
return 0;
return count - size;
}
-#endif /* UDC_PROC_FILE */
+#endif /* CONFIG_USB_GADGET_DEBUG_FILES */
/*-------------------------------------------------------------------------*/
ep->dev = dev;
INIT_LIST_HEAD (&ep->queue);
- ep_reset(0, ep);
+ ep_reset(NULL, ep);
}
- dev->ep[0].reg_mode = 0;
+ dev->ep[0].reg_mode = NULL;
dev->ep[0].ep.maxpacket = MAX_EP0_SIZE;
list_del_init (&dev->ep[0].ep.ep_list);
}
static void udc_reset(struct goku_udc *dev)
{
- struct goku_udc_regs *regs = dev->regs;
+ struct goku_udc_regs __iomem *regs = dev->regs;
writel(0, ®s->power_detect);
writel(0, ®s->int_enable);
static void ep0_start(struct goku_udc *dev)
{
- struct goku_udc_regs *regs = dev->regs;
- unsigned i;
+ struct goku_udc_regs __iomem *regs = dev->regs;
+ unsigned i;
VDBG(dev, "%s\n", __FUNCTION__);
return -EBUSY;
/* hook up the driver */
- driver->driver.bus = 0;
+ driver->driver.bus = NULL;
dev->driver = driver;
dev->gadget.dev.driver = &driver->driver;
retval = driver->bind(&dev->gadget);
if (retval) {
DBG(dev, "bind to driver %s --> error %d\n",
driver->driver.name, retval);
- dev->driver = 0;
- dev->gadget.dev.driver = 0;
+ dev->driver = NULL;
+ dev->gadget.dev.driver = NULL;
return retval;
}
DBG (dev, "%s\n", __FUNCTION__);
if (dev->gadget.speed == USB_SPEED_UNKNOWN)
- driver = 0;
+ driver = NULL;
/* disconnect gadget driver after quiesceing hw and the driver */
udc_reset (dev);
return -EINVAL;
spin_lock_irqsave(&dev->lock, flags);
- dev->driver = 0;
+ dev->driver = NULL;
stop_activity(dev, driver);
spin_unlock_irqrestore(&dev->lock, flags);
static void ep0_setup(struct goku_udc *dev)
{
- struct goku_udc_regs *regs = dev->regs;
- struct usb_ctrlrequest ctrl;
- int tmp;
+ struct goku_udc_regs __iomem *regs = dev->regs;
+ struct usb_ctrlrequest ctrl;
+ int tmp;
/* read SETUP packet and enter DATA stage */
ctrl.bRequestType = readl(®s->bRequestType);
ctrl.bRequest = readl(®s->bRequest);
- ctrl.wValue = (readl(®s->wValueH) << 8) | readl(®s->wValueL);
- ctrl.wIndex = (readl(®s->wIndexH) << 8) | readl(®s->wIndexL);
- ctrl.wLength = (readl(®s->wLengthH) << 8) | readl(®s->wLengthL);
+ ctrl.wValue = cpu_to_le16((readl(®s->wValueH) << 8)
+ | readl(®s->wValueL));
+ ctrl.wIndex = cpu_to_le16((readl(®s->wIndexH) << 8)
+ | readl(®s->wIndexL));
+ ctrl.wLength = cpu_to_le16((readl(®s->wLengthH) << 8)
+ | readl(®s->wLengthL));
writel(0, ®s->SetupRecv);
nuke(&dev->ep[0], 0);
case USB_REQ_CLEAR_FEATURE:
switch (ctrl.bRequestType) {
case USB_RECIP_ENDPOINT:
- tmp = ctrl.wIndex & 0x0f;
+ tmp = le16_to_cpu(ctrl.wIndex) & 0x0f;
/* active endpoint */
if (tmp > 3 || (!dev->ep[tmp].desc && tmp != 0))
goto stall;
- if (ctrl.wIndex & USB_DIR_IN) {
+ if (ctrl.wIndex & __constant_cpu_to_le16(
+ USB_DIR_IN)) {
if (!dev->ep[tmp].is_in)
goto stall;
} else {
if (dev->ep[tmp].is_in)
goto stall;
}
- if (ctrl.wValue != USB_ENDPOINT_HALT)
+ if (ctrl.wValue != __constant_cpu_to_le16(
+ USB_ENDPOINT_HALT))
goto stall;
if (tmp)
goku_clear_halt(&dev->ep[tmp]);
return;
case USB_RECIP_DEVICE:
/* device remote wakeup: always clear */
- if (ctrl.wValue != 1)
+ if (ctrl.wValue != __constant_cpu_to_le16(1))
goto stall;
VDBG(dev, "clear dev remote wakeup\n");
goto succeed;
#ifdef USB_TRACE
VDBG(dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
ctrl.bRequestType, ctrl.bRequest,
- ctrl.wValue, ctrl.wIndex, ctrl.wLength);
+ le16_to_cpu(ctrl.wValue), le16_to_cpu(ctrl.wIndex),
+ le16_to_cpu(ctrl.wLength));
#endif
/* hw wants to know when we're configured (or not) */
dev->req_config = (ctrl.bRequest == USB_REQ_SET_CONFIGURATION
&& ctrl.bRequestType == USB_RECIP_DEVICE);
if (unlikely(dev->req_config))
- dev->configured = (ctrl.wValue != 0);
+ dev->configured = (ctrl.wValue != __constant_cpu_to_le16(0));
/* delegate everything to the gadget driver.
* it may respond after this irq handler returns.
static irqreturn_t goku_irq(int irq, void *_dev, struct pt_regs *r)
{
- struct goku_udc *dev = _dev;
- struct goku_udc_regs *regs = dev->regs;
- struct goku_ep *ep;
- u32 stat, handled = 0;
- unsigned i, rescans = 5;
+ struct goku_udc *dev = _dev;
+ struct goku_udc_regs __iomem *regs = dev->regs;
+ struct goku_ep *ep;
+ u32 stat, handled = 0;
+ unsigned i, rescans = 5;
spin_lock(&dev->lock);
stat = 0;
handled = 1;
// FIXME have a neater way to prevent re-enumeration
- dev->driver = 0;
+ dev->driver = NULL;
goto done;
}
if (stat & INT_PWRDETECT) {
usb_gadget_unregister_driver(dev->driver);
}
-#ifdef UDC_PROC_FILE
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
remove_proc_entry(proc_node_name, NULL);
#endif
if (dev->regs)
pci_disable_device(pdev);
device_unregister(&dev->gadget.dev);
- pci_set_drvdata(pdev, 0);
- dev->regs = 0;
- the_controller = 0;
+ pci_set_drvdata(pdev, NULL);
+ dev->regs = NULL;
+ the_controller = NULL;
INFO(dev, "unbind\n");
}
static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
- struct goku_udc *dev = 0;
+ struct goku_udc *dev = NULL;
unsigned long resource, len;
- void *base = 0;
+ void __iomem *base = NULL;
int retval;
char buf [8], *bufp;
retval = -EFAULT;
goto done;
}
- dev->regs = (struct goku_udc_regs *) base;
+ dev->regs = (struct goku_udc_regs __iomem *) base;
pci_set_drvdata(pdev, dev);
INFO(dev, "%s\n", driver_desc);
pci_set_master(pdev);
-#ifdef UDC_PROC_FILE
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev);
#endif
static int __init init (void)
{
- return pci_module_init (&goku_pci_driver);
+ return pci_register_driver (&goku_pci_driver);
}
module_init (init);
git://git.onelab.eu / linux-2.6.git / blobdiff