more patches

author: Greg Kroah-Hartman <gregkh@suse.de> 2008-10-08 14:24:28 -0700
committer: Greg Kroah-Hartman <gregkh@suse.de> 2008-10-08 14:24:28 -0700
commit: 1bf94aacd8c94f985c573402d7a5eab548aaffd4 (patch)
tree: 50b43bb3b8abd67842df7e120b540408e7f798cd
parent: 1240ba9862f462ed5d39d8682081a30eddc764eb (diff)
download: patches-1bf94aacd8c94f985c573402d7a5eab548aaffd4.tar.gz
4 files changed, 1047 insertions, 0 deletions
diff --git a/series b/series
index 0d4d6fe259dfe1..02d7c4990bc2eb 100644
--- a/series
+++ b/series
@@ -159,6 +159,8 @@ usb/usb-ehci-log-a-warning-if-ehci-hcd-is-not-loaded-first.patch
 usb/usb-option-anydata-new-modem-same-id.patch
 usb/usb-snoop-processes-opening-usbfs-device-files.patch
 usb/usb-ehci-fix-remote-wakeup-support-for-arc-tdi-core.patch
+usb/usb-export-if-an-interface-driver-supports-autosuspend.patch
+usb/usb-ohci-add-support-for-tmio-ohci-cell.patch
 
 usb/fsl_usb2_udc-make-dr_ep_setup-function-static.patch
 usb/fsl_usb2_udc-remove-check-for-udc-null-in-dr_controller_setup.patch
@@ -218,6 +220,7 @@ staging/staging-go7007-v4l-fixes.patch
 staging/staging-slicoss-lots-of-checkpatch-fixes.patch
 staging/staging-slicoss-fix-warnings-due-to-static-usage.patch
 staging/staging-slicoss-fix-remaining-type-names.patch
+staging/staging-lindent-sxg.c.patch
 
 # can not even compile :(
 #staging/usb-add-princeton-instruments-usb-camera-driver.patch
@@ -245,3 +248,4 @@ staging/staging-slicoss-fix-remaining-type-names.patch
 #f.patch
 
 
+
diff --git a/staging/staging-lindent-sxg.c.patch b/staging/staging-lindent-sxg.c.patch
new file mode 100644
index 00000000000000..922464a5bc1a7e
--- /dev/null
+++ b/staging/staging-lindent-sxg.c.patch
@@ -0,0 +1,483 @@
+From jrm8005@gmail.com  Wed Oct  8 14:20:09 2008
+From: "J.R. Mauro" <jrm8005@gmail.com>
+Date: Sun, 5 Oct 2008 20:38:52 -0400
+Subject: Staging: Lindent sxg.c
+To: Greg Kroah-Hartman <gregkh@suse.de>
+Message-ID: <20081006003852.GF11436@localhost>
+Content-Disposition: inline
+
+
+Lindent drivers/staging/sxg/sxg.c
+
+Signed-off by: J.R. Mauro <jrm8005@gmail.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/staging/sxg/sxg.c |  146 +++++++++++++++++++++++++---------------------
+ 1 file changed, 81 insertions(+), 65 deletions(-)
+
+--- a/drivers/staging/sxg/sxg.c
++++ b/drivers/staging/sxg/sxg.c
+@@ -80,9 +80,15 @@
+ #include "sxgphycode.h"
+ #include "saharadbgdownload.h"
+ 
+-static int sxg_allocate_buffer_memory(p_adapter_t adapter, u32 Size, SXG_BUFFER_TYPE BufferType);
+-static void sxg_allocate_rcvblock_complete(p_adapter_t adapter, void * RcvBlock, dma_addr_t PhysicalAddress, u32 Length);
+-static void sxg_allocate_sgl_buffer_complete(p_adapter_t adapter, PSXG_SCATTER_GATHER SxgSgl, dma_addr_t PhysicalAddress, u32 Length);
++static int sxg_allocate_buffer_memory(p_adapter_t adapter, u32 Size,
++				      SXG_BUFFER_TYPE BufferType);
++static void sxg_allocate_rcvblock_complete(p_adapter_t adapter, void *RcvBlock,
++					   dma_addr_t PhysicalAddress,
++					   u32 Length);
++static void sxg_allocate_sgl_buffer_complete(p_adapter_t adapter,
++					     PSXG_SCATTER_GATHER SxgSgl,
++					     dma_addr_t PhysicalAddress,
++					     u32 Length);
+ 
+ static void sxg_mcast_init_crc32(void);
+ 
+@@ -100,13 +106,13 @@ static void sxg_complete_slow_send(p_ada
+ static struct sk_buff *sxg_slow_receive(p_adapter_t adapter, PSXG_EVENT Event);
+ static void sxg_process_rcv_error(p_adapter_t adapter, u32 ErrorStatus);
+ static bool sxg_mac_filter(p_adapter_t adapter,
+-		       p_ether_header EtherHdr, ushort length);
++			   p_ether_header EtherHdr, ushort length);
+ 
+ #if SLIC_GET_STATS_ENABLED
+ static struct net_device_stats *sxg_get_stats(p_net_device dev);
+ #endif
+ 
+-static int sxg_mac_set_address(p_net_device dev, void * ptr);
++static int sxg_mac_set_address(p_net_device dev, void *ptr);
+ 
+ static void sxg_adapter_set_hwaddr(p_adapter_t adapter);
+ 
+@@ -115,20 +121,19 @@ static void sxg_mcast_set_mask(p_adapter
+ 
+ static int sxg_initialize_adapter(p_adapter_t adapter);
+ static void sxg_stock_rcv_buffers(p_adapter_t adapter);
+-static void sxg_complete_descriptor_blocks(p_adapter_t adapter, unsigned char Index);
++static void sxg_complete_descriptor_blocks(p_adapter_t adapter,
++					   unsigned char Index);
+ static int sxg_initialize_link(p_adapter_t adapter);
+ static int sxg_phy_init(p_adapter_t adapter);
+ static void sxg_link_event(p_adapter_t adapter);
+ static SXG_LINK_STATE sxg_get_link_state(p_adapter_t adapter);
+ static void sxg_link_state(p_adapter_t adapter, SXG_LINK_STATE LinkState);
+ static int sxg_write_mdio_reg(p_adapter_t adapter,
+-		       u32 DevAddr, u32 RegAddr, u32 Value);
++			      u32 DevAddr, u32 RegAddr, u32 Value);
+ static int sxg_read_mdio_reg(p_adapter_t adapter,
+-		      u32 DevAddr, u32 RegAddr, u32 * pValue);
++			     u32 DevAddr, u32 RegAddr, u32 *pValue);
+ static void sxg_mcast_set_list(p_net_device dev);
+ 
+-
+-
+ #define XXXTODO 0
+ 
+ static unsigned int sxg_first_init = 1;
+@@ -164,6 +169,7 @@ static struct pci_device_id sxg_pci_tbl[
+ 	{PCI_DEVICE(SXG_VENDOR_ID, SXG_DEVICE_ID)},
+ 	{0,}
+ };
++
+ MODULE_DEVICE_TABLE(pci, sxg_pci_tbl);
+ 
+ /***********************************************************************
+@@ -242,7 +248,7 @@ static bool sxg_download_microcode(p_ada
+ 	PSXG_HW_REGS HwRegs = adapter->HwRegs;
+ 	u32 Section;
+ 	u32 ThisSectionSize;
+-	u32 * Instruction = NULL;
++	u32 *Instruction = NULL;
+ 	u32 BaseAddress, AddressOffset, Address;
+ //      u32                         Failure;
+ 	u32 ValueRead;
+@@ -606,7 +612,7 @@ static void sxg_config_pci(struct pci_de
+ 				     PCI_COMMAND_MASTER |	// Bus master enable
+ 				     PCI_COMMAND_INVALIDATE |	// Memory write and invalidate
+ 				     PCI_COMMAND_PARITY |	// Parity error response
+-				     PCI_COMMAND_SERR |		// System ERR
++				     PCI_COMMAND_SERR |	// System ERR
+ 				     PCI_COMMAND_FAST_BACK);	// Fast back-to-back
+ 	if (pci_command != new_command) {
+ 		DBG_ERROR("%s -- Updating PCI COMMAND register %4.4x->%4.4x.\n",
+@@ -695,17 +701,19 @@ static int sxg_entry_probe(struct pci_de
+ 		  mmio_start, mmio_len);
+ 
+ 	memmapped_ioaddr = ioremap(mmio_start, mmio_len);
+-	DBG_ERROR("sxg: %s MEMMAPPED_IOADDR [%p]\n", __FUNCTION__, memmapped_ioaddr);
++	DBG_ERROR("sxg: %s MEMMAPPED_IOADDR [%p]\n", __FUNCTION__,
++		  memmapped_ioaddr);
+ 	if (!memmapped_ioaddr) {
+ 		DBG_ERROR("%s cannot remap MMIO region %lx @ %lx\n",
+ 			  __FUNCTION__, mmio_len, mmio_start);
+ 		goto err_out_free_mmio_region;
+ 	}
+ 
+-	DBG_ERROR("sxg: %s found Alacritech SXG PCI, MMIO at %p, start[%lx] len[%lx], IRQ %d.\n",
++	DBG_ERROR
++	    ("sxg: %s found Alacritech SXG PCI, MMIO at %p, start[%lx] len[%lx], IRQ %d.\n",
+ 	     __func__, memmapped_ioaddr, mmio_start, mmio_len, pcidev->irq);
+ 
+-	adapter->HwRegs = (void *) memmapped_ioaddr;
++	adapter->HwRegs = (void *)memmapped_ioaddr;
+ 	adapter->base_addr = memmapped_ioaddr;
+ 
+ 	mmio_start = pci_resource_start(pcidev, 2);
+@@ -715,7 +723,8 @@ static int sxg_entry_probe(struct pci_de
+ 		  mmio_start, mmio_len);
+ 
+ 	memmapped_ioaddr = ioremap(mmio_start, mmio_len);
+-	DBG_ERROR("sxg: %s MEMMAPPED_IOADDR [%p]\n", __func__, memmapped_ioaddr);
++	DBG_ERROR("sxg: %s MEMMAPPED_IOADDR [%p]\n", __func__,
++		  memmapped_ioaddr);
+ 	if (!memmapped_ioaddr) {
+ 		DBG_ERROR("%s cannot remap MMIO region %lx @ %lx\n",
+ 			  __FUNCTION__, mmio_len, mmio_start);
+@@ -845,7 +854,6 @@ static int sxg_entry_probe(struct pci_de
+ 	return -ENODEV;
+ }
+ 
+-
+ /***********************************************************************
+  * LINE BASE Interrupt routines..
+  ***********************************************************************/
+@@ -957,7 +965,8 @@ static irqreturn_t sxg_isr(int irq, void
+ 			PSXG_EVENT_RING EventRing = &adapter->EventRings[i];
+ 			PSXG_EVENT Event =
+ 			    &EventRing->Ring[adapter->NextEvent[i]];
+-			unsigned char Cpu = adapter->RssSystemInfo->RssIdToCpu[i];
++			unsigned char Cpu =
++			    adapter->RssSystemInfo->RssIdToCpu[i];
+ 			if (Event->Status & EVENT_STATUS_VALID) {
+ 				adapter->IsrDpcsPending++;
+ 				CpuMask |= (1 << Cpu);
+@@ -1078,7 +1087,8 @@ static int sxg_process_isr(p_adapter_t a
+ 		if (Isr & SXG_ISR_DEAD) {
+ 			// Set aside the crash info and set the adapter state to RESET
+ 			adapter->CrashCpu =
+-			    (unsigned char) ((Isr & SXG_ISR_CPU) >> SXG_ISR_CPU_SHIFT);
++			    (unsigned char)((Isr & SXG_ISR_CPU) >>
++					    SXG_ISR_CPU_SHIFT);
+ 			adapter->CrashLocation = (ushort) (Isr & SXG_ISR_CRASH);
+ 			adapter->Dead = TRUE;
+ 			DBG_ERROR("%s: ISR_DEAD %x, CPU: %d\n", __FUNCTION__,
+@@ -1286,7 +1296,7 @@ static void sxg_complete_slow_send(p_ada
+ {
+ 	PSXG_XMT_RING XmtRing = &adapter->XmtRings[0];
+ 	PSXG_RING_INFO XmtRingInfo = &adapter->XmtRingZeroInfo;
+-	u32 * ContextType;
++	u32 *ContextType;
+ 	PSXG_CMD XmtCmd;
+ 
+ 	// NOTE - This lock is dropped and regrabbed in this loop.
+@@ -1380,11 +1390,9 @@ static struct sk_buff *sxg_slow_receive(
+ 		SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "RcvError",
+ 			  Event, Event->Status, Event->HostHandle, 0);
+ 		// XXXTODO - Remove this print later
+-		DBG_ERROR("SXG: Receive error %x\n",
+-			  *(u32 *)
++		DBG_ERROR("SXG: Receive error %x\n", *(u32 *)
+ 			  SXG_RECEIVE_DATA_LOCATION(RcvDataBufferHdr));
+-		sxg_process_rcv_error(adapter,
+-				      *(u32 *)
++		sxg_process_rcv_error(adapter, *(u32 *)
+ 				      SXG_RECEIVE_DATA_LOCATION
+ 				      (RcvDataBufferHdr));
+ 		goto drop;
+@@ -1406,8 +1414,7 @@ static struct sk_buff *sxg_slow_receive(
+ 	//
+ 	// Dumb-nic frame.  See if it passes our mac filter and update stats
+ 	//
+-	if (!sxg_mac_filter(adapter,
+-			    (p_ether_header)
++	if (!sxg_mac_filter(adapter, (p_ether_header)
+ 			    SXG_RECEIVE_DATA_LOCATION(RcvDataBufferHdr),
+ 			    Event->Length)) {
+ 		SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "RcvFiltr",
+@@ -1527,7 +1534,8 @@ static void sxg_process_rcv_error(p_adap
+  * Return Value:
+  * 	TRUE if the frame is to be allowed
+  */
+-static bool sxg_mac_filter(p_adapter_t adapter, p_ether_header EtherHdr, ushort length)
++static bool sxg_mac_filter(p_adapter_t adapter, p_ether_header EtherHdr,
++			   ushort length)
+ {
+ 	bool EqualAddr;
+ 
+@@ -1600,7 +1608,8 @@ static int sxg_register_interrupt(p_adap
+ 		    ("sxg: %s AllocAdaptRsrcs adapter[%p] dev->irq[%x] %x\n",
+ 		     __FUNCTION__, adapter, adapter->netdev->irq, NR_IRQS);
+ 
+-		spin_unlock_irqrestore(&sxg_global.driver_lock, sxg_global.flags);
++		spin_unlock_irqrestore(&sxg_global.driver_lock,
++				       sxg_global.flags);
+ 
+ 		retval = request_irq(adapter->netdev->irq,
+ 				     &sxg_isr,
+@@ -1729,7 +1738,6 @@ static int sxg_entry_open(p_net_device d
+ 		sxg_global.num_sxg_ports_active++;
+ 		adapter->activated = 1;
+ 	}
+-
+ 	// Initialize the adapter
+ 	DBG_ERROR("sxg: %s ENTER sxg_initialize_adapter\n", __FUNCTION__);
+ 	status = sxg_initialize_adapter(adapter);
+@@ -1786,7 +1794,7 @@ static void __devexit sxg_entry_remove(s
+ 	release_mem_region(mmio_start, mmio_len);
+ 
+ 	DBG_ERROR("sxg: %s iounmap dev->base_addr[%x]\n", __FUNCTION__,
+-		  (unsigned int) dev->base_addr);
++		  (unsigned int)dev->base_addr);
+ 	iounmap((char *)dev->base_addr);
+ 
+ 	DBG_ERROR("sxg: %s deallocate device\n", __FUNCTION__);
+@@ -1929,7 +1937,7 @@ static int sxg_transmit_packet(p_adapter
+ {
+ 	PSCATTER_GATHER_LIST pSgl;
+ 	PSXG_SCATTER_GATHER SxgSgl;
+-	void * SglBuffer;
++	void *SglBuffer;
+ 	u32 SglBufferLength;
+ 
+ 	// The vast majority of work is done in the shared
+@@ -2038,7 +2046,9 @@ static void sxg_dumb_sgl(PSCATTER_GATHER
+ #endif
+ 	// Fill in the command
+ 	// Copy out the first SGE to the command and adjust for offset
+-	phys_addr = pci_map_single(adapter->pcidev, skb->data, skb->len, PCI_DMA_TODEVICE);
++	phys_addr =
++	    pci_map_single(adapter->pcidev, skb->data, skb->len,
++			   PCI_DMA_TODEVICE);
+ 	XmtCmd->Buffer.FirstSgeAddress = SXG_GET_ADDR_HIGH(phys_addr);
+ 	XmtCmd->Buffer.FirstSgeAddress = XmtCmd->Buffer.FirstSgeAddress << 32;
+ 	XmtCmd->Buffer.FirstSgeAddress =
+@@ -2422,7 +2432,8 @@ static SXG_LINK_STATE sxg_get_link_state
+ 	return (SXG_LINK_DOWN);
+ }
+ 
+-static void sxg_indicate_link_state(p_adapter_t adapter, SXG_LINK_STATE LinkState)
++static void sxg_indicate_link_state(p_adapter_t adapter,
++				    SXG_LINK_STATE LinkState)
+ {
+ 	if (adapter->LinkState == SXG_LINK_UP) {
+ 		DBG_ERROR("%s: LINK now UP, call netif_start_queue\n",
+@@ -2487,11 +2498,11 @@ static void sxg_link_state(p_adapter_t a
+  *	status
+  */
+ static int sxg_write_mdio_reg(p_adapter_t adapter,
+-		   u32 DevAddr, u32 RegAddr, u32 Value)
++			      u32 DevAddr, u32 RegAddr, u32 Value)
+ {
+ 	PSXG_HW_REGS HwRegs = adapter->HwRegs;
+ 	u32 AddrOp;		// Address operation (written to MIIM field reg)
+-	u32 WriteOp;	// Write operation (written to MIIM field reg)
++	u32 WriteOp;		// Write operation (written to MIIM field reg)
+ 	u32 Cmd;		// Command (written to MIIM command reg)
+ 	u32 ValueRead;
+ 	u32 Timeout;
+@@ -2577,7 +2588,7 @@ static int sxg_write_mdio_reg(p_adapter_
+  *	status
+  */
+ static int sxg_read_mdio_reg(p_adapter_t adapter,
+-		  u32 DevAddr, u32 RegAddr, u32 * pValue)
++			     u32 DevAddr, u32 RegAddr, u32 *pValue)
+ {
+ 	PSXG_HW_REGS HwRegs = adapter->HwRegs;
+ 	u32 AddrOp;		// Address operation (written to MIIM field reg)
+@@ -2698,7 +2709,7 @@ static int sxg_mcast_add_list(p_adapter_
+  * we must then transpose the value and return bits 30-23.
+  *
+  */
+-static u32 sxg_crc_table[256]; /* Table of CRC's for all possible byte values */
++static u32 sxg_crc_table[256];	/* Table of CRC's for all possible byte values */
+ static u32 sxg_crc_init;	/* Is table initialized                        */
+ 
+ /*
+@@ -2706,7 +2717,7 @@ static u32 sxg_crc_init;	/* Is table ini
+  */
+ static void sxg_mcast_init_crc32(void)
+ {
+-	u32 c;		/*  CRC shit reg                 */
++	u32 c;			/*  CRC shit reg                 */
+ 	u32 e = 0;		/*  Poly X-or pattern            */
+ 	int i;			/*  counter                      */
+ 	int k;			/*  byte being shifted into crc  */
+@@ -2783,7 +2794,7 @@ static void sxg_mcast_set_list(p_net_dev
+ 	ASSERT(adapter);
+ 
+ 	for (i = 1; i <= mc_count; i++) {
+-		addresses = (char *) & mc_list->dmi_addr;
++		addresses = (char *)&mc_list->dmi_addr;
+ 		if (mc_list->dmi_addrlen == 6) {
+ 			status = sxg_mcast_add_list(adapter, addresses);
+ 			if (status != STATUS_SUCCESS) {
+@@ -2833,7 +2844,7 @@ static void sxg_mcast_set_mask(p_adapter
+ 	PSXG_UCODE_REGS sxg_regs = adapter->UcodeRegs;
+ 
+ 	DBG_ERROR("%s ENTER (%s) macopts[%x] mask[%llx]\n", __FUNCTION__,
+-		  adapter->netdev->name, (unsigned int) adapter->MacFilter,
++		  adapter->netdev->name, (unsigned int)adapter->MacFilter,
+ 		  adapter->MulticastMask);
+ 
+ 	if (adapter->MacFilter & (MAC_ALLMCAST | MAC_PROMISC)) {
+@@ -2857,12 +2868,10 @@ static void sxg_mcast_set_mask(p_adapter
+ 			   ((adapter->MulticastMask >> 32) & 0xFFFFFFFF)));
+ 
+ 		WRITE_REG(sxg_regs->McastLow,
+-			  (u32) (adapter->MulticastMask & 0xFFFFFFFF),
+-			  FLUSH);
++			  (u32) (adapter->MulticastMask & 0xFFFFFFFF), FLUSH);
+ 		WRITE_REG(sxg_regs->McastHigh,
+ 			  (u32) ((adapter->
+-				      MulticastMask >> 32) & 0xFFFFFFFF),
+-			  FLUSH);
++				  MulticastMask >> 32) & 0xFFFFFFFF), FLUSH);
+ 	}
+ }
+ 
+@@ -2991,9 +3000,9 @@ void SxgFreeResources(p_adapter_t adapte
+  *	None.
+  */
+ static void sxg_allocate_complete(p_adapter_t adapter,
+-		      void *VirtualAddress,
+-		      dma_addr_t PhysicalAddress,
+-		      u32 Length, SXG_BUFFER_TYPE Context)
++				  void *VirtualAddress,
++				  dma_addr_t PhysicalAddress,
++				  u32 Length, SXG_BUFFER_TYPE Context)
+ {
+ 	SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "AllocCmp",
+ 		  adapter, VirtualAddress, Length, Context);
+@@ -3008,8 +3017,7 @@ static void sxg_allocate_complete(p_adap
+ 					       PhysicalAddress, Length);
+ 		break;
+ 	case SXG_BUFFER_TYPE_SGL:
+-		sxg_allocate_sgl_buffer_complete(adapter,
+-						 (PSXG_SCATTER_GATHER)
++		sxg_allocate_sgl_buffer_complete(adapter, (PSXG_SCATTER_GATHER)
+ 						 VirtualAddress,
+ 						 PhysicalAddress, Length);
+ 		break;
+@@ -3031,10 +3039,10 @@ static void sxg_allocate_complete(p_adap
+  *	int
+  */
+ static int sxg_allocate_buffer_memory(p_adapter_t adapter,
+-			   u32 Size, SXG_BUFFER_TYPE BufferType)
++				      u32 Size, SXG_BUFFER_TYPE BufferType)
+ {
+ 	int status;
+-	void * Buffer;
++	void *Buffer;
+ 	dma_addr_t pBuffer;
+ 
+ 	SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "AllocMem",
+@@ -3083,8 +3091,9 @@ static int sxg_allocate_buffer_memory(p_
+  *
+  */
+ static void sxg_allocate_rcvblock_complete(p_adapter_t adapter,
+-			       void * RcvBlock,
+-			       dma_addr_t PhysicalAddress, u32 Length)
++					   void *RcvBlock,
++					   dma_addr_t PhysicalAddress,
++					   u32 Length)
+ {
+ 	u32 i;
+ 	u32 BufferSize = adapter->ReceiveBufferSize;
+@@ -3160,9 +3169,10 @@ static void sxg_allocate_rcvblock_comple
+ 	}
+ 
+ 	// Locate the descriptor block and put it on a separate free queue
+-	RcvDescriptorBlock = (PSXG_RCV_DESCRIPTOR_BLOCK) ((unsigned char *)RcvBlock +
+-							  SXG_RCV_DESCRIPTOR_BLOCK_OFFSET
+-							  (BufferSize));
++	RcvDescriptorBlock =
++	    (PSXG_RCV_DESCRIPTOR_BLOCK) ((unsigned char *)RcvBlock +
++					 SXG_RCV_DESCRIPTOR_BLOCK_OFFSET
++					 (BufferSize));
+ 	RcvDescriptorBlockHdr =
+ 	    (PSXG_RCV_DESCRIPTOR_BLOCK_HDR) ((unsigned char *)RcvBlock +
+ 					     SXG_RCV_DESCRIPTOR_BLOCK_HDR_OFFSET
+@@ -3210,8 +3220,9 @@ static void sxg_allocate_rcvblock_comple
+  *
+  */
+ static void sxg_allocate_sgl_buffer_complete(p_adapter_t adapter,
+-				 PSXG_SCATTER_GATHER SxgSgl,
+-				 dma_addr_t PhysicalAddress, u32 Length)
++					     PSXG_SCATTER_GATHER SxgSgl,
++					     dma_addr_t PhysicalAddress,
++					     u32 Length)
+ {
+ 	SXG_TRACE(TRACE_SXG, SxgTraceBuffer, TRACE_NOISY, "AlSglCmp",
+ 		  adapter, SxgSgl, Length, 0);
+@@ -3228,7 +3239,8 @@ static void sxg_allocate_sgl_buffer_comp
+ 		  adapter, SxgSgl, Length, 0);
+ }
+ 
+-static unsigned char temp_mac_address[6] = { 0x00, 0xab, 0xcd, 0xef, 0x12, 0x69 };
++static unsigned char temp_mac_address[6] =
++    { 0x00, 0xab, 0xcd, 0xef, 0x12, 0x69 };
+ 
+ static void sxg_adapter_set_hwaddr(p_adapter_t adapter)
+ {
+@@ -3255,7 +3267,7 @@ static void sxg_adapter_set_hwaddr(p_ada
+ 
+ }
+ 
+-static int sxg_mac_set_address(p_net_device dev, void * ptr)
++static int sxg_mac_set_address(p_net_device dev, void *ptr)
+ {
+ #if XXXTODO
+ 	p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
+@@ -3400,7 +3412,8 @@ static int sxg_initialize_adapter(p_adap
+  *	status
+  */
+ static int sxg_fill_descriptor_block(p_adapter_t adapter,
+-			  PSXG_RCV_DESCRIPTOR_BLOCK_HDR RcvDescriptorBlockHdr)
++				     PSXG_RCV_DESCRIPTOR_BLOCK_HDR
++				     RcvDescriptorBlockHdr)
+ {
+ 	u32 i;
+ 	PSXG_RING_INFO RcvRingInfo = &adapter->RcvRingZeroInfo;
+@@ -3436,7 +3449,8 @@ static int sxg_fill_descriptor_block(p_a
+ 		ASSERT(RcvDataBufferHdr);
+ 		SXG_REINIATIALIZE_PACKET(RcvDataBufferHdr->SxgDumbRcvPacket);
+ 		RcvDataBufferHdr->State = SXG_BUFFER_ONCARD;
+-		RcvDescriptorBlock->Descriptors[i].VirtualAddress = (void *)RcvDataBufferHdr;
++		RcvDescriptorBlock->Descriptors[i].VirtualAddress =
++		    (void *)RcvDataBufferHdr;
+ 		RcvDescriptorBlock->Descriptors[i].PhysicalAddress =
+ 		    RcvDataBufferHdr->PhysicalAddress;
+ 	}
+@@ -3497,7 +3511,9 @@ static void sxg_stock_rcv_buffers(p_adap
+ 		RcvDescriptorBlockHdr = NULL;
+ 		if (adapter->FreeRcvBlockCount) {
+ 			_ple = RemoveHeadList(&adapter->FreeRcvBlocks);
+-			RcvDescriptorBlockHdr = container_of(_ple, SXG_RCV_DESCRIPTOR_BLOCK_HDR, FreeList);
++			RcvDescriptorBlockHdr =
++			    container_of(_ple, SXG_RCV_DESCRIPTOR_BLOCK_HDR,
++					 FreeList);
+ 			adapter->FreeRcvBlockCount--;
+ 			RcvDescriptorBlockHdr->State = SXG_BUFFER_BUSY;
+ 		}
+@@ -3533,7 +3549,8 @@ static void sxg_stock_rcv_buffers(p_adap
+  * Return
+  *	None
+  */
+-static void sxg_complete_descriptor_blocks(p_adapter_t adapter, unsigned char Index)
++static void sxg_complete_descriptor_blocks(p_adapter_t adapter,
++					   unsigned char Index)
+ {
+ 	PSXG_RCV_RING RingZero = &adapter->RcvRings[0];
+ 	PSXG_RING_INFO RcvRingInfo = &adapter->RcvRingZeroInfo;
+@@ -3576,7 +3593,6 @@ static void sxg_complete_descriptor_bloc
+ 		  adapter, Index, RcvRingInfo->Head, RcvRingInfo->Tail);
+ }
+ 
+-
+ static struct pci_driver sxg_driver = {
+ 	.name = DRV_NAME,
+ 	.id_table = sxg_pci_tbl,
diff --git a/usb/usb-export-if-an-interface-driver-supports-autosuspend.patch b/usb/usb-export-if-an-interface-driver-supports-autosuspend.patch
new file mode 100644
index 00000000000000..764a346885b8a9
--- /dev/null
+++ b/usb/usb-export-if-an-interface-driver-supports-autosuspend.patch
@@ -0,0 +1,89 @@
+From sarah.a.sharp@linux.intel.com  Wed Oct  8 14:20:40 2008
+From: Sarah Sharp <sarah.a.sharp@linux.intel.com>
+Date: Mon, 6 Oct 2008 14:45:46 -0700
+Subject: USB: Export if an interface driver supports autosuspend.
+To: Greg KH <greg@kroah.com>
+Cc: linux-usb@vger.kernel.org
+Message-ID: <20081006214546.GA8342@localdomain>
+Content-Disposition: inline
+
+
+Create a new sysfs file per interface named supports_autosuspend.  This
+file returns true if an interface driver's .supports_autosuspend flag is
+set.  It also returns true if the interface is unclaimed (since the USB
+core will autosuspend a device if an interface is not claimed).
+
+This new sysfs file will be useful for user space scripts to test whether
+a USB device correctly auto-suspends.
+
+Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
+Cc: Oliver Neukum <oliver@neukum.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ Documentation/ABI/testing/sysfs-bus-usb |   16 ++++++++++++++++
+ drivers/usb/core/sysfs.c                |   24 ++++++++++++++++++++++++
+ 2 files changed, 40 insertions(+)
+
+--- a/Documentation/ABI/testing/sysfs-bus-usb
++++ b/Documentation/ABI/testing/sysfs-bus-usb
+@@ -85,3 +85,19 @@ Description:
+ Users:
+ 		PowerTOP <power@bughost.org>
+ 		http://www.lesswatts.org/projects/powertop/
++
++What:		/sys/bus/usb/device/<busnum>-<devnum>...:<config num>-<interface num>/supports_autosuspend
++Date:		January 2008
++KernelVersion:	2.6.27
++Contact:	Sarah Sharp <sarah.a.sharp@intel.com>
++Description:
++		When read, this file returns 1 if the interface driver
++		for this interface supports autosuspend.  It also
++		returns 1 if no driver has claimed this interface, as an
++		unclaimed interface will not stop the device from being
++		autosuspended if all other interface drivers are idle.
++		The file returns 0 if autosuspend support has not been
++		added to the driver.
++Users:
++		USB PM tool
++		git://git.moblin.org/users/sarah/usb-pm-tool/
+--- a/drivers/usb/core/sysfs.c
++++ b/drivers/usb/core/sysfs.c
+@@ -743,6 +743,29 @@ static ssize_t show_modalias(struct devi
+ }
+ static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
+ 
++static ssize_t show_supports_autosuspend(struct device *dev,
++		struct device_attribute *attr, char *buf)
++{
++	struct usb_interface *intf;
++	struct usb_device *udev;
++	int ret;
++
++	intf = to_usb_interface(dev);
++	udev = interface_to_usbdev(intf);
++
++	usb_lock_device(udev);
++	/* Devices will be autosuspended even when an interface isn't claimed */
++	if (!intf->dev.driver ||
++			to_usb_driver(intf->dev.driver)->supports_autosuspend)
++		ret = sprintf(buf, "%u\n", 1);
++	else
++		ret = sprintf(buf, "%u\n", 0);
++	usb_unlock_device(udev);
++
++	return ret;
++}
++static DEVICE_ATTR(supports_autosuspend, S_IRUGO, show_supports_autosuspend, NULL);
++
+ static struct attribute *intf_attrs[] = {
+ 	&dev_attr_bInterfaceNumber.attr,
+ 	&dev_attr_bAlternateSetting.attr,
+@@ -751,6 +774,7 @@ static struct attribute *intf_attrs[] = 
+ 	&dev_attr_bInterfaceSubClass.attr,
+ 	&dev_attr_bInterfaceProtocol.attr,
+ 	&dev_attr_modalias.attr,
++	&dev_attr_supports_autosuspend.attr,
+ 	NULL,
+ };
+ static struct attribute_group intf_attr_grp = {
diff --git a/usb/usb-ohci-add-support-for-tmio-ohci-cell.patch b/usb/usb-ohci-add-support-for-tmio-ohci-cell.patch
new file mode 100644
index 00000000000000..5f2c85e7e9d291
--- /dev/null
+++ b/usb/usb-ohci-add-support-for-tmio-ohci-cell.patch
@@ -0,0 +1,471 @@
+From dbaryshkov@gmail.com  Wed Oct  8 14:21:19 2008
+From: Dmitry Baryshkov <dbaryshkov@gmail.com>
+Date: Wed,  8 Oct 2008 16:14:23 +0400
+Subject: USB: ohci: add support for tmio-ohci cell
+To: linux-usb@vger.kernel.org
+Cc: Dmitry Baryshkov <dbaryshkov@gmail.com>, Ian Molton <spyro@f2s.com>
+Message-ID: <1223468063-536-1-git-send-email-dbaryshkov@gmail.com>
+
+
+Some Toshiba Mobile I/O chips have OHCI controller built in.
+E.g. the tc6393xb chip found in several Toshiba e-Series PDAs
+and in Sharp Zaurus SL-6000 PDA. This adds platform glue
+to support OHCI function of the chip.
+
+Signed-off-by: Dmitry Baryshkov <dbaryshkov@gmail.com>
+Acked-by: Ian Molton <spyro@f2s.com>
+Cc: Ian Molton <spyro@f2s.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/Kconfig          |    1 
+ drivers/usb/host/ohci-hcd.c  |   21 ++
+ drivers/usb/host/ohci-tmio.c |  376 +++++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 398 insertions(+)
+
+--- a/drivers/usb/host/ohci-hcd.c
++++ b/drivers/usb/host/ohci-hcd.c
+@@ -1075,12 +1075,18 @@ MODULE_LICENSE ("GPL");
+ #define SM501_OHCI_DRIVER	ohci_hcd_sm501_driver
+ #endif
+ 
++#ifdef CONFIG_MFD_TC6393XB
++#include "ohci-tmio.c"
++#define TMIO_OHCI_DRIVER	ohci_hcd_tmio_driver
++#endif
++
+ #if	!defined(PCI_DRIVER) &&		\
+ 	!defined(PLATFORM_DRIVER) &&	\
+ 	!defined(OF_PLATFORM_DRIVER) &&	\
+ 	!defined(SA1111_DRIVER) &&	\
+ 	!defined(PS3_SYSTEM_BUS_DRIVER) && \
+ 	!defined(SM501_OHCI_DRIVER) && \
++	!defined(TMIO_OHCI_DRIVER) && \
+ 	!defined(SSB_OHCI_DRIVER)
+ #error "missing bus glue for ohci-hcd"
+ #endif
+@@ -1147,13 +1153,25 @@ static int __init ohci_hcd_mod_init(void
+ 		goto error_sm501;
+ #endif
+ 
++#ifdef TMIO_OHCI_DRIVER
++	retval = platform_driver_register(&TMIO_OHCI_DRIVER);
++	if (retval < 0)
++		goto error_tmio;
++#endif
++
+ 	return retval;
+ 
+ 	/* Error path */
++#ifdef TMIO_OHCI_DRIVER
++	platform_driver_unregister(&TMIO_OHCI_DRIVER);
++ error_tmio:
++#endif
+ #ifdef SM501_OHCI_DRIVER
++	platform_driver_unregister(&SM501_OHCI_DRIVER);
+  error_sm501:
+ #endif
+ #ifdef SSB_OHCI_DRIVER
++	ssb_driver_unregister(&SSB_OHCI_DRIVER);
+  error_ssb:
+ #endif
+ #ifdef PCI_DRIVER
+@@ -1189,6 +1207,9 @@ module_init(ohci_hcd_mod_init);
+ 
+ static void __exit ohci_hcd_mod_exit(void)
+ {
++#ifdef TMIO_OHCI_DRIVER
++	platform_driver_unregister(&TMIO_OHCI_DRIVER);
++#endif
+ #ifdef SM501_OHCI_DRIVER
+ 	platform_driver_unregister(&SM501_OHCI_DRIVER);
+ #endif
+--- /dev/null
++++ b/drivers/usb/host/ohci-tmio.c
+@@ -0,0 +1,376 @@
++/*
++ * 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>
++ * (C) Copyright 2007, 2008 Dmitry Baryshkov <dbaryshkov@gmail.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.
++ *
++ * 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/platform_device.h>
++#include <linux/mfd/core.h>
++#include <linux/mfd/tmio.h>
++#include <linux/dma-mapping.h>
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * USB Host Controller Configuration Register
++ */
++#define CCR_REVID	0x08	/* b Revision ID				*/
++#define CCR_BASE	0x10	/* l USB Control Register Base Address Low	*/
++#define CCR_ILME	0x40	/* b Internal Local Memory Enable		*/
++#define CCR_PM		0x4c	/* w Power Management			*/
++#define CCR_INTC	0x50	/* b INT Control				*/
++#define CCR_LMW1L	0x54	/* w Local Memory Window 1 LMADRS Low	*/
++#define CCR_LMW1H	0x56	/* w Local Memory Window 1 LMADRS High	*/
++#define CCR_LMW1BL	0x58	/* w Local Memory Window 1 Base Address Low	*/
++#define CCR_LMW1BH	0x5A	/* w Local Memory Window 1 Base Address High	*/
++#define CCR_LMW2L	0x5C	/* w Local Memory Window 2 LMADRS Low	*/
++#define CCR_LMW2H	0x5E	/* w Local Memory Window 2 LMADRS High	*/
++#define CCR_LMW2BL	0x60	/* w Local Memory Window 2 Base Address Low	*/
++#define CCR_LMW2BH	0x62	/* w Local Memory Window 2 Base Address High	*/
++#define CCR_MISC	0xFC	/* b MISC					*/
++
++#define CCR_PM_GKEN      0x0001
++#define CCR_PM_CKRNEN    0x0002
++#define CCR_PM_USBPW1    0x0004
++#define CCR_PM_USBPW2    0x0008
++#define CCR_PM_USBPW3    0x0008
++#define CCR_PM_PMEE      0x0100
++#define CCR_PM_PMES      0x8000
++
++/*-------------------------------------------------------------------------*/
++
++struct tmio_hcd {
++	void __iomem		*ccr;
++	spinlock_t		lock; /* protects RMW cycles */
++};
++
++#define hcd_to_tmio(hcd)	((struct tmio_hcd *)(hcd_to_ohci(hcd) + 1))
++
++/*-------------------------------------------------------------------------*/
++
++static void tmio_write_pm(struct platform_device *dev)
++{
++	struct usb_hcd *hcd = platform_get_drvdata(dev);
++	struct tmio_hcd *tmio = hcd_to_tmio(hcd);
++	u16 pm;
++	unsigned long flags;
++
++	spin_lock_irqsave(&tmio->lock, flags);
++
++	pm = CCR_PM_GKEN | CCR_PM_CKRNEN |
++	     CCR_PM_PMEE | CCR_PM_PMES;
++
++	tmio_iowrite16(pm, tmio->ccr + CCR_PM);
++	spin_unlock_irqrestore(&tmio->lock, flags);
++}
++
++static void tmio_stop_hc(struct platform_device *dev)
++{
++	struct usb_hcd *hcd = platform_get_drvdata(dev);
++	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
++	struct tmio_hcd *tmio = hcd_to_tmio(hcd);
++	u16 pm;
++
++	pm = CCR_PM_GKEN | CCR_PM_CKRNEN;
++	switch (ohci->num_ports) {
++		default:
++			dev_err(&dev->dev, "Unsupported amount of ports: %d\n", ohci->num_ports);
++		case 3:
++			pm |= CCR_PM_USBPW3;
++		case 2:
++			pm |= CCR_PM_USBPW2;
++		case 1:
++			pm |= CCR_PM_USBPW1;
++	}
++	tmio_iowrite8(0, tmio->ccr + CCR_INTC);
++	tmio_iowrite8(0, tmio->ccr + CCR_ILME);
++	tmio_iowrite16(0, tmio->ccr + CCR_BASE);
++	tmio_iowrite16(0, tmio->ccr + CCR_BASE + 2);
++	tmio_iowrite16(pm, tmio->ccr + CCR_PM);
++}
++
++static void tmio_start_hc(struct platform_device *dev)
++{
++	struct usb_hcd *hcd = platform_get_drvdata(dev);
++	struct tmio_hcd *tmio = hcd_to_tmio(hcd);
++	unsigned long base = hcd->rsrc_start;
++
++	tmio_write_pm(dev);
++	tmio_iowrite16(base, tmio->ccr + CCR_BASE);
++	tmio_iowrite16(base >> 16, tmio->ccr + CCR_BASE + 2);
++	tmio_iowrite8(1, tmio->ccr + CCR_ILME);
++	tmio_iowrite8(2, tmio->ccr + CCR_INTC);
++
++	dev_info(&dev->dev, "revision %d @ 0x%08llx, irq %d\n",
++			tmio_ioread8(tmio->ccr + CCR_REVID), hcd->rsrc_start, hcd->irq);
++}
++
++static int ohci_tmio_start(struct usb_hcd *hcd)
++{
++	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
++	int ret;
++
++	if ((ret = ohci_init(ohci)) < 0)
++		return ret;
++
++	if ((ret = ohci_run(ohci)) < 0) {
++		err("can't start %s", hcd->self.bus_name);
++		ohci_stop(hcd);
++		return ret;
++	}
++
++	return 0;
++}
++
++static const struct hc_driver ohci_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 =			ohci_irq,
++	.flags =		HCD_USB11 | HCD_MEMORY | HCD_LOCAL_MEM,
++
++	/* basic lifecycle operations */
++	.start =		ohci_tmio_start,
++	.stop =			ohci_stop,
++	.shutdown =		ohci_shutdown,
++
++	/* managing i/o requests and associated device resources */
++	.urb_enqueue =		ohci_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,
++};
++
++/*-------------------------------------------------------------------------*/
++static struct platform_driver ohci_hcd_tmio_driver;
++
++static int __devinit ohci_hcd_tmio_drv_probe(struct platform_device *dev)
++{
++	struct mfd_cell *cell = dev->dev.platform_data;
++	struct resource *regs = platform_get_resource(dev, IORESOURCE_MEM, 0);
++	struct resource *config = platform_get_resource(dev, IORESOURCE_MEM, 1);
++	struct resource *sram = platform_get_resource(dev, IORESOURCE_MEM, 2);
++	int irq = platform_get_irq(dev, 0);
++	struct tmio_hcd *tmio;
++	struct ohci_hcd *ohci;
++	struct usb_hcd *hcd;
++	int ret;
++
++	if (usb_disabled())
++		return -ENODEV;
++
++	if (!cell)
++		return -EINVAL;
++
++	hcd = usb_create_hcd(&ohci_tmio_hc_driver, &dev->dev, dev->dev.bus_id);
++	if (!hcd) {
++		ret = -ENOMEM;
++		goto err_usb_create_hcd;
++	}
++
++	hcd->rsrc_start = regs->start;
++	hcd->rsrc_len = regs->end - regs->start + 1;
++
++	tmio = hcd_to_tmio(hcd);
++
++	spin_lock_init(&tmio->lock);
++
++	tmio->ccr = ioremap(config->start, config->end - config->start + 1);
++	if (!tmio->ccr) {
++		ret = -ENOMEM;
++		goto err_ioremap_ccr;
++	}
++
++	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
++	if (!hcd->regs) {
++		ret = -ENOMEM;
++		goto err_ioremap_regs;
++	}
++
++	if (!dma_declare_coherent_memory(&dev->dev, sram->start,
++				sram->start,
++				sram->end - sram->start + 1,
++				DMA_MEMORY_MAP | DMA_MEMORY_EXCLUSIVE)) {
++		ret = -EBUSY;
++		goto err_dma_declare;
++	}
++
++	if (cell->enable) {
++		ret = cell->enable(dev);
++		if (ret)
++			goto err_enable;
++	}
++
++	tmio_start_hc(dev);
++	ohci = hcd_to_ohci(hcd);
++	ohci_hcd_init(ohci);
++
++	ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
++	if (ret)
++		goto err_add_hcd;
++
++	if (ret == 0)
++		return ret;
++
++	usb_remove_hcd(hcd);
++
++err_add_hcd:
++	tmio_stop_hc(dev);
++	if (cell->disable)
++		cell->disable(dev);
++err_enable:
++	dma_release_declared_memory(&dev->dev);
++err_dma_declare:
++	iounmap(hcd->regs);
++err_ioremap_regs:
++	iounmap(tmio->ccr);
++err_ioremap_ccr:
++	usb_put_hcd(hcd);
++err_usb_create_hcd:
++
++	return ret;
++}
++
++static int __devexit ohci_hcd_tmio_drv_remove(struct platform_device *dev)
++{
++	struct usb_hcd *hcd = platform_get_drvdata(dev);
++	struct tmio_hcd *tmio = hcd_to_tmio(hcd);
++	struct mfd_cell *cell = dev->dev.platform_data;
++
++	usb_remove_hcd(hcd);
++	tmio_stop_hc(dev);
++	if (cell->disable)
++		cell->disable(dev);
++	dma_release_declared_memory(&dev->dev);
++	iounmap(hcd->regs);
++	iounmap(tmio->ccr);
++	usb_put_hcd(hcd);
++
++	platform_set_drvdata(dev, NULL);
++
++	return 0;
++}
++
++#ifdef CONFIG_PM
++static int ohci_hcd_tmio_drv_suspend(struct platform_device *dev, pm_message_t state)
++{
++	struct mfd_cell *cell = dev->dev.platform_data;
++	struct usb_hcd *hcd = platform_get_drvdata(dev);
++	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
++	struct tmio_hcd *tmio = hcd_to_tmio(hcd);
++	unsigned long flags;
++	u8 misc;
++	int ret;
++
++	if (time_before(jiffies, ohci->next_statechange))
++		msleep(5);
++	ohci->next_statechange = jiffies;
++
++	spin_lock_irqsave(&tmio->lock, flags);
++
++	misc = tmio_ioread8(tmio->ccr + CCR_MISC);
++	misc |= 1 << 3; /* USSUSP */
++	tmio_iowrite8(misc, tmio->ccr + CCR_MISC);
++
++	spin_unlock_irqrestore(&tmio->lock, flags);
++
++	if (cell->suspend) {
++		ret = cell->suspend(dev);
++		if (ret)
++			return ret;
++	}
++
++	hcd->state = HC_STATE_SUSPENDED;
++
++	return 0;
++}
++
++static int ohci_hcd_tmio_drv_resume(struct platform_device *dev)
++{
++	struct mfd_cell *cell = dev->dev.platform_data;
++	struct usb_hcd *hcd = platform_get_drvdata(dev);
++	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
++	struct tmio_hcd *tmio = hcd_to_tmio(hcd);
++	unsigned long flags;
++	u8 misc;
++	int ret;
++
++	if (time_before(jiffies, ohci->next_statechange))
++		msleep(5);
++	ohci->next_statechange = jiffies;
++
++	if (cell->resume) {
++		ret = cell->resume(dev);
++		if (ret)
++			return ret;
++	}
++
++	tmio_start_hc(dev);
++
++	spin_lock_irqsave(&tmio->lock, flags);
++
++	misc = tmio_ioread8(tmio->ccr + CCR_MISC);
++	misc &= ~(1 << 3); /* USSUSP */
++	tmio_iowrite8(misc, tmio->ccr + CCR_MISC);
++
++	spin_unlock_irqrestore(&tmio->lock, flags);
++
++	ohci_finish_controller_resume(hcd);
++
++	return 0;
++}
++#else
++#define ohci_hcd_tmio_drv_suspend NULL
++#define ohci_hcd_tmio_drv_resume NULL
++#endif
++
++static struct platform_driver ohci_hcd_tmio_driver = {
++	.probe		= ohci_hcd_tmio_drv_probe,
++	.remove		= __devexit_p(ohci_hcd_tmio_drv_remove),
++	.shutdown	= usb_hcd_platform_shutdown,
++	.suspend	= ohci_hcd_tmio_drv_suspend,
++	.resume		= ohci_hcd_tmio_drv_resume,
++	.driver		= {
++		.name	= "tmio-ohci",
++		.owner	= THIS_MODULE,
++	},
++};
+--- a/drivers/usb/Kconfig
++++ b/drivers/usb/Kconfig
+@@ -37,6 +37,7 @@ config USB_ARCH_HAS_OHCI
+ 	default y if ARCH_EP93XX
+ 	default y if ARCH_AT91
+ 	default y if ARCH_PNX4008
++	default y if MFD_TC6393XB
+ 	# PPC:
+ 	default y if STB03xxx
+ 	default y if PPC_MPC52xx
author	Greg Kroah-Hartman <gregkh@suse.de>	2008-10-08 14:24:28 -0700
committer	Greg Kroah-Hartman <gregkh@suse.de>	2008-10-08 14:24:28 -0700
commit	1bf94aacd8c94f985c573402d7a5eab548aaffd4 (patch)
tree	50b43bb3b8abd67842df7e120b540408e7f798cd
parent	1240ba9862f462ed5d39d8682081a30eddc764eb (diff)
download	patches-1bf94aacd8c94f985c573402d7a5eab548aaffd4.tar.gz