diff options
Diffstat (limited to 'packages/linux/linux-rp-2.6.19/tmio-ohci-r6.patch')
| -rw-r--r-- | packages/linux/linux-rp-2.6.19/tmio-ohci-r6.patch | 929 |
1 files changed, 929 insertions, 0 deletions
diff --git a/packages/linux/linux-rp-2.6.19/tmio-ohci-r6.patch b/packages/linux/linux-rp-2.6.19/tmio-ohci-r6.patch new file mode 100644 index 0000000000..9fdd2962c9 --- /dev/null +++ b/packages/linux/linux-rp-2.6.19/tmio-ohci-r6.patch @@ -0,0 +1,929 @@ + + drivers/usb/host/Kconfig | 1 + drivers/usb/host/ohci-hcd.c | 1 + drivers/usb/host/ohci-tmio.c | 894 +++++++++++++++++++++++++++++++++++++++++++ + 3 files changed, 896 insertions(+) + +Index: git/drivers/usb/host/ohci-tmio.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ git/drivers/usb/host/ohci-tmio.c 2006-11-07 21:48:33.000000000 +0000 +@@ -0,0 +1,894 @@ ++/* ++ * OHCI HCD (Host Controller Driver) for USB. ++ * ++ * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at> ++ * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net> ++ * (C) Copyright 2002 Hewlett-Packard Company ++ * ++ * Bus glue for Toshiba Mobile IO (TMIO) Controller's OHCI core ++ * (C) Copyright 2005 Chris Humbert <mahadri-usb@drigon.com> ++ * ++ * This is known to work with the following variants: ++ * TC6393XB revision 3 (32kB SRAM) ++ * ++ * The TMIO's OHCI core DMAs through a small internal buffer that ++ * is directly addressable by the CPU. dma_declare_coherent_memory ++ * and DMA bounce buffers allow the higher-level OHCI host driver to ++ * work. However, the dma API doesn't handle dma mapping failures ++ * well (dma_sg_map() is a prime example), so it is unusable. ++ * ++ * This HC pretends be a PIO-ish controller and uses the kernel's ++ * generic allocator for the entire SRAM. Using the USB core's ++ * usb_operations, we provide hcd_buffer_alloc/free. Using the OHCI's ++ * ohci_ops, we provide memory management for OHCI's TDs and EDs. We ++ * internally queue a URB's TDs until enough dma memory is available ++ * to enqueue them with the HC. ++ * ++ * Written from sparse documentation from Toshiba and Sharp's driver ++ * for the 2.4 kernel, ++ * usb-ohci-tc6393.c (C) Copyright 2004 Lineo Solutions, Inc. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++ ++#include <linux/fs.h> ++#include <linux/mount.h> ++#include <linux/pagemap.h> ++#include <linux/init.h> ++#include <linux/namei.h> ++#include <linux/sched.h> ++ ++#include <linux/genalloc.h> ++#include <asm/dma-mapping.h> /* for consistent_sync() */ ++#include <asm/hardware/tmio.h> ++ ++/*-------------------------------------------------------------------------*/ ++ ++/* ++ * USB Host Controller Configuration Register ++ */ ++struct tmio_uhccr { ++ u8 x00[8]; ++ u8 revid; /* 0x08 Revision ID */ ++ u8 x01[7]; ++ u16 basel; /* 0x10 USB Control Register Base Address Low */ ++ u16 baseh; /* 0x12 USB Control Register Base Address High */ ++ u8 x02[0x2c]; ++ u8 ilme; /* 0x40 Internal Local Memory Enable */ ++ u8 x03[0x0b]; ++ u16 pm; /* 0x4c Power Management */ ++ u8 x04[2]; ++ u8 intc; /* 0x50 INT Control */ ++ u8 x05[3]; ++ u16 lmw1l; /* 0x54 Local Memory Window 1 LMADRS Low */ ++ u16 lmw1h; /* 0x56 Local Memory Window 1 LMADRS High */ ++ u16 lmw1bl; /* 0x58 Local Memory Window 1 Base Address Low */ ++ u16 lmw1bh; /* 0x5A Local Memory Window 1 Base Address High */ ++ u16 lmw2l; /* 0x5C Local Memory Window 2 LMADRS Low */ ++ u16 lmw2h; /* 0x5E Local Memory Window 2 LMADRS High */ ++ u16 lmw2bl; /* 0x60 Local Memory Window 2 Base Address Low */ ++ u16 lmw2bh; /* 0x62 Local Memory Window 2 Base Address High */ ++ u8 x06[0x98]; ++ u8 misc; /* 0xFC MISC */ ++ u8 x07[3]; ++} __attribute__ ((packed)); ++ ++union tmio_uhccr_pm { ++ u16 raw; ++struct { ++ unsigned gcken:1; /* D0 */ ++ unsigned ckrnen:1; /* D1 */ ++ unsigned uspw1:1; /* D2 USB Port 1 Power Disable */ ++ unsigned uspw2:1; /* D3 USB Port 2 Power Disable */ ++ unsigned x00:4; ++ unsigned pmee:1; /* D8 */ ++ unsigned x01:6; ++ unsigned pmes:1; /* D15 */ ++} __attribute__ ((packed)); ++} __attribute__ ((packed)); ++ ++/*-------------------------------------------------------------------------*/ ++ ++struct tmio_dma_pool { ++ struct device* dev; ++ unsigned int size; ++}; ++ ++struct tmio_hcd { ++ struct gen_pool* poolp; ++ struct usb_operations ops; ++ struct tmio_dma_pool td_pool; ++ struct tmio_dma_pool ed_pool; ++ ++ struct tmio_uhccr __iomem *ccr; ++ void __iomem * sram; ++ size_t sram_len; ++}; ++ ++#define hcd_to_tmio(hcd) ((struct tmio_hcd*)(hcd_to_ohci (hcd) + 1)) ++ ++struct tmio_td { ++ void* data; /* td's data buffer */ ++ void __iomem * bounce; /* dma bounce buffer */ ++ dma_addr_t dma; /* bounce buffer dma address */ ++ size_t len; /* bounce buffer length */ ++ u32 info; /* parameter for td_fill */ ++}; ++ ++struct tmio_urb { ++ int td_add; /* next index to be added */ ++ int td_queue; /* next index to be HC enqueued */ ++ ++ struct tmio_td td [0]; /* private td data */ ++}; ++ ++static inline struct tmio_urb *urb_to_turb (struct urb *urb) ++{ ++ urb_priv_t* urb_priv = urb->hcpriv; ++ return (struct tmio_urb*)(urb_priv->td + urb_priv->length); ++} ++ ++/*-------------------------------------------------------------------------*/ ++ ++/* gen_pool_alloc page allocator callback */ ++static unsigned long tmio_pool_callback(struct gen_pool *poolp) ++{ ++ return 0; ++} ++ ++static inline void tmio_pool_destroy(struct tmio_hcd *tmio) ++{ ++ struct gen_pool *poolp = tmio->poolp; ++ ++ if (!poolp) ++ return; ++ if (poolp->h) ++ kfree(poolp->h); ++ kfree(poolp); ++ tmio->poolp = NULL; ++} ++ ++/*-------------------------------------------------------------------------*/ ++ ++#define BOUNDED_XYL(x,y,ylen) (((y) <= (x)) && ((x) < ((y)+(ylen)))) ++#define BOUNDED_XYY(x,y1,y2) (((y1) <= (x)) && ((x) < (y2))) ++ ++static inline dma_addr_t tmio_virt_to_dma (struct usb_hcd *hcd, void *vaddr) ++{ ++ struct resource* sram = tmio_resource_mem (hcd->self.controller); ++ struct tmio_hcd* tmio = hcd_to_tmio (hcd); ++ ++ return BOUNDED_XYL (vaddr, tmio->sram, tmio->sram_len) ++ ? sram->start + (vaddr - tmio->sram) ++ : ~0; ++} ++ ++static inline void* tmio_dma_to_virt (struct usb_hcd *hcd, dma_addr_t handle) ++{ ++ struct resource* sram = tmio_resource_mem (hcd->self.controller); ++ struct tmio_hcd* tmio = hcd_to_tmio (hcd); ++ ++ return BOUNDED_XYY (handle, sram->start, sram->end + 1) ++ ? tmio->sram + handle - sram->start ++ : NULL; ++} ++ ++/* ++ * allocate dma-able memory in the device's internal sram ++ * ++ * The generic pool allocator's minimum chunk size is 32 bytes, ++ * which is the cache line size on the PXA255, so we don't need ++ * to do anything special for smaller requests. ++ */ ++static inline void *tmio_dma_alloc (struct device *dev, size_t size, ++ dma_addr_t *handle, gfp_t mem_flags) ++{ ++ struct usb_hcd* hcd = dev_get_drvdata (dev); ++ struct tmio_hcd* tmio = hcd_to_tmio (hcd); ++ void* virt = (void*) gen_pool_alloc (tmio->poolp, size); ++ ++ return (*handle = tmio_virt_to_dma (hcd, virt)) == ~0 ? NULL : virt; ++} ++ ++static inline void tmio_dma_free (struct device *dev, size_t size, ++ void *cpu_addr, dma_addr_t handle) ++{ ++ struct usb_hcd* hcd = dev_get_drvdata (dev); ++ struct tmio_hcd* tmio = hcd_to_tmio (hcd); ++ dma_addr_t dma = tmio_virt_to_dma (hcd, cpu_addr); ++ ++ if (unlikely (dma == ~0)) { ++ dev_err (dev, "trying to free bad address 0x%p\n", cpu_addr); ++ return; ++ } ++ ++ if (unlikely (handle != dma)) ++ dev_err (dev, "dma address mismatch for 0x%p: %08x != %08x\n", ++ cpu_addr, handle, dma); ++ ++ gen_pool_free (tmio->poolp, (unsigned long) cpu_addr, size); ++} ++ ++/*-------------------------------------------------------------------------*/ ++ ++static void *tmio_dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags, ++ dma_addr_t *handle) ++{ ++ struct tmio_dma_pool *tdp = (struct tmio_dma_pool*) pool; ++ return tmio_dma_alloc (tdp->dev, tdp->size, handle, mem_flags); ++} ++ ++static void ++tmio_dma_pool_free (struct dma_pool *pool, void *vaddr, dma_addr_t addr) ++{ ++ struct tmio_dma_pool *tdp = (struct tmio_dma_pool*) pool; ++ return tmio_dma_free (tdp->dev, tdp->size, vaddr, addr); ++} ++ ++static void *tmio_buffer_alloc (struct usb_bus *bus, size_t size, ++ gfp_t mem_flags, dma_addr_t *dma) ++{ ++ return tmio_dma_alloc (bus->controller, size, dma, mem_flags); ++} ++ ++static void tmio_buffer_free (struct usb_bus *bus, size_t size, ++ void *addr, dma_addr_t dma) ++{ ++ tmio_dma_free (bus->controller, size, addr, dma); ++} ++ ++/*-------------------------------------------------------------------------*/ ++ ++static void tmio_hc_stop (struct usb_hcd *hcd) ++{ ++ struct device* dev = hcd->self.controller; ++ struct tmio_device* tdev = dev_to_tdev (dev); ++ struct tmio_hcd* tmio = hcd_to_tmio (hcd); ++ struct tmio_uhccr __iomem* ccr = tmio->ccr; ++ union tmio_uhccr_pm pm = {0}; ++ ++ pm.gcken = 1; ++ pm.ckrnen = 1; ++ pm.uspw1 = 1; ++ pm.uspw2 = 1; ++ ++ iowrite8 (0, &ccr->intc); ++ iowrite8 (0, &ccr->ilme); ++ iowrite16(0, &ccr->basel); ++ iowrite16(0, &ccr->baseh); ++ iowrite16(pm.raw, &ccr->pm); ++ ++ tdev->ops->function (dev, 0); ++ tdev->ops->clock (dev, 0); ++} ++ ++static void tmio_hc_start (struct usb_hcd *hcd) ++{ ++ struct device* dev = hcd->self.controller; ++ struct tmio_device* tdev = dev_to_tdev (dev); ++ struct tmio_hcd* tmio = hcd_to_tmio (hcd); ++ struct tmio_uhccr __iomem* ccr = tmio->ccr; ++ union tmio_uhccr_pm pm = {0}; ++ ++ pm.pmes = 1; ++ pm.pmee = 1; ++ pm.ckrnen = 1; ++ pm.gcken = 1; ++ ++ tdev->ops->clock (dev, 1); ++ tdev->ops->function (dev, 1); ++ ++ iowrite16(pm.raw, &ccr->pm); ++ iowrite16(hcd->rsrc_start, &ccr->basel); ++ iowrite16(hcd->rsrc_start >> 16, &ccr->baseh); ++ iowrite8 (1, &ccr->ilme); ++ iowrite8 (2, &ccr->intc); ++ ++ consistent_sync (tmio->sram, tmio->sram_len, DMA_BIDIRECTIONAL); ++ ++ dev_info (dev, "revision %d @ 0x%08llx, irq %d\n", ++ ioread8 (&ccr->revid), hcd->rsrc_start, hcd->irq); ++} ++ ++static void tmio_stop (struct usb_hcd *hcd) ++{ ++ struct ohci_hcd* ohci = hcd_to_ohci (hcd); ++ ++ /* NULL these so ohci_stop() doesn't try to free them */ ++ ohci->hcca = NULL; ++ ohci->td_cache = NULL; ++ ohci->ed_cache = NULL; ++ ++ ohci_stop (hcd); ++ tmio_hc_stop (hcd); ++ tmio_pool_destroy (hcd_to_tmio (hcd)); ++ ++ /* We don't free the hcca because tmio_hc_stop() turns off ++ * the sram and the memory allocation data is destroyed. */ ++} ++ ++static int tmio_start (struct usb_hcd *hcd) ++{ ++ struct device* dev = hcd->self.controller; ++ struct ohci_hcd* ohci = hcd_to_ohci (hcd); ++ struct tmio_hcd* tmio = hcd_to_tmio (hcd); ++ int retval; ++ ++ tmio_hc_start (hcd); ++ ++ tmio->poolp = gen_pool_create(0, fls(tmio->sram_len) - 1, ++ tmio_pool_callback, 0); ++ if (!tmio->poolp) { ++ retval = -ENOMEM; ++ goto err_gen_pool_create; ++ } ++ ++ gen_pool_free (tmio->poolp, (unsigned long)(tmio->sram), ++ tmio->sram_len); ++ ++ ohci->hcca = tmio_dma_alloc (dev, sizeof *ohci->hcca, ++ &ohci->hcca_dma, GFP_KERNEL); ++ if (!ohci->hcca) { ++ retval = -ENOMEM; ++ goto err_hcca_alloc; ++ } ++ ++ /* for our dma_pool_alloc/free hooks */ ++ ohci->td_cache = (struct dma_pool*) &tmio->td_pool; ++ ohci->ed_cache = (struct dma_pool*) &tmio->ed_pool; ++ ++ if ((retval = ohci_init (ohci)) < 0) ++ goto err_ohci_init; ++ ++ if ((retval = ohci_run (ohci)) < 0) ++ goto err_ohci_run; ++ ++ return 0; ++ ++err_ohci_run: ++ err ("can't start %s", hcd->self.bus_name); ++err_ohci_init: ++err_hcca_alloc: ++err_gen_pool_create: ++ tmio_stop (hcd); ++ return retval; ++} ++ ++/*-------------------------------------------------------------------------*/ ++ ++static inline void *tmio_urb_dma_to_virt(struct urb *urb, dma_addr_t dma) ++{ ++ if (BOUNDED_XYL(dma, urb->transfer_dma, urb->transfer_buffer_length)) ++ return urb->transfer_buffer + dma - urb->transfer_dma; ++ ++ if (BOUNDED_XYL(dma, urb->setup_dma, sizeof (struct usb_ctrlrequest))) ++ return urb->setup_packet + dma - urb->setup_dma; ++ ++ return NULL; ++} ++ ++static struct tmio_td* tmio_td_find (struct td *td, int *index) ++{ ++ struct urb* urb = td->urb; ++ urb_priv_t* urb_priv = urb->hcpriv; ++ struct tmio_urb* turb = urb_to_turb (urb); ++ int i; ++ ++ for (i=0; i < urb_priv->length; i++) ++ if (urb_priv->td[i] == td) { ++ *index = i; ++ return turb->td + i; ++ } ++ ++ return NULL; ++} ++ ++/* ++ * map the td's data to dma-able memory ++ * ++ * if this td transfers data, ++ * sets tmtd->data to the urb's data buffer ++ * sets tmtd->dma to dma-able memory ++ * sets tmtd->bounce to non-NULL if a bounce buffer is allocated ++ * copies the urb's data buffer to the bounce buffer if necessary ++ */ ++static int tmio_td_dma_map (struct ohci_hcd *ohci, struct urb *urb, ++ struct tmio_td *tmtd, int idx) ++{ ++ struct usb_hcd* hcd = ohci_to_hcd (ohci); ++ struct device* dev = hcd->self.controller; ++ dma_addr_t dma; ++ ++ if (!tmtd->len) ++ return 0; ++ ++ if (tmio_dma_to_virt (hcd, tmtd->dma)) ++ return 0; ++ ++ tmtd->data = tmio_urb_dma_to_virt (urb, tmtd->dma); ++ if (unlikely (!tmtd->data)) { ++ dev_err (dev, "TD has bad dma address 0x%08x\n", tmtd->dma); ++ return 0; ++ } ++ ++ tmtd->bounce = tmio_dma_alloc (dev, tmtd->len, &dma, GFP_ATOMIC); ++ if (!tmtd->bounce) ++ return -ENOMEM; ++ ++ if ((usb_pipecontrol (urb->pipe) && !idx) || usb_pipeout (urb->pipe)) { ++ consistent_sync (tmtd->bounce, tmtd->len, DMA_TO_DEVICE); ++ memcpy (tmtd->bounce, tmtd->data, tmtd->len); ++ } else ++ consistent_sync (tmtd->bounce, tmtd->len, DMA_FROM_DEVICE); ++ ++ tmtd->dma = dma; ++ return 0; ++} ++ ++/* ++ * unmaps the td's data from dma-able memory ++ * ++ * if a bounce buffer has been allocated, ++ * copy the bounce buffer to the urb's data buffer if necessary ++ * free the bounce buffer ++ */ ++static void tmio_td_dma_unmap (struct ohci_hcd *ohci, struct td *td) ++{ ++ struct device* dev = (ohci_to_hcd (ohci))->self.controller; ++ struct urb* urb = td->urb; ++ int idx; ++ struct tmio_td* tmtd = tmio_td_find (td, &idx); ++ ++ if (!tmtd->bounce) ++ return; ++ ++ if (usb_pipein (urb->pipe) && (usb_pipecontrol (urb->pipe) ? idx : 1)) { ++ memcpy (tmtd->data, tmtd->bounce, tmtd->len); ++ consistent_sync (tmtd->data, tmtd->len, DMA_TO_DEVICE); ++ } ++ ++ tmio_dma_free (dev, tmtd->len, tmtd->bounce, tmtd->dma); ++} ++ ++static int tmio_urb_runqueue (struct ohci_hcd *ohci, struct urb *urb) ++{ ++ struct tmio_urb* turb = urb_to_turb (urb); ++ urb_priv_t* urb_priv= urb->hcpriv; ++ int start = turb->td_queue; ++ int retval = 0; ++ int i; ++ ++ for (i = start; i < turb->td_add; i = ++turb->td_queue) { ++ struct tmio_td *tmtd = turb->td + i; ++ ++ if ((retval = tmio_td_dma_map (ohci, urb, tmtd, i))) ++ break; ++ ++ td_fill (ohci, tmtd->info, tmtd->dma, tmtd->len, urb, i); ++ } ++ ++ if (i <= start) ++ return retval; ++ ++ /* kickstart the appropriate list */ ++ wmb (); ++ switch (urb_priv->ed->type) { ++ case PIPE_BULK: ++ ohci_writel (ohci, OHCI_BLF, &ohci->regs->cmdstatus); ++ break; ++ case PIPE_CONTROL: ++ ohci_writel (ohci, OHCI_CLF, &ohci->regs->cmdstatus); ++ break; ++ } ++ ++ return retval; ++} ++ ++/* ++ * This needs to be called with ohci->lock held so the pending urb list ++ * isn't modified. ++ */ ++static int tmio_ohci_runqueue (struct ohci_hcd *ohci) ++{ ++ urb_priv_t* priv; ++ int retval = 0; ++ ++ list_for_each_entry_reverse (priv, &ohci->pending, pending) ++ if ((retval = tmio_urb_runqueue (ohci, priv->td[0]->urb))) ++ return retval; ++ ++ return retval; ++} ++ ++static void tmio_td_fill (struct ohci_hcd *ohci, u32 info, ++ dma_addr_t data, int len, struct urb *urb, int index) ++{ ++ struct tmio_urb* turb = urb_to_turb (urb); ++ struct tmio_td* tmtd = turb->td + index; ++ ++ tmtd->data = NULL; ++ tmtd->bounce = NULL; ++ tmtd->dma = data; ++ tmtd->len = len; ++ tmtd->info = info; ++ turb->td_add = index + 1; ++} ++ ++static void ++tmio_td_done (struct ohci_hcd *ohci, struct urb *urb, struct td *td) ++{ ++ tmio_td_dma_unmap (ohci, td); ++ td_done (ohci, urb, td); ++} ++ ++const static struct ohci_ops tmio_ops = { ++ .dma_pool_alloc = tmio_dma_pool_alloc, ++ .dma_pool_free = tmio_dma_pool_free, ++ .td_fill = tmio_td_fill, ++ .td_done = tmio_td_done, ++}; ++ ++/*-------------------------------------------------------------------------*/ ++ ++static irqreturn_t tmio_irq (struct usb_hcd *hcd, struct pt_regs *ptregs) ++{ ++ irqreturn_t retval = ohci_irq (hcd, ptregs); ++ ++ if (retval == IRQ_HANDLED) { ++ struct ohci_hcd *ohci = hcd_to_ohci (hcd); ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ohci->lock, flags); ++ tmio_ohci_runqueue (ohci); ++ spin_unlock_irqrestore (&ohci->lock, flags); ++ } ++ ++ return retval; ++} ++ ++/* ++ * This is ohci_urb_enqueue with: ++ * dma address sanitization for tmio_urb_dma_to_virt() ++ * allocate extra space in urb_priv for our private data ++ * initialize urb_priv->td[0]->urb for tmio_ohci_runqueue() ++ * call tmio_ohci_runqueue() after submitting TDs ++ */ ++static int tmio_urb_enqueue ( ++ struct usb_hcd *hcd, ++ struct usb_host_endpoint *ep, ++ struct urb *urb, ++ gfp_t mem_flags ++) { ++ struct ohci_hcd *ohci = hcd_to_ohci (hcd); ++ struct ed *ed; ++ urb_priv_t *urb_priv; ++ unsigned int pipe = urb->pipe; ++ int i, size = 0; ++ unsigned long flags; ++ int retval = 0; ++ ++#ifdef OHCI_VERBOSE_DEBUG ++ urb_print (urb, "SUB", usb_pipein (pipe)); ++#endif ++ ++ /* make sure we can convert dma offsets back to virtual addresses */ ++ if (!tmio_dma_to_virt (hcd, urb->setup_dma)) ++ urb->setup_dma = 0; ++ ++ if (!tmio_dma_to_virt (hcd, urb->transfer_dma)) ++ urb->transfer_dma = sizeof (struct usb_ctrlrequest); ++ ++ /* every endpoint has a ed, locate and maybe (re)initialize it */ ++ if (! (ed = ed_get (ohci, ep, urb->dev, pipe, urb->interval))) ++ return -ENOMEM; ++ ++ /* for the private part of the URB we need the number of TDs (size) */ ++ switch (ed->type) { ++ case PIPE_CONTROL: ++ /* td_submit_urb() doesn't yet handle these */ ++ if (urb->transfer_buffer_length > 4096) ++ return -EMSGSIZE; ++ ++ /* 1 TD for setup, 1 for ACK, plus ... */ ++ size = 2; ++ /* FALLTHROUGH */ ++ // case PIPE_INTERRUPT: ++ // case PIPE_BULK: ++ default: ++ /* one TD for every 4096 Bytes (can be upto 8K) */ ++ size += urb->transfer_buffer_length / 4096; ++ /* ... and for any remaining bytes ... */ ++ if ((urb->transfer_buffer_length % 4096) != 0) ++ size++; ++ /* ... and maybe a zero length packet to wrap it up */ ++ if (size == 0) ++ size++; ++ else if ((urb->transfer_flags & URB_ZERO_PACKET) != 0 ++ && (urb->transfer_buffer_length ++ % usb_maxpacket (urb->dev, pipe, ++ usb_pipeout (pipe))) == 0) ++ size++; ++ break; ++ case PIPE_ISOCHRONOUS: /* number of packets from URB */ ++ size = urb->number_of_packets; ++ break; ++ } ++ ++ /* allocate the private part of the URB */ ++ urb_priv = kzalloc (sizeof (urb_priv_t) ++ + size * sizeof (struct td*) ++ + sizeof (struct tmio_urb) ++ + size * sizeof (struct tmio_td), ++ mem_flags); ++ if (!urb_priv) ++ return -ENOMEM; ++ INIT_LIST_HEAD (&urb_priv->pending); ++ urb_priv->length = size; ++ urb_priv->ed = ed; ++ ++ /* allocate the TDs (deferring hash chain updates) */ ++ for (i = 0; i < size; i++) { ++ urb_priv->td [i] = td_alloc (ohci, mem_flags); ++ if (!urb_priv->td [i]) { ++ urb_priv->length = i; ++ urb_free_priv (ohci, urb_priv); ++ return -ENOMEM; ++ } ++ urb_priv->td [i]->urb = urb; ++ } ++ ++ spin_lock_irqsave (&ohci->lock, flags); ++ ++ /* don't submit to a dead HC */ ++ if (!HC_IS_RUNNING(hcd->state)) { ++ retval = -ENODEV; ++ goto fail; ++ } ++ ++ /* in case of unlink-during-submit */ ++ spin_lock (&urb->lock); ++ if (urb->status != -EINPROGRESS) { ++ spin_unlock (&urb->lock); ++ urb->hcpriv = urb_priv; ++ finish_urb (ohci, urb, NULL); ++ retval = 0; ++ goto fail; ++ } ++ ++ /* schedule the ed if needed */ ++ if (ed->state == ED_IDLE) { ++ retval = ed_schedule (ohci, ed); ++ if (retval < 0) ++ goto fail0; ++ if (ed->type == PIPE_ISOCHRONOUS) { ++ u16 frame = ohci_frame_no(ohci); ++ ++ /* delay a few frames before the first TD */ ++ frame += max_t (u16, 8, ed->interval); ++ frame &= ~(ed->interval - 1); ++ frame |= ed->branch; ++ urb->start_frame = frame; ++ ++ /* yes, only URB_ISO_ASAP is supported, and ++ * urb->start_frame is never used as input. ++ */ ++ } ++ } else if (ed->type == PIPE_ISOCHRONOUS) ++ urb->start_frame = ed->last_iso + ed->interval; ++ ++ /* fill the TDs and link them to the ed; and ++ * enable that part of the schedule, if needed ++ * and update count of queued periodic urbs ++ */ ++ urb->hcpriv = urb_priv; ++ td_submit_urb (ohci, urb); ++ tmio_ohci_runqueue (ohci); ++ ++fail0: ++ spin_unlock (&urb->lock); ++fail: ++ if (retval) ++ urb_free_priv (ohci, urb_priv); ++ spin_unlock_irqrestore (&ohci->lock, flags); ++ return retval; ++} ++ ++static const struct hc_driver tmio_hc_driver = { ++ .description = hcd_name, ++ .product_desc = "TMIO OHCI USB Host Controller", ++ .hcd_priv_size = sizeof (struct ohci_hcd) ++ + sizeof (struct tmio_hcd), ++ ++ /* generic hardware linkage */ ++ .irq = tmio_irq, ++ .flags = HCD_USB11 | HCD_MEMORY, ++ ++ /* basic lifecycle operations */ ++ .start = tmio_start, ++ .stop = tmio_stop, ++ ++ /* managing i/o requests and associated device resources */ ++ .urb_enqueue = tmio_urb_enqueue, ++ .urb_dequeue = ohci_urb_dequeue, ++ .endpoint_disable = ohci_endpoint_disable, ++ ++ /* scheduling support */ ++ .get_frame_number = ohci_get_frame, ++ ++ /* root hub support */ ++ .hub_status_data = ohci_hub_status_data, ++ .hub_control = ohci_hub_control, ++#ifdef CONFIG_PM ++ .bus_suspend = ohci_bus_suspend, ++ .bus_resume = ohci_bus_resume, ++#endif ++ .start_port_reset = ohci_start_port_reset, ++}; ++ ++/*-------------------------------------------------------------------------*/ ++ ++/* configure so an HC device and id are always provided */ ++/* always called with process context; sleeping is OK */ ++ ++/** ++ * tmio_probe - initialize TMIO-based HCDs ++ * Context: !in_interrupt() ++ * ++ * Allocates basic resources for this USB host controller, and ++ * then invokes the start() method for the HCD associated with it ++ * through the hotplug entry's driver_data. ++ */ ++static int tmio_probe (struct device *dev) ++{ ++ struct tmio_device* tdev = dev_to_tdev (dev); ++ struct resource* config = tmio_resource_config (dev); ++ struct resource* regs = tmio_resource_control (dev); ++ struct resource* sram = tmio_resource_mem (dev); ++ struct resource* irq = tmio_resource_irq (dev); ++ struct usb_operations* ops; ++ struct tmio_hcd* tmio; ++ struct ohci_hcd* ohci; ++ struct usb_hcd* hcd; ++ int retval; ++ ++ if (usb_disabled ()) ++ return -ENODEV; ++ ++ if (dev->dma_mask || dev->coherent_dma_mask) { ++ dev_err (dev, "DMA not supported\n"); ++ return -ENODEV; ++ } ++ ++ hcd = usb_create_hcd (&tmio_hc_driver, dev, dev->bus_id); ++ if (!hcd) { ++ retval = -ENOMEM; ++ goto err_create_hcd; ++ } ++ ++ tmio = hcd_to_tmio (hcd); ++ tmio->td_pool.dev = dev; ++ tmio->ed_pool.dev = dev; ++ tmio->td_pool.size = sizeof (struct td); ++ tmio->ed_pool.size = sizeof (struct ed); ++ ohci = hcd_to_ohci (hcd); ++ ohci_hcd_init (ohci); ++ ohci->ops = &tmio_ops; ++ ++ retval = request_resource (tdev->iomem, config); ++ if (retval) ++ goto err_request_config_resource; ++ ++ retval = request_resource (tdev->iomem, regs); ++ if (retval) ++ goto err_request_regs_resource; ++ ++ retval = request_resource (tdev->iomem, sram); ++ if (retval) ++ goto err_request_sram_resource; ++ ++ hcd->rsrc_start = regs->start; ++ hcd->rsrc_len = regs->end - regs->start + 1; ++ tmio->sram_len = sram->end - sram->start + 1; ++ ++ tmio->ccr = ioremap (config->start, config->end - config->start + 1); ++ if (!tmio->ccr) { ++ retval = -ENOMEM; ++ goto err_ioremap_ccr; ++ } ++ ++ hcd->regs = ioremap (hcd->rsrc_start, hcd->rsrc_len); ++ if (!hcd->regs) { ++ retval = -ENOMEM; ++ goto err_ioremap_regs; ++ } ++ ++ tmio->sram = ioremap (sram->start, tmio->sram_len); ++ if (!tmio->sram) { ++ retval = -ENOMEM; ++ goto err_ioremap_sram; ++ } ++ ++ /* drivers should use our coherent buffer allocator */ ++ ops = &tmio->ops; ++ memcpy (ops, hcd->self.op, sizeof *ops); ++ ops->buffer_alloc = tmio_buffer_alloc; ++ ops->buffer_free = tmio_buffer_free; ++ hcd->self.op = ops; ++ ++ retval = usb_add_hcd (hcd, irq->start, SA_INTERRUPT); ++ if (retval) ++ goto err_usb_add_hcd; ++ ++ return 0; ++ ++err_usb_add_hcd: ++ iounmap (tmio->sram); ++err_ioremap_sram: ++ iounmap (hcd->regs); ++err_ioremap_regs: ++ iounmap (tmio->ccr); ++err_ioremap_ccr: ++ release_resource (sram); ++err_request_sram_resource: ++ release_resource (regs); ++err_request_regs_resource: ++ release_resource (config); ++err_request_config_resource: ++ usb_put_hcd (hcd); ++err_create_hcd: ++ return retval; ++} ++ ++/* may be called without controller electrically present */ ++/* may be called with controller, bus, and devices active */ ++ ++/** ++ * tmio_remove - shutdown processing for TMIO-based HCDs ++ * @dev: USB Host Controller being removed ++ * Context: !in_interrupt() ++ * ++ * Reverses the effect of tmio_probe(), first invoking ++ * the HCD's stop() method. It is always called from a thread ++ * context, normally "rmmod", "apmd", or something similar. ++ */ ++static int tmio_remove (struct device *dev) ++{ ++ struct usb_hcd* hcd = dev_get_drvdata (dev); ++ struct tmio_hcd* tmio = hcd_to_tmio (hcd); ++ ++ usb_remove_hcd (hcd); ++ iounmap (tmio->sram); ++ iounmap (hcd->regs); ++ iounmap (tmio->ccr); ++ release_resource (tmio_resource_mem (dev)); ++ release_resource (tmio_resource_control (dev)); ++ release_resource (tmio_resource_config (dev)); ++ usb_put_hcd (hcd); ++ return 0; ++} ++ ++static struct device_driver tmio_ohci = { ++ .name = TMIO_NAME_OHCI, ++ .bus = &tmio_bus_type, ++ .probe = tmio_probe, ++ .remove = tmio_remove, ++}; ++ ++static int __init tmio_init (void) ++{ ++ dbg (DRIVER_INFO " (%s)", TMIO_SOC_NAME); ++ dbg ("block sizes: ed %d td %d", ++ sizeof (struct ed), sizeof (struct td)); ++ ++ return driver_register (&tmio_ohci); ++} ++ ++static void __exit tmio_exit (void) ++{ ++ driver_unregister (&tmio_ohci); ++} ++ ++module_init (tmio_init); ++module_exit (tmio_exit); +Index: git/drivers/usb/host/Kconfig +=================================================================== +--- git.orig/drivers/usb/host/Kconfig 2006-11-07 21:46:32.000000000 +0000 ++++ git/drivers/usb/host/Kconfig 2006-11-07 21:48:38.000000000 +0000 +@@ -84,6 +84,7 @@ config USB_OHCI_HCD + depends on USB && USB_ARCH_HAS_OHCI + select ISP1301_OMAP if MACH_OMAP_H2 || MACH_OMAP_H3 + select I2C if ARCH_PNX4008 ++ select GENERIC_ALLOCATOR if TOSHIBA_TC6393XB + ---help--- + The Open Host Controller Interface (OHCI) is a standard for accessing + USB 1.1 host controller hardware. It does more in hardware than Intel's +Index: git/drivers/usb/host/ohci-hcd.c +=================================================================== +--- git.orig/drivers/usb/host/ohci-hcd.c 2006-11-07 21:46:32.000000000 +0000 ++++ git/drivers/usb/host/ohci-hcd.c 2006-11-07 21:48:33.000000000 +0000 +@@ -944,6 +944,7 @@ MODULE_LICENSE ("GPL"); + || defined(CONFIG_ARCH_OMAP) \ + || defined (CONFIG_ARCH_LH7A404) \ + || defined (CONFIG_PXA27x) \ ++ || defined (CONFIG_TOSHIBA_TC6393XB) \ + || defined (CONFIG_ARCH_EP93XX) \ + || defined (CONFIG_SOC_AU1X00) \ + || defined (CONFIG_USB_OHCI_HCD_PPC_SOC) \ |