if (ep->dma && (max % 4) != 0 && use_dma_chaining) {
DEBUG (ep->dev, "%s, no dma for maxpacket %d\n",
ep->ep.name, ep->ep.maxpacket);
- ep->dma = 0;
+ ep->dma = NULL;
}
/* set type, direction, address; reset fifo counters */
{
u32 tmp;
- ep->desc = 0;
+ ep->desc = NULL;
INIT_LIST_HEAD (&ep->queue);
ep->ep.maxpacket = ~0;
struct net2280_request *req;
if (!_ep)
- return 0;
+ return NULL;
ep = container_of (_ep, struct net2280_ep, ep);
req = kmalloc (sizeof *req, gfp_flags);
if (!req)
- return 0;
+ return NULL;
memset (req, 0, sizeof *req);
req->req.dma = DMA_ADDR_INVALID;
&req->td_dma);
if (!td) {
kfree (req);
- return 0;
+ return NULL;
}
td->dmacount = 0; /* not VALID */
td->dmaaddr = __constant_cpu_to_le32 (DMA_ADDR_INVALID);
ep = container_of (_ep, struct net2280_ep, ep);
if (!_ep)
- return 0;
+ return NULL;
*dma = DMA_ADDR_INVALID;
#if defined(USE_KMALLOC)
total = req->length - req->actual;
} else {
total = 0;
- buf = 0;
+ buf = NULL;
}
/* write just one packet at a time */
if (ep->num == 0)
allow_status (ep);
/* don't queue it */
- req = 0;
+ req = NULL;
} else
s = readl (&ep->regs->ep_stat);
}
* OUT: was "usb-short", we must restart.
*/
if (ep->is_in && !req->valid) {
- struct net2280_request *entry, *prev = 0;
+ struct net2280_request *entry, *prev = NULL;
int reqmode, done = 0;
DEBUG (ep->dev, "%s dma hiccup td %p\n", ep->ep.name, req->td);
DEBUG (ep->dev, "unlink (%s) pio\n", _ep->name);
done (ep, req, -ECONNRESET);
}
- req = 0;
+ req = NULL;
/* patch up hardware chaining data */
} else if (ep->dma && use_dma_chaining) {
, &dev->usb->stdrsp);
writel ( (1 << USB_ROOT_PORT_WAKEUP_ENABLE)
| (1 << SELF_POWERED_USB_DEVICE)
+ /* erratum 0102 workaround */
+ | ((dev->chiprev == 0100) ? 0 : 1) << SUSPEND_IMMEDIATELY
| (1 << REMOTE_WAKEUP_SUPPORT)
| (1 << USB_DETECT_ENABLE)
| (1 << SELF_POWERED_STATUS)
| (1 << PCI_RETRY_ABORT_INTERRUPT_ENABLE)
| (1 << VBUS_INTERRUPT_ENABLE)
| (1 << ROOT_PORT_RESET_INTERRUPT_ENABLE)
+ | (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE)
, &dev->regs->pciirqenb1);
/* don't leave any writes posted */
dev->ep [i].irqs = 0;
/* 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) {
DEBUG (dev, "bind to driver %s --> %d\n",
driver->driver.name, retval);
- dev->driver = 0;
- dev->gadget.dev.driver = 0;
+ dev->driver = NULL;
+ dev->gadget.dev.driver = NULL;
return retval;
}
/* don't disconnect if it's not connected */
if (dev->gadget.speed == USB_SPEED_UNKNOWN)
- driver = 0;
+ driver = NULL;
/* stop hardware; prevent new request submissions;
* and kill any outstanding requests.
spin_unlock_irqrestore (&dev->lock, flags);
driver->unbind (&dev->gadget);
- dev->gadget.dev.driver = 0;
- dev->driver = 0;
+ dev->gadget.dev.driver = NULL;
+ dev->driver = NULL;
net2280_led_active (dev, 0);
device_remove_file (&dev->pdev->dev, &dev_attr_function);
req = list_entry (ep->queue.next,
struct net2280_request, queue);
else
- req = 0;
+ req = NULL;
/* ack all, and handle what we care about */
t = readl (&ep->regs->ep_stat);
set_halt (ep);
mode = 2;
} else if (!req && ep->stopped)
- write_fifo (ep, 0);
+ write_fifo (ep, NULL);
}
} else {
/* status; stop NAKing */
ep->stopped = 1;
if (req)
done (ep, req, -EOVERFLOW);
- req = 0;
+ req = NULL;
}
}
}
scan_dma_completions (ep);
if (unlikely (list_empty (&ep->queue)
|| ep->out_overflow)) {
- req = 0;
+ req = NULL;
break;
}
req = list_entry (ep->queue.next,
count &= DMA_BYTE_COUNT_MASK;
if (readl (&ep->dma->dmadesc)
!= req->td_dma)
- req = 0;
+ req = NULL;
break;
}
udelay(1);
if (ep->num == 0) {
/* wait for control status */
if (mode != 2)
- req = 0;
+ req = NULL;
} else if (!req->req.zero || len != ep->ep.maxpacket)
mode = 2;
}
*/
if (!ep->stopped)
allow_status (ep);
- req = 0;
+ req = NULL;
} else {
if (!list_empty (&ep->queue) && !ep->stopped)
req = list_entry (ep->queue.next,
struct net2280_request, queue);
else
- req = 0;
+ req = NULL;
if (req && !ep->is_in)
stop_out_naking (ep);
}
if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f))
return ep;
}
- return 0;
+ return NULL;
}
static void handle_stat0_irqs (struct net2280 *dev, u32 stat)
return;
}
- /* NOTE: we don't actually suspend the hardware; that starts to
- * interact with PCI power management, and needs something like a
- * controller->suspend() call to clear SUSPEND_REQUEST_INTERRUPT.
- * we shouldn't see resume interrupts.
- * for rev 0100, this also avoids erratum 0102.
+ /* NOTE: chip stays in PCI D0 state for now, but it could
+ * enter D1 to save more power
*/
tmp = (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT);
if (stat & tmp) {
- if (dev->driver->suspend)
- dev->driver->suspend (&dev->gadget);
+ writel (tmp, &dev->regs->irqstat1);
+ if (stat & (1 << SUSPEND_REQUEST_INTERRUPT)) {
+ if (dev->driver->suspend)
+ dev->driver->suspend (&dev->gadget);
+ /* we use SUSPEND_IMMEDIATELY */
+ stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT);
+ } else {
+ if (dev->driver->resume)
+ dev->driver->resume (&dev->gadget);
+ /* at high speed, note erratum 0133 */
+ }
stat &= ~tmp;
}
- stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT);
/* clear any other status/irqs */
if (stat)
/* some status we can just ignore */
stat &= ~((1 << CONTROL_STATUS_INTERRUPT)
+ | (1 << SUSPEND_REQUEST_INTERRUPT)
| (1 << RESUME_INTERRUPT)
| (1 << SOF_INTERRUPT));
if (!stat)
pci_disable_device (pdev);
device_unregister (&dev->gadget.dev);
device_remove_file (&pdev->dev, &dev_attr_registers);
- pci_set_drvdata (pdev, 0);
+ pci_set_drvdata (pdev, NULL);
INFO (dev, "unbind\n");
- the_controller = 0;
+ the_controller = NULL;
}
/* wrap this driver around the specified device, but
{
struct net2280 *dev;
unsigned long resource, len;
- void *base = 0;
+ void *base = NULL;
int retval, i;
char buf [8], *bufp;
git://git.onelab.eu / linux-2.6.git / blobdiff