cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

sl811-hcd.c (46497B)


      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * SL811HS HCD (Host Controller Driver) for USB.
      4 *
      5 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
      6 * Copyright (C) 2004-2005 David Brownell
      7 *
      8 * Periodic scheduling is based on Roman's OHCI code
      9 * 	Copyright (C) 1999 Roman Weissgaerber
     10 *
     11 * The SL811HS controller handles host side USB (like the SL11H, but with
     12 * another register set and SOF generation) as well as peripheral side USB
     13 * (like the SL811S).  This driver version doesn't implement the Gadget API
     14 * for the peripheral role; or OTG (that'd need much external circuitry).
     15 *
     16 * For documentation, see the SL811HS spec and the "SL811HS Embedded Host"
     17 * document (providing significant pieces missing from that spec); plus
     18 * the SL811S spec if you want peripheral side info.
     19 */
     20
     21/*
     22 * Status:  Passed basic stress testing, works with hubs, mice, keyboards,
     23 * and usb-storage.
     24 *
     25 * TODO:
     26 * - usb suspend/resume triggered by sl811
     27 * - various issues noted in the code
     28 * - performance work; use both register banks; ...
     29 * - use urb->iso_frame_desc[] with ISO transfers
     30 */
     31
     32#undef	VERBOSE
     33#undef	PACKET_TRACE
     34
     35#include <linux/module.h>
     36#include <linux/moduleparam.h>
     37#include <linux/kernel.h>
     38#include <linux/delay.h>
     39#include <linux/ioport.h>
     40#include <linux/sched.h>
     41#include <linux/slab.h>
     42#include <linux/errno.h>
     43#include <linux/timer.h>
     44#include <linux/list.h>
     45#include <linux/interrupt.h>
     46#include <linux/usb.h>
     47#include <linux/usb/sl811.h>
     48#include <linux/usb/hcd.h>
     49#include <linux/platform_device.h>
     50#include <linux/prefetch.h>
     51#include <linux/debugfs.h>
     52#include <linux/seq_file.h>
     53
     54#include <asm/io.h>
     55#include <asm/irq.h>
     56#include <asm/byteorder.h>
     57#include <asm/unaligned.h>
     58
     59#include "sl811.h"
     60
     61
     62MODULE_DESCRIPTION("SL811HS USB Host Controller Driver");
     63MODULE_LICENSE("GPL");
     64MODULE_ALIAS("platform:sl811-hcd");
     65
     66#define DRIVER_VERSION	"19 May 2005"
     67
     68/* for now, use only one transfer register bank */
     69#undef	USE_B
     70
     71// #define	QUIRK2
     72#define	QUIRK3
     73
     74static const char hcd_name[] = "sl811-hcd";
     75
     76/*-------------------------------------------------------------------------*/
     77
     78static void port_power(struct sl811 *sl811, int is_on)
     79{
     80	struct usb_hcd	*hcd = sl811_to_hcd(sl811);
     81
     82	/* hub is inactive unless the port is powered */
     83	if (is_on) {
     84		if (sl811->port1 & USB_PORT_STAT_POWER)
     85			return;
     86
     87		sl811->port1 = USB_PORT_STAT_POWER;
     88		sl811->irq_enable = SL11H_INTMASK_INSRMV;
     89	} else {
     90		sl811->port1 = 0;
     91		sl811->irq_enable = 0;
     92		hcd->state = HC_STATE_HALT;
     93	}
     94	sl811->ctrl1 = 0;
     95	sl811_write(sl811, SL11H_IRQ_ENABLE, 0);
     96	sl811_write(sl811, SL11H_IRQ_STATUS, ~0);
     97
     98	if (sl811->board && sl811->board->port_power) {
     99		/* switch VBUS, at 500mA unless hub power budget gets set */
    100		dev_dbg(hcd->self.controller, "power %s\n",
    101			is_on ? "on" : "off");
    102		sl811->board->port_power(hcd->self.controller, is_on);
    103	}
    104
    105	/* reset as thoroughly as we can */
    106	if (sl811->board && sl811->board->reset)
    107		sl811->board->reset(hcd->self.controller);
    108	else {
    109		sl811_write(sl811, SL11H_CTLREG1, SL11H_CTL1MASK_SE0);
    110		mdelay(20);
    111	}
    112
    113	sl811_write(sl811, SL11H_IRQ_ENABLE, 0);
    114	sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
    115	sl811_write(sl811, SL811HS_CTLREG2, SL811HS_CTL2_INIT);
    116	sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
    117
    118	// if !is_on, put into lowpower mode now
    119}
    120
    121/*-------------------------------------------------------------------------*/
    122
    123/* This is a PIO-only HCD.  Queueing appends URBs to the endpoint's queue,
    124 * and may start I/O.  Endpoint queues are scanned during completion irq
    125 * handlers (one per packet: ACK, NAK, faults, etc) and urb cancellation.
    126 *
    127 * Using an external DMA engine to copy a packet at a time could work,
    128 * though setup/teardown costs may be too big to make it worthwhile.
    129 */
    130
    131/* SETUP starts a new control request.  Devices are not allowed to
    132 * STALL or NAK these; they must cancel any pending control requests.
    133 */
    134static void setup_packet(
    135	struct sl811		*sl811,
    136	struct sl811h_ep	*ep,
    137	struct urb		*urb,
    138	u8			bank,
    139	u8			control
    140)
    141{
    142	u8			addr;
    143	u8			len;
    144	void __iomem		*data_reg;
    145
    146	addr = SL811HS_PACKET_BUF(bank == 0);
    147	len = sizeof(struct usb_ctrlrequest);
    148	data_reg = sl811->data_reg;
    149	sl811_write_buf(sl811, addr, urb->setup_packet, len);
    150
    151	/* autoincrementing */
    152	sl811_write(sl811, bank + SL11H_BUFADDRREG, addr);
    153	writeb(len, data_reg);
    154	writeb(SL_SETUP /* | ep->epnum */, data_reg);
    155	writeb(usb_pipedevice(urb->pipe), data_reg);
    156
    157	/* always OUT/data0 */
    158	sl811_write(sl811, bank + SL11H_HOSTCTLREG,
    159			control | SL11H_HCTLMASK_OUT);
    160	ep->length = 0;
    161	PACKET("SETUP qh%p\n", ep);
    162}
    163
    164/* STATUS finishes control requests, often after IN or OUT data packets */
    165static void status_packet(
    166	struct sl811		*sl811,
    167	struct sl811h_ep	*ep,
    168	struct urb		*urb,
    169	u8			bank,
    170	u8			control
    171)
    172{
    173	int			do_out;
    174	void __iomem		*data_reg;
    175
    176	do_out = urb->transfer_buffer_length && usb_pipein(urb->pipe);
    177	data_reg = sl811->data_reg;
    178
    179	/* autoincrementing */
    180	sl811_write(sl811, bank + SL11H_BUFADDRREG, 0);
    181	writeb(0, data_reg);
    182	writeb((do_out ? SL_OUT : SL_IN) /* | ep->epnum */, data_reg);
    183	writeb(usb_pipedevice(urb->pipe), data_reg);
    184
    185	/* always data1; sometimes IN */
    186	control |= SL11H_HCTLMASK_TOGGLE;
    187	if (do_out)
    188		control |= SL11H_HCTLMASK_OUT;
    189	sl811_write(sl811, bank + SL11H_HOSTCTLREG, control);
    190	ep->length = 0;
    191	PACKET("STATUS%s/%s qh%p\n", ep->nak_count ? "/retry" : "",
    192			do_out ? "out" : "in", ep);
    193}
    194
    195/* IN packets can be used with any type of endpoint. here we just
    196 * start the transfer, data from the peripheral may arrive later.
    197 * urb->iso_frame_desc is currently ignored here...
    198 */
    199static void in_packet(
    200	struct sl811		*sl811,
    201	struct sl811h_ep	*ep,
    202	struct urb		*urb,
    203	u8			bank,
    204	u8			control
    205)
    206{
    207	u8			addr;
    208	u8			len;
    209	void __iomem		*data_reg;
    210
    211	/* avoid losing data on overflow */
    212	len = ep->maxpacket;
    213	addr = SL811HS_PACKET_BUF(bank == 0);
    214	if (!(control & SL11H_HCTLMASK_ISOCH)
    215			&& usb_gettoggle(urb->dev, ep->epnum, 0))
    216		control |= SL11H_HCTLMASK_TOGGLE;
    217	data_reg = sl811->data_reg;
    218
    219	/* autoincrementing */
    220	sl811_write(sl811, bank + SL11H_BUFADDRREG, addr);
    221	writeb(len, data_reg);
    222	writeb(SL_IN | ep->epnum, data_reg);
    223	writeb(usb_pipedevice(urb->pipe), data_reg);
    224
    225	sl811_write(sl811, bank + SL11H_HOSTCTLREG, control);
    226	ep->length = min_t(u32, len,
    227			urb->transfer_buffer_length - urb->actual_length);
    228	PACKET("IN%s/%d qh%p len%d\n", ep->nak_count ? "/retry" : "",
    229			!!usb_gettoggle(urb->dev, ep->epnum, 0), ep, len);
    230}
    231
    232/* OUT packets can be used with any type of endpoint.
    233 * urb->iso_frame_desc is currently ignored here...
    234 */
    235static void out_packet(
    236	struct sl811		*sl811,
    237	struct sl811h_ep	*ep,
    238	struct urb		*urb,
    239	u8			bank,
    240	u8			control
    241)
    242{
    243	void			*buf;
    244	u8			addr;
    245	u8			len;
    246	void __iomem		*data_reg;
    247
    248	buf = urb->transfer_buffer + urb->actual_length;
    249	prefetch(buf);
    250
    251	len = min_t(u32, ep->maxpacket,
    252			urb->transfer_buffer_length - urb->actual_length);
    253
    254	if (!(control & SL11H_HCTLMASK_ISOCH)
    255			&& usb_gettoggle(urb->dev, ep->epnum, 1))
    256		control |= SL11H_HCTLMASK_TOGGLE;
    257	addr = SL811HS_PACKET_BUF(bank == 0);
    258	data_reg = sl811->data_reg;
    259
    260	sl811_write_buf(sl811, addr, buf, len);
    261
    262	/* autoincrementing */
    263	sl811_write(sl811, bank + SL11H_BUFADDRREG, addr);
    264	writeb(len, data_reg);
    265	writeb(SL_OUT | ep->epnum, data_reg);
    266	writeb(usb_pipedevice(urb->pipe), data_reg);
    267
    268	sl811_write(sl811, bank + SL11H_HOSTCTLREG,
    269			control | SL11H_HCTLMASK_OUT);
    270	ep->length = len;
    271	PACKET("OUT%s/%d qh%p len%d\n", ep->nak_count ? "/retry" : "",
    272			!!usb_gettoggle(urb->dev, ep->epnum, 1), ep, len);
    273}
    274
    275/*-------------------------------------------------------------------------*/
    276
    277/* caller updates on-chip enables later */
    278
    279static inline void sofirq_on(struct sl811 *sl811)
    280{
    281	if (sl811->irq_enable & SL11H_INTMASK_SOFINTR)
    282		return;
    283	dev_dbg(sl811_to_hcd(sl811)->self.controller, "sof irq on\n");
    284	sl811->irq_enable |= SL11H_INTMASK_SOFINTR;
    285}
    286
    287static inline void sofirq_off(struct sl811 *sl811)
    288{
    289	if (!(sl811->irq_enable & SL11H_INTMASK_SOFINTR))
    290		return;
    291	dev_dbg(sl811_to_hcd(sl811)->self.controller, "sof irq off\n");
    292	sl811->irq_enable &= ~SL11H_INTMASK_SOFINTR;
    293}
    294
    295/*-------------------------------------------------------------------------*/
    296
    297/* pick the next endpoint for a transaction, and issue it.
    298 * frames start with periodic transfers (after whatever is pending
    299 * from the previous frame), and the rest of the time is async
    300 * transfers, scheduled round-robin.
    301 */
    302static struct sl811h_ep	*start(struct sl811 *sl811, u8 bank)
    303{
    304	struct sl811h_ep	*ep;
    305	struct urb		*urb;
    306	int			fclock;
    307	u8			control;
    308
    309	/* use endpoint at schedule head */
    310	if (sl811->next_periodic) {
    311		ep = sl811->next_periodic;
    312		sl811->next_periodic = ep->next;
    313	} else {
    314		if (sl811->next_async)
    315			ep = sl811->next_async;
    316		else if (!list_empty(&sl811->async))
    317			ep = container_of(sl811->async.next,
    318					struct sl811h_ep, schedule);
    319		else {
    320			/* could set up the first fullspeed periodic
    321			 * transfer for the next frame ...
    322			 */
    323			return NULL;
    324		}
    325
    326#ifdef USE_B
    327		if ((bank && sl811->active_b == ep) || sl811->active_a == ep)
    328			return NULL;
    329#endif
    330
    331		if (ep->schedule.next == &sl811->async)
    332			sl811->next_async = NULL;
    333		else
    334			sl811->next_async = container_of(ep->schedule.next,
    335					struct sl811h_ep, schedule);
    336	}
    337
    338	if (unlikely(list_empty(&ep->hep->urb_list))) {
    339		dev_dbg(sl811_to_hcd(sl811)->self.controller,
    340			"empty %p queue?\n", ep);
    341		return NULL;
    342	}
    343
    344	urb = container_of(ep->hep->urb_list.next, struct urb, urb_list);
    345	control = ep->defctrl;
    346
    347	/* if this frame doesn't have enough time left to transfer this
    348	 * packet, wait till the next frame.  too-simple algorithm...
    349	 */
    350	fclock = sl811_read(sl811, SL11H_SOFTMRREG) << 6;
    351	fclock -= 100;		/* setup takes not much time */
    352	if (urb->dev->speed == USB_SPEED_LOW) {
    353		if (control & SL11H_HCTLMASK_PREAMBLE) {
    354			/* also note erratum 1: some hubs won't work */
    355			fclock -= 800;
    356		}
    357		fclock -= ep->maxpacket << 8;
    358
    359		/* erratum 2: AFTERSOF only works for fullspeed */
    360		if (fclock < 0) {
    361			if (ep->period)
    362				sl811->stat_overrun++;
    363			sofirq_on(sl811);
    364			return NULL;
    365		}
    366	} else {
    367		fclock -= 12000 / 19;	/* 19 64byte packets/msec */
    368		if (fclock < 0) {
    369			if (ep->period)
    370				sl811->stat_overrun++;
    371			control |= SL11H_HCTLMASK_AFTERSOF;
    372
    373		/* throttle bulk/control irq noise */
    374		} else if (ep->nak_count)
    375			control |= SL11H_HCTLMASK_AFTERSOF;
    376	}
    377
    378
    379	switch (ep->nextpid) {
    380	case USB_PID_IN:
    381		in_packet(sl811, ep, urb, bank, control);
    382		break;
    383	case USB_PID_OUT:
    384		out_packet(sl811, ep, urb, bank, control);
    385		break;
    386	case USB_PID_SETUP:
    387		setup_packet(sl811, ep, urb, bank, control);
    388		break;
    389	case USB_PID_ACK:		/* for control status */
    390		status_packet(sl811, ep, urb, bank, control);
    391		break;
    392	default:
    393		dev_dbg(sl811_to_hcd(sl811)->self.controller,
    394			"bad ep%p pid %02x\n", ep, ep->nextpid);
    395		ep = NULL;
    396	}
    397	return ep;
    398}
    399
    400#define MIN_JIFFIES	((msecs_to_jiffies(2) > 1) ? msecs_to_jiffies(2) : 2)
    401
    402static inline void start_transfer(struct sl811 *sl811)
    403{
    404	if (sl811->port1 & USB_PORT_STAT_SUSPEND)
    405		return;
    406	if (sl811->active_a == NULL) {
    407		sl811->active_a = start(sl811, SL811_EP_A(SL811_HOST_BUF));
    408		if (sl811->active_a != NULL)
    409			sl811->jiffies_a = jiffies + MIN_JIFFIES;
    410	}
    411#ifdef USE_B
    412	if (sl811->active_b == NULL) {
    413		sl811->active_b = start(sl811, SL811_EP_B(SL811_HOST_BUF));
    414		if (sl811->active_b != NULL)
    415			sl811->jiffies_b = jiffies + MIN_JIFFIES;
    416	}
    417#endif
    418}
    419
    420static void finish_request(
    421	struct sl811		*sl811,
    422	struct sl811h_ep	*ep,
    423	struct urb		*urb,
    424	int			status
    425) __releases(sl811->lock) __acquires(sl811->lock)
    426{
    427	unsigned		i;
    428
    429	if (usb_pipecontrol(urb->pipe))
    430		ep->nextpid = USB_PID_SETUP;
    431
    432	usb_hcd_unlink_urb_from_ep(sl811_to_hcd(sl811), urb);
    433	spin_unlock(&sl811->lock);
    434	usb_hcd_giveback_urb(sl811_to_hcd(sl811), urb, status);
    435	spin_lock(&sl811->lock);
    436
    437	/* leave active endpoints in the schedule */
    438	if (!list_empty(&ep->hep->urb_list))
    439		return;
    440
    441	/* async deschedule? */
    442	if (!list_empty(&ep->schedule)) {
    443		list_del_init(&ep->schedule);
    444		if (ep == sl811->next_async)
    445			sl811->next_async = NULL;
    446		return;
    447	}
    448
    449	/* periodic deschedule */
    450	dev_dbg(sl811_to_hcd(sl811)->self.controller,
    451		"deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
    452	for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
    453		struct sl811h_ep	*temp;
    454		struct sl811h_ep	**prev = &sl811->periodic[i];
    455
    456		while (*prev && ((temp = *prev) != ep))
    457			prev = &temp->next;
    458		if (*prev)
    459			*prev = ep->next;
    460		sl811->load[i] -= ep->load;
    461	}
    462	ep->branch = PERIODIC_SIZE;
    463	sl811->periodic_count--;
    464	sl811_to_hcd(sl811)->self.bandwidth_allocated
    465		-= ep->load / ep->period;
    466	if (ep == sl811->next_periodic)
    467		sl811->next_periodic = ep->next;
    468
    469	/* we might turn SOFs back on again for the async schedule */
    470	if (sl811->periodic_count == 0)
    471		sofirq_off(sl811);
    472}
    473
    474static void
    475done(struct sl811 *sl811, struct sl811h_ep *ep, u8 bank)
    476{
    477	u8			status;
    478	struct urb		*urb;
    479	int			urbstat = -EINPROGRESS;
    480
    481	if (unlikely(!ep))
    482		return;
    483
    484	status = sl811_read(sl811, bank + SL11H_PKTSTATREG);
    485
    486	urb = container_of(ep->hep->urb_list.next, struct urb, urb_list);
    487
    488	/* we can safely ignore NAKs */
    489	if (status & SL11H_STATMASK_NAK) {
    490		// PACKET("...NAK_%02x qh%p\n", bank, ep);
    491		if (!ep->period)
    492			ep->nak_count++;
    493		ep->error_count = 0;
    494
    495	/* ACK advances transfer, toggle, and maybe queue */
    496	} else if (status & SL11H_STATMASK_ACK) {
    497		struct usb_device	*udev = urb->dev;
    498		int			len;
    499		unsigned char		*buf;
    500
    501		/* urb->iso_frame_desc is currently ignored here... */
    502
    503		ep->nak_count = ep->error_count = 0;
    504		switch (ep->nextpid) {
    505		case USB_PID_OUT:
    506			// PACKET("...ACK/out_%02x qh%p\n", bank, ep);
    507			urb->actual_length += ep->length;
    508			usb_dotoggle(udev, ep->epnum, 1);
    509			if (urb->actual_length
    510					== urb->transfer_buffer_length) {
    511				if (usb_pipecontrol(urb->pipe))
    512					ep->nextpid = USB_PID_ACK;
    513
    514				/* some bulk protocols terminate OUT transfers
    515				 * by a short packet, using ZLPs not padding.
    516				 */
    517				else if (ep->length < ep->maxpacket
    518						|| !(urb->transfer_flags
    519							& URB_ZERO_PACKET))
    520					urbstat = 0;
    521			}
    522			break;
    523		case USB_PID_IN:
    524			// PACKET("...ACK/in_%02x qh%p\n", bank, ep);
    525			buf = urb->transfer_buffer + urb->actual_length;
    526			prefetchw(buf);
    527			len = ep->maxpacket - sl811_read(sl811,
    528						bank + SL11H_XFERCNTREG);
    529			if (len > ep->length) {
    530				len = ep->length;
    531				urbstat = -EOVERFLOW;
    532			}
    533			urb->actual_length += len;
    534			sl811_read_buf(sl811, SL811HS_PACKET_BUF(bank == 0),
    535					buf, len);
    536			usb_dotoggle(udev, ep->epnum, 0);
    537			if (urbstat == -EINPROGRESS &&
    538					(len < ep->maxpacket ||
    539						urb->actual_length ==
    540						urb->transfer_buffer_length)) {
    541				if (usb_pipecontrol(urb->pipe))
    542					ep->nextpid = USB_PID_ACK;
    543				else
    544					urbstat = 0;
    545			}
    546			break;
    547		case USB_PID_SETUP:
    548			// PACKET("...ACK/setup_%02x qh%p\n", bank, ep);
    549			if (urb->transfer_buffer_length == urb->actual_length)
    550				ep->nextpid = USB_PID_ACK;
    551			else if (usb_pipeout(urb->pipe)) {
    552				usb_settoggle(udev, 0, 1, 1);
    553				ep->nextpid = USB_PID_OUT;
    554			} else {
    555				usb_settoggle(udev, 0, 0, 1);
    556				ep->nextpid = USB_PID_IN;
    557			}
    558			break;
    559		case USB_PID_ACK:
    560			// PACKET("...ACK/status_%02x qh%p\n", bank, ep);
    561			urbstat = 0;
    562			break;
    563		}
    564
    565	/* STALL stops all transfers */
    566	} else if (status & SL11H_STATMASK_STALL) {
    567		PACKET("...STALL_%02x qh%p\n", bank, ep);
    568		ep->nak_count = ep->error_count = 0;
    569		urbstat = -EPIPE;
    570
    571	/* error? retry, until "3 strikes" */
    572	} else if (++ep->error_count >= 3) {
    573		if (status & SL11H_STATMASK_TMOUT)
    574			urbstat = -ETIME;
    575		else if (status & SL11H_STATMASK_OVF)
    576			urbstat = -EOVERFLOW;
    577		else
    578			urbstat = -EPROTO;
    579		ep->error_count = 0;
    580		PACKET("...3STRIKES_%02x %02x qh%p stat %d\n",
    581				bank, status, ep, urbstat);
    582	}
    583
    584	if (urbstat != -EINPROGRESS || urb->unlinked)
    585		finish_request(sl811, ep, urb, urbstat);
    586}
    587
    588static inline u8 checkdone(struct sl811 *sl811)
    589{
    590	u8	ctl;
    591	u8	irqstat = 0;
    592
    593	if (sl811->active_a && time_before_eq(sl811->jiffies_a, jiffies)) {
    594		ctl = sl811_read(sl811, SL811_EP_A(SL11H_HOSTCTLREG));
    595		if (ctl & SL11H_HCTLMASK_ARM)
    596			sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 0);
    597		dev_dbg(sl811_to_hcd(sl811)->self.controller,
    598			"%s DONE_A: ctrl %02x sts %02x\n",
    599			(ctl & SL11H_HCTLMASK_ARM) ? "timeout" : "lost",
    600			ctl,
    601			sl811_read(sl811, SL811_EP_A(SL11H_PKTSTATREG)));
    602		irqstat |= SL11H_INTMASK_DONE_A;
    603	}
    604#ifdef	USE_B
    605	if (sl811->active_b && time_before_eq(sl811->jiffies_b, jiffies)) {
    606		ctl = sl811_read(sl811, SL811_EP_B(SL11H_HOSTCTLREG));
    607		if (ctl & SL11H_HCTLMASK_ARM)
    608			sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 0);
    609		dev_dbg(sl811_to_hcd(sl811)->self.controller,
    610			"%s DONE_B: ctrl %02x sts %02x\n",
    611			(ctl & SL11H_HCTLMASK_ARM) ? "timeout" : "lost",
    612			ctl,
    613			sl811_read(sl811, SL811_EP_B(SL11H_PKTSTATREG)));
    614		irqstat |= SL11H_INTMASK_DONE_A;
    615	}
    616#endif
    617	return irqstat;
    618}
    619
    620static irqreturn_t sl811h_irq(struct usb_hcd *hcd)
    621{
    622	struct sl811	*sl811 = hcd_to_sl811(hcd);
    623	u8		irqstat;
    624	irqreturn_t	ret = IRQ_NONE;
    625	unsigned	retries = 5;
    626
    627	spin_lock(&sl811->lock);
    628
    629retry:
    630	irqstat = sl811_read(sl811, SL11H_IRQ_STATUS) & ~SL11H_INTMASK_DP;
    631	if (irqstat) {
    632		sl811_write(sl811, SL11H_IRQ_STATUS, irqstat);
    633		irqstat &= sl811->irq_enable;
    634	}
    635
    636#ifdef	QUIRK2
    637	/* this may no longer be necessary ... */
    638	if (irqstat == 0) {
    639		irqstat = checkdone(sl811);
    640		if (irqstat)
    641			sl811->stat_lost++;
    642	}
    643#endif
    644
    645	/* USB packets, not necessarily handled in the order they're
    646	 * issued ... that's fine if they're different endpoints.
    647	 */
    648	if (irqstat & SL11H_INTMASK_DONE_A) {
    649		done(sl811, sl811->active_a, SL811_EP_A(SL811_HOST_BUF));
    650		sl811->active_a = NULL;
    651		sl811->stat_a++;
    652	}
    653#ifdef USE_B
    654	if (irqstat & SL11H_INTMASK_DONE_B) {
    655		done(sl811, sl811->active_b, SL811_EP_B(SL811_HOST_BUF));
    656		sl811->active_b = NULL;
    657		sl811->stat_b++;
    658	}
    659#endif
    660	if (irqstat & SL11H_INTMASK_SOFINTR) {
    661		unsigned index;
    662
    663		index = sl811->frame++ % (PERIODIC_SIZE - 1);
    664		sl811->stat_sof++;
    665
    666		/* be graceful about almost-inevitable periodic schedule
    667		 * overruns:  continue the previous frame's transfers iff
    668		 * this one has nothing scheduled.
    669		 */
    670		if (sl811->next_periodic) {
    671			// dev_err(hcd->self.controller, "overrun to slot %d\n", index);
    672			sl811->stat_overrun++;
    673		}
    674		if (sl811->periodic[index])
    675			sl811->next_periodic = sl811->periodic[index];
    676	}
    677
    678	/* hub_wq manages debouncing and wakeup */
    679	if (irqstat & SL11H_INTMASK_INSRMV) {
    680		sl811->stat_insrmv++;
    681
    682		/* most stats are reset for each VBUS session */
    683		sl811->stat_wake = 0;
    684		sl811->stat_sof = 0;
    685		sl811->stat_a = 0;
    686		sl811->stat_b = 0;
    687		sl811->stat_lost = 0;
    688
    689		sl811->ctrl1 = 0;
    690		sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
    691
    692		sl811->irq_enable = SL11H_INTMASK_INSRMV;
    693		sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
    694
    695		/* usbcore nukes other pending transactions on disconnect */
    696		if (sl811->active_a) {
    697			sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 0);
    698			finish_request(sl811, sl811->active_a,
    699				container_of(sl811->active_a
    700						->hep->urb_list.next,
    701					struct urb, urb_list),
    702				-ESHUTDOWN);
    703			sl811->active_a = NULL;
    704		}
    705#ifdef	USE_B
    706		if (sl811->active_b) {
    707			sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 0);
    708			finish_request(sl811, sl811->active_b,
    709				container_of(sl811->active_b
    710						->hep->urb_list.next,
    711					struct urb, urb_list),
    712				NULL, -ESHUTDOWN);
    713			sl811->active_b = NULL;
    714		}
    715#endif
    716
    717		/* port status seems weird until after reset, so
    718		 * force the reset and make hub_wq clean up later.
    719		 */
    720		if (irqstat & SL11H_INTMASK_RD)
    721			sl811->port1 &= ~USB_PORT_STAT_CONNECTION;
    722		else
    723			sl811->port1 |= USB_PORT_STAT_CONNECTION;
    724
    725		sl811->port1 |= USB_PORT_STAT_C_CONNECTION << 16;
    726
    727	} else if (irqstat & SL11H_INTMASK_RD) {
    728		if (sl811->port1 & USB_PORT_STAT_SUSPEND) {
    729			dev_dbg(hcd->self.controller, "wakeup\n");
    730			sl811->port1 |= USB_PORT_STAT_C_SUSPEND << 16;
    731			sl811->stat_wake++;
    732		} else
    733			irqstat &= ~SL11H_INTMASK_RD;
    734	}
    735
    736	if (irqstat) {
    737		if (sl811->port1 & USB_PORT_STAT_ENABLE)
    738			start_transfer(sl811);
    739		ret = IRQ_HANDLED;
    740		if (retries--)
    741			goto retry;
    742	}
    743
    744	if (sl811->periodic_count == 0 && list_empty(&sl811->async))
    745		sofirq_off(sl811);
    746	sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
    747
    748	spin_unlock(&sl811->lock);
    749
    750	return ret;
    751}
    752
    753/*-------------------------------------------------------------------------*/
    754
    755/* usb 1.1 says max 90% of a frame is available for periodic transfers.
    756 * this driver doesn't promise that much since it's got to handle an
    757 * IRQ per packet; irq handling latencies also use up that time.
    758 *
    759 * NOTE:  the periodic schedule is a sparse tree, with the load for
    760 * each branch minimized.  see fig 3.5 in the OHCI spec for example.
    761 */
    762#define	MAX_PERIODIC_LOAD	500	/* out of 1000 usec */
    763
    764static int balance(struct sl811 *sl811, u16 period, u16 load)
    765{
    766	int	i, branch = -ENOSPC;
    767
    768	/* search for the least loaded schedule branch of that period
    769	 * which has enough bandwidth left unreserved.
    770	 */
    771	for (i = 0; i < period ; i++) {
    772		if (branch < 0 || sl811->load[branch] > sl811->load[i]) {
    773			int	j;
    774
    775			for (j = i; j < PERIODIC_SIZE; j += period) {
    776				if ((sl811->load[j] + load)
    777						> MAX_PERIODIC_LOAD)
    778					break;
    779			}
    780			if (j < PERIODIC_SIZE)
    781				continue;
    782			branch = i;
    783		}
    784	}
    785	return branch;
    786}
    787
    788/*-------------------------------------------------------------------------*/
    789
    790static int sl811h_urb_enqueue(
    791	struct usb_hcd		*hcd,
    792	struct urb		*urb,
    793	gfp_t			mem_flags
    794) {
    795	struct sl811		*sl811 = hcd_to_sl811(hcd);
    796	struct usb_device	*udev = urb->dev;
    797	unsigned int		pipe = urb->pipe;
    798	int			is_out = !usb_pipein(pipe);
    799	int			type = usb_pipetype(pipe);
    800	int			epnum = usb_pipeendpoint(pipe);
    801	struct sl811h_ep	*ep = NULL;
    802	unsigned long		flags;
    803	int			i;
    804	int			retval;
    805	struct usb_host_endpoint	*hep = urb->ep;
    806
    807#ifndef CONFIG_USB_SL811_HCD_ISO
    808	if (type == PIPE_ISOCHRONOUS)
    809		return -ENOSPC;
    810#endif
    811
    812	/* avoid all allocations within spinlocks */
    813	if (!hep->hcpriv) {
    814		ep = kzalloc(sizeof *ep, mem_flags);
    815		if (ep == NULL)
    816			return -ENOMEM;
    817	}
    818
    819	spin_lock_irqsave(&sl811->lock, flags);
    820
    821	/* don't submit to a dead or disabled port */
    822	if (!(sl811->port1 & USB_PORT_STAT_ENABLE)
    823			|| !HC_IS_RUNNING(hcd->state)) {
    824		retval = -ENODEV;
    825		kfree(ep);
    826		goto fail_not_linked;
    827	}
    828	retval = usb_hcd_link_urb_to_ep(hcd, urb);
    829	if (retval) {
    830		kfree(ep);
    831		goto fail_not_linked;
    832	}
    833
    834	if (hep->hcpriv) {
    835		kfree(ep);
    836		ep = hep->hcpriv;
    837	} else if (!ep) {
    838		retval = -ENOMEM;
    839		goto fail;
    840
    841	} else {
    842		INIT_LIST_HEAD(&ep->schedule);
    843		ep->udev = udev;
    844		ep->epnum = epnum;
    845		ep->maxpacket = usb_maxpacket(udev, urb->pipe);
    846		ep->defctrl = SL11H_HCTLMASK_ARM | SL11H_HCTLMASK_ENABLE;
    847		usb_settoggle(udev, epnum, is_out, 0);
    848
    849		if (type == PIPE_CONTROL)
    850			ep->nextpid = USB_PID_SETUP;
    851		else if (is_out)
    852			ep->nextpid = USB_PID_OUT;
    853		else
    854			ep->nextpid = USB_PID_IN;
    855
    856		if (ep->maxpacket > H_MAXPACKET) {
    857			/* iso packets up to 240 bytes could work... */
    858			dev_dbg(hcd->self.controller,
    859				"dev %d ep%d maxpacket %d\n", udev->devnum,
    860				epnum, ep->maxpacket);
    861			retval = -EINVAL;
    862			kfree(ep);
    863			goto fail;
    864		}
    865
    866		if (udev->speed == USB_SPEED_LOW) {
    867			/* send preamble for external hub? */
    868			if (!(sl811->ctrl1 & SL11H_CTL1MASK_LSPD))
    869				ep->defctrl |= SL11H_HCTLMASK_PREAMBLE;
    870		}
    871		switch (type) {
    872		case PIPE_ISOCHRONOUS:
    873		case PIPE_INTERRUPT:
    874			if (urb->interval > PERIODIC_SIZE)
    875				urb->interval = PERIODIC_SIZE;
    876			ep->period = urb->interval;
    877			ep->branch = PERIODIC_SIZE;
    878			if (type == PIPE_ISOCHRONOUS)
    879				ep->defctrl |= SL11H_HCTLMASK_ISOCH;
    880			ep->load = usb_calc_bus_time(udev->speed, !is_out,
    881						     type == PIPE_ISOCHRONOUS,
    882						     usb_maxpacket(udev, pipe))
    883					/ 1000;
    884			break;
    885		}
    886
    887		ep->hep = hep;
    888		hep->hcpriv = ep;
    889	}
    890
    891	/* maybe put endpoint into schedule */
    892	switch (type) {
    893	case PIPE_CONTROL:
    894	case PIPE_BULK:
    895		if (list_empty(&ep->schedule))
    896			list_add_tail(&ep->schedule, &sl811->async);
    897		break;
    898	case PIPE_ISOCHRONOUS:
    899	case PIPE_INTERRUPT:
    900		urb->interval = ep->period;
    901		if (ep->branch < PERIODIC_SIZE) {
    902			/* NOTE:  the phase is correct here, but the value
    903			 * needs offsetting by the transfer queue depth.
    904			 * All current drivers ignore start_frame, so this
    905			 * is unlikely to ever matter...
    906			 */
    907			urb->start_frame = (sl811->frame & (PERIODIC_SIZE - 1))
    908						+ ep->branch;
    909			break;
    910		}
    911
    912		retval = balance(sl811, ep->period, ep->load);
    913		if (retval < 0)
    914			goto fail;
    915		ep->branch = retval;
    916		retval = 0;
    917		urb->start_frame = (sl811->frame & (PERIODIC_SIZE - 1))
    918					+ ep->branch;
    919
    920		/* sort each schedule branch by period (slow before fast)
    921		 * to share the faster parts of the tree without needing
    922		 * dummy/placeholder nodes
    923		 */
    924		dev_dbg(hcd->self.controller, "schedule qh%d/%p branch %d\n",
    925			ep->period, ep, ep->branch);
    926		for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
    927			struct sl811h_ep	**prev = &sl811->periodic[i];
    928			struct sl811h_ep	*here = *prev;
    929
    930			while (here && ep != here) {
    931				if (ep->period > here->period)
    932					break;
    933				prev = &here->next;
    934				here = *prev;
    935			}
    936			if (ep != here) {
    937				ep->next = here;
    938				*prev = ep;
    939			}
    940			sl811->load[i] += ep->load;
    941		}
    942		sl811->periodic_count++;
    943		hcd->self.bandwidth_allocated += ep->load / ep->period;
    944		sofirq_on(sl811);
    945	}
    946
    947	urb->hcpriv = hep;
    948	start_transfer(sl811);
    949	sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
    950fail:
    951	if (retval)
    952		usb_hcd_unlink_urb_from_ep(hcd, urb);
    953fail_not_linked:
    954	spin_unlock_irqrestore(&sl811->lock, flags);
    955	return retval;
    956}
    957
    958static int sl811h_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
    959{
    960	struct sl811		*sl811 = hcd_to_sl811(hcd);
    961	struct usb_host_endpoint *hep;
    962	unsigned long		flags;
    963	struct sl811h_ep	*ep;
    964	int			retval;
    965
    966	spin_lock_irqsave(&sl811->lock, flags);
    967	retval = usb_hcd_check_unlink_urb(hcd, urb, status);
    968	if (retval)
    969		goto fail;
    970
    971	hep = urb->hcpriv;
    972	ep = hep->hcpriv;
    973	if (ep) {
    974		/* finish right away if this urb can't be active ...
    975		 * note that some drivers wrongly expect delays
    976		 */
    977		if (ep->hep->urb_list.next != &urb->urb_list) {
    978			/* not front of queue?  never active */
    979
    980		/* for active transfers, we expect an IRQ */
    981		} else if (sl811->active_a == ep) {
    982			if (time_before_eq(sl811->jiffies_a, jiffies)) {
    983				/* happens a lot with lowspeed?? */
    984				dev_dbg(hcd->self.controller,
    985					"giveup on DONE_A: ctrl %02x sts %02x\n",
    986					sl811_read(sl811,
    987						SL811_EP_A(SL11H_HOSTCTLREG)),
    988					sl811_read(sl811,
    989						SL811_EP_A(SL11H_PKTSTATREG)));
    990				sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG),
    991						0);
    992				sl811->active_a = NULL;
    993			} else
    994				urb = NULL;
    995#ifdef	USE_B
    996		} else if (sl811->active_b == ep) {
    997			if (time_before_eq(sl811->jiffies_a, jiffies)) {
    998				/* happens a lot with lowspeed?? */
    999				dev_dbg(hcd->self.controller,
   1000					"giveup on DONE_B: ctrl %02x sts %02x\n",
   1001					sl811_read(sl811,
   1002						SL811_EP_B(SL11H_HOSTCTLREG)),
   1003					sl811_read(sl811,
   1004						SL811_EP_B(SL11H_PKTSTATREG)));
   1005				sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG),
   1006						0);
   1007				sl811->active_b = NULL;
   1008			} else
   1009				urb = NULL;
   1010#endif
   1011		} else {
   1012			/* front of queue for inactive endpoint */
   1013		}
   1014
   1015		if (urb)
   1016			finish_request(sl811, ep, urb, 0);
   1017		else
   1018			dev_dbg(sl811_to_hcd(sl811)->self.controller,
   1019				"dequeue, urb %p active %s; wait4irq\n", urb,
   1020				(sl811->active_a == ep) ? "A" : "B");
   1021	} else
   1022		retval = -EINVAL;
   1023 fail:
   1024	spin_unlock_irqrestore(&sl811->lock, flags);
   1025	return retval;
   1026}
   1027
   1028static void
   1029sl811h_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep)
   1030{
   1031	struct sl811h_ep	*ep = hep->hcpriv;
   1032
   1033	if (!ep)
   1034		return;
   1035
   1036	/* assume we'd just wait for the irq */
   1037	if (!list_empty(&hep->urb_list))
   1038		msleep(3);
   1039	if (!list_empty(&hep->urb_list))
   1040		dev_warn(hcd->self.controller, "ep %p not empty?\n", ep);
   1041
   1042	kfree(ep);
   1043	hep->hcpriv = NULL;
   1044}
   1045
   1046static int
   1047sl811h_get_frame(struct usb_hcd *hcd)
   1048{
   1049	struct sl811 *sl811 = hcd_to_sl811(hcd);
   1050
   1051	/* wrong except while periodic transfers are scheduled;
   1052	 * never matches the on-the-wire frame;
   1053	 * subject to overruns.
   1054	 */
   1055	return sl811->frame;
   1056}
   1057
   1058
   1059/*-------------------------------------------------------------------------*/
   1060
   1061/* the virtual root hub timer IRQ checks for hub status */
   1062static int
   1063sl811h_hub_status_data(struct usb_hcd *hcd, char *buf)
   1064{
   1065	struct sl811 *sl811 = hcd_to_sl811(hcd);
   1066#ifdef	QUIRK3
   1067	unsigned long flags;
   1068
   1069	/* non-SMP HACK: use root hub timer as i/o watchdog
   1070	 * this seems essential when SOF IRQs aren't in use...
   1071	 */
   1072	local_irq_save(flags);
   1073	if (!timer_pending(&sl811->timer)) {
   1074		if (sl811h_irq( /* ~0, */ hcd) != IRQ_NONE)
   1075			sl811->stat_lost++;
   1076	}
   1077	local_irq_restore(flags);
   1078#endif
   1079
   1080	if (!(sl811->port1 & (0xffff << 16)))
   1081		return 0;
   1082
   1083	/* tell hub_wq port 1 changed */
   1084	*buf = (1 << 1);
   1085	return 1;
   1086}
   1087
   1088static void
   1089sl811h_hub_descriptor (
   1090	struct sl811			*sl811,
   1091	struct usb_hub_descriptor	*desc
   1092) {
   1093	u16		temp = 0;
   1094
   1095	desc->bDescriptorType = USB_DT_HUB;
   1096	desc->bHubContrCurrent = 0;
   1097
   1098	desc->bNbrPorts = 1;
   1099	desc->bDescLength = 9;
   1100
   1101	/* per-port power switching (gang of one!), or none */
   1102	desc->bPwrOn2PwrGood = 0;
   1103	if (sl811->board && sl811->board->port_power) {
   1104		desc->bPwrOn2PwrGood = sl811->board->potpg;
   1105		if (!desc->bPwrOn2PwrGood)
   1106			desc->bPwrOn2PwrGood = 10;
   1107		temp = HUB_CHAR_INDV_PORT_LPSM;
   1108	} else
   1109		temp = HUB_CHAR_NO_LPSM;
   1110
   1111	/* no overcurrent errors detection/handling */
   1112	temp |= HUB_CHAR_NO_OCPM;
   1113
   1114	desc->wHubCharacteristics = cpu_to_le16(temp);
   1115
   1116	/* ports removable, and legacy PortPwrCtrlMask */
   1117	desc->u.hs.DeviceRemovable[0] = 0 << 1;
   1118	desc->u.hs.DeviceRemovable[1] = ~0;
   1119}
   1120
   1121static void
   1122sl811h_timer(struct timer_list *t)
   1123{
   1124	struct sl811 	*sl811 = from_timer(sl811, t, timer);
   1125	unsigned long	flags;
   1126	u8		irqstat;
   1127	u8		signaling = sl811->ctrl1 & SL11H_CTL1MASK_FORCE;
   1128	const u32	mask = USB_PORT_STAT_CONNECTION
   1129				| USB_PORT_STAT_ENABLE
   1130				| USB_PORT_STAT_LOW_SPEED;
   1131
   1132	spin_lock_irqsave(&sl811->lock, flags);
   1133
   1134	/* stop special signaling */
   1135	sl811->ctrl1 &= ~SL11H_CTL1MASK_FORCE;
   1136	sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
   1137	udelay(3);
   1138
   1139	irqstat = sl811_read(sl811, SL11H_IRQ_STATUS);
   1140
   1141	switch (signaling) {
   1142	case SL11H_CTL1MASK_SE0:
   1143		dev_dbg(sl811_to_hcd(sl811)->self.controller, "end reset\n");
   1144		sl811->port1 = (USB_PORT_STAT_C_RESET << 16)
   1145				 | USB_PORT_STAT_POWER;
   1146		sl811->ctrl1 = 0;
   1147		/* don't wrongly ack RD */
   1148		if (irqstat & SL11H_INTMASK_INSRMV)
   1149			irqstat &= ~SL11H_INTMASK_RD;
   1150		break;
   1151	case SL11H_CTL1MASK_K:
   1152		dev_dbg(sl811_to_hcd(sl811)->self.controller, "end resume\n");
   1153		sl811->port1 &= ~USB_PORT_STAT_SUSPEND;
   1154		break;
   1155	default:
   1156		dev_dbg(sl811_to_hcd(sl811)->self.controller,
   1157			"odd timer signaling: %02x\n", signaling);
   1158		break;
   1159	}
   1160	sl811_write(sl811, SL11H_IRQ_STATUS, irqstat);
   1161
   1162	if (irqstat & SL11H_INTMASK_RD) {
   1163		/* usbcore nukes all pending transactions on disconnect */
   1164		if (sl811->port1 & USB_PORT_STAT_CONNECTION)
   1165			sl811->port1 |= (USB_PORT_STAT_C_CONNECTION << 16)
   1166					| (USB_PORT_STAT_C_ENABLE << 16);
   1167		sl811->port1 &= ~mask;
   1168		sl811->irq_enable = SL11H_INTMASK_INSRMV;
   1169	} else {
   1170		sl811->port1 |= mask;
   1171		if (irqstat & SL11H_INTMASK_DP)
   1172			sl811->port1 &= ~USB_PORT_STAT_LOW_SPEED;
   1173		sl811->irq_enable = SL11H_INTMASK_INSRMV | SL11H_INTMASK_RD;
   1174	}
   1175
   1176	if (sl811->port1 & USB_PORT_STAT_CONNECTION) {
   1177		u8	ctrl2 = SL811HS_CTL2_INIT;
   1178
   1179		sl811->irq_enable |= SL11H_INTMASK_DONE_A;
   1180#ifdef USE_B
   1181		sl811->irq_enable |= SL11H_INTMASK_DONE_B;
   1182#endif
   1183		if (sl811->port1 & USB_PORT_STAT_LOW_SPEED) {
   1184			sl811->ctrl1 |= SL11H_CTL1MASK_LSPD;
   1185			ctrl2 |= SL811HS_CTL2MASK_DSWAP;
   1186		}
   1187
   1188		/* start SOFs flowing, kickstarting with A registers */
   1189		sl811->ctrl1 |= SL11H_CTL1MASK_SOF_ENA;
   1190		sl811_write(sl811, SL11H_SOFLOWREG, 0xe0);
   1191		sl811_write(sl811, SL811HS_CTLREG2, ctrl2);
   1192
   1193		/* autoincrementing */
   1194		sl811_write(sl811, SL811_EP_A(SL11H_BUFLNTHREG), 0);
   1195		writeb(SL_SOF, sl811->data_reg);
   1196		writeb(0, sl811->data_reg);
   1197		sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG),
   1198				SL11H_HCTLMASK_ARM);
   1199
   1200		/* hub_wq provides debounce delay */
   1201	} else {
   1202		sl811->ctrl1 = 0;
   1203	}
   1204	sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
   1205
   1206	/* reenable irqs */
   1207	sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
   1208	spin_unlock_irqrestore(&sl811->lock, flags);
   1209}
   1210
   1211static int
   1212sl811h_hub_control(
   1213	struct usb_hcd	*hcd,
   1214	u16		typeReq,
   1215	u16		wValue,
   1216	u16		wIndex,
   1217	char		*buf,
   1218	u16		wLength
   1219) {
   1220	struct sl811	*sl811 = hcd_to_sl811(hcd);
   1221	int		retval = 0;
   1222	unsigned long	flags;
   1223
   1224	spin_lock_irqsave(&sl811->lock, flags);
   1225
   1226	switch (typeReq) {
   1227	case ClearHubFeature:
   1228	case SetHubFeature:
   1229		switch (wValue) {
   1230		case C_HUB_OVER_CURRENT:
   1231		case C_HUB_LOCAL_POWER:
   1232			break;
   1233		default:
   1234			goto error;
   1235		}
   1236		break;
   1237	case ClearPortFeature:
   1238		if (wIndex != 1 || wLength != 0)
   1239			goto error;
   1240
   1241		switch (wValue) {
   1242		case USB_PORT_FEAT_ENABLE:
   1243			sl811->port1 &= USB_PORT_STAT_POWER;
   1244			sl811->ctrl1 = 0;
   1245			sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
   1246			sl811->irq_enable = SL11H_INTMASK_INSRMV;
   1247			sl811_write(sl811, SL11H_IRQ_ENABLE,
   1248						sl811->irq_enable);
   1249			break;
   1250		case USB_PORT_FEAT_SUSPEND:
   1251			if (!(sl811->port1 & USB_PORT_STAT_SUSPEND))
   1252				break;
   1253
   1254			/* 20 msec of resume/K signaling, other irqs blocked */
   1255			dev_dbg(hcd->self.controller, "start resume...\n");
   1256			sl811->irq_enable = 0;
   1257			sl811_write(sl811, SL11H_IRQ_ENABLE,
   1258						sl811->irq_enable);
   1259			sl811->ctrl1 |= SL11H_CTL1MASK_K;
   1260			sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
   1261
   1262			mod_timer(&sl811->timer, jiffies
   1263					+ msecs_to_jiffies(USB_RESUME_TIMEOUT));
   1264			break;
   1265		case USB_PORT_FEAT_POWER:
   1266			port_power(sl811, 0);
   1267			break;
   1268		case USB_PORT_FEAT_C_ENABLE:
   1269		case USB_PORT_FEAT_C_SUSPEND:
   1270		case USB_PORT_FEAT_C_CONNECTION:
   1271		case USB_PORT_FEAT_C_OVER_CURRENT:
   1272		case USB_PORT_FEAT_C_RESET:
   1273			break;
   1274		default:
   1275			goto error;
   1276		}
   1277		sl811->port1 &= ~(1 << wValue);
   1278		break;
   1279	case GetHubDescriptor:
   1280		sl811h_hub_descriptor(sl811, (struct usb_hub_descriptor *) buf);
   1281		break;
   1282	case GetHubStatus:
   1283		put_unaligned_le32(0, buf);
   1284		break;
   1285	case GetPortStatus:
   1286		if (wIndex != 1)
   1287			goto error;
   1288		put_unaligned_le32(sl811->port1, buf);
   1289
   1290		if (__is_defined(VERBOSE) ||
   1291		    *(u16*)(buf+2)) /* only if wPortChange is interesting */
   1292			dev_dbg(hcd->self.controller, "GetPortStatus %08x\n",
   1293				sl811->port1);
   1294		break;
   1295	case SetPortFeature:
   1296		if (wIndex != 1 || wLength != 0)
   1297			goto error;
   1298		switch (wValue) {
   1299		case USB_PORT_FEAT_SUSPEND:
   1300			if (sl811->port1 & USB_PORT_STAT_RESET)
   1301				goto error;
   1302			if (!(sl811->port1 & USB_PORT_STAT_ENABLE))
   1303				goto error;
   1304
   1305			dev_dbg(hcd->self.controller,"suspend...\n");
   1306			sl811->ctrl1 &= ~SL11H_CTL1MASK_SOF_ENA;
   1307			sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
   1308			break;
   1309		case USB_PORT_FEAT_POWER:
   1310			port_power(sl811, 1);
   1311			break;
   1312		case USB_PORT_FEAT_RESET:
   1313			if (sl811->port1 & USB_PORT_STAT_SUSPEND)
   1314				goto error;
   1315			if (!(sl811->port1 & USB_PORT_STAT_POWER))
   1316				break;
   1317
   1318			/* 50 msec of reset/SE0 signaling, irqs blocked */
   1319			sl811->irq_enable = 0;
   1320			sl811_write(sl811, SL11H_IRQ_ENABLE,
   1321						sl811->irq_enable);
   1322			sl811->ctrl1 = SL11H_CTL1MASK_SE0;
   1323			sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
   1324			sl811->port1 |= USB_PORT_STAT_RESET;
   1325			mod_timer(&sl811->timer, jiffies
   1326					+ msecs_to_jiffies(50));
   1327			break;
   1328		default:
   1329			goto error;
   1330		}
   1331		sl811->port1 |= 1 << wValue;
   1332		break;
   1333
   1334	default:
   1335error:
   1336		/* "protocol stall" on error */
   1337		retval = -EPIPE;
   1338	}
   1339
   1340	spin_unlock_irqrestore(&sl811->lock, flags);
   1341	return retval;
   1342}
   1343
   1344#ifdef	CONFIG_PM
   1345
   1346static int
   1347sl811h_bus_suspend(struct usb_hcd *hcd)
   1348{
   1349	// SOFs off
   1350	dev_dbg(hcd->self.controller, "%s\n", __func__);
   1351	return 0;
   1352}
   1353
   1354static int
   1355sl811h_bus_resume(struct usb_hcd *hcd)
   1356{
   1357	// SOFs on
   1358	dev_dbg(hcd->self.controller, "%s\n", __func__);
   1359	return 0;
   1360}
   1361
   1362#else
   1363
   1364#define	sl811h_bus_suspend	NULL
   1365#define	sl811h_bus_resume	NULL
   1366
   1367#endif
   1368
   1369
   1370/*-------------------------------------------------------------------------*/
   1371
   1372static void dump_irq(struct seq_file *s, char *label, u8 mask)
   1373{
   1374	seq_printf(s, "%s %02x%s%s%s%s%s%s\n", label, mask,
   1375		(mask & SL11H_INTMASK_DONE_A) ? " done_a" : "",
   1376		(mask & SL11H_INTMASK_DONE_B) ? " done_b" : "",
   1377		(mask & SL11H_INTMASK_SOFINTR) ? " sof" : "",
   1378		(mask & SL11H_INTMASK_INSRMV) ? " ins/rmv" : "",
   1379		(mask & SL11H_INTMASK_RD) ? " rd" : "",
   1380		(mask & SL11H_INTMASK_DP) ? " dp" : "");
   1381}
   1382
   1383static int sl811h_debug_show(struct seq_file *s, void *unused)
   1384{
   1385	struct sl811		*sl811 = s->private;
   1386	struct sl811h_ep	*ep;
   1387	unsigned		i;
   1388
   1389	seq_printf(s, "%s\n%s version %s\nportstatus[1] = %08x\n",
   1390		sl811_to_hcd(sl811)->product_desc,
   1391		hcd_name, DRIVER_VERSION,
   1392		sl811->port1);
   1393
   1394	seq_printf(s, "insert/remove: %ld\n", sl811->stat_insrmv);
   1395	seq_printf(s, "current session:  done_a %ld done_b %ld "
   1396			"wake %ld sof %ld overrun %ld lost %ld\n\n",
   1397		sl811->stat_a, sl811->stat_b,
   1398		sl811->stat_wake, sl811->stat_sof,
   1399		sl811->stat_overrun, sl811->stat_lost);
   1400
   1401	spin_lock_irq(&sl811->lock);
   1402
   1403	if (sl811->ctrl1 & SL11H_CTL1MASK_SUSPEND)
   1404		seq_printf(s, "(suspended)\n\n");
   1405	else {
   1406		u8	t = sl811_read(sl811, SL11H_CTLREG1);
   1407
   1408		seq_printf(s, "ctrl1 %02x%s%s%s%s\n", t,
   1409			(t & SL11H_CTL1MASK_SOF_ENA) ? " sofgen" : "",
   1410			({char *s; switch (t & SL11H_CTL1MASK_FORCE) {
   1411			case SL11H_CTL1MASK_NORMAL: s = ""; break;
   1412			case SL11H_CTL1MASK_SE0: s = " se0/reset"; break;
   1413			case SL11H_CTL1MASK_K: s = " k/resume"; break;
   1414			default: s = "j"; break;
   1415			} s; }),
   1416			(t & SL11H_CTL1MASK_LSPD) ? " lowspeed" : "",
   1417			(t & SL11H_CTL1MASK_SUSPEND) ? " suspend" : "");
   1418
   1419		dump_irq(s, "irq_enable",
   1420				sl811_read(sl811, SL11H_IRQ_ENABLE));
   1421		dump_irq(s, "irq_status",
   1422				sl811_read(sl811, SL11H_IRQ_STATUS));
   1423		seq_printf(s, "frame clocks remaining:  %d\n",
   1424				sl811_read(sl811, SL11H_SOFTMRREG) << 6);
   1425	}
   1426
   1427	seq_printf(s, "A: qh%p ctl %02x sts %02x\n", sl811->active_a,
   1428		sl811_read(sl811, SL811_EP_A(SL11H_HOSTCTLREG)),
   1429		sl811_read(sl811, SL811_EP_A(SL11H_PKTSTATREG)));
   1430	seq_printf(s, "B: qh%p ctl %02x sts %02x\n", sl811->active_b,
   1431		sl811_read(sl811, SL811_EP_B(SL11H_HOSTCTLREG)),
   1432		sl811_read(sl811, SL811_EP_B(SL11H_PKTSTATREG)));
   1433	seq_printf(s, "\n");
   1434	list_for_each_entry (ep, &sl811->async, schedule) {
   1435		struct urb		*urb;
   1436
   1437		seq_printf(s, "%s%sqh%p, ep%d%s, maxpacket %d"
   1438					" nak %d err %d\n",
   1439			(ep == sl811->active_a) ? "(A) " : "",
   1440			(ep == sl811->active_b) ? "(B) " : "",
   1441			ep, ep->epnum,
   1442			({ char *s; switch (ep->nextpid) {
   1443			case USB_PID_IN: s = "in"; break;
   1444			case USB_PID_OUT: s = "out"; break;
   1445			case USB_PID_SETUP: s = "setup"; break;
   1446			case USB_PID_ACK: s = "status"; break;
   1447			default: s = "?"; break;
   1448			} s;}),
   1449			ep->maxpacket,
   1450			ep->nak_count, ep->error_count);
   1451		list_for_each_entry (urb, &ep->hep->urb_list, urb_list) {
   1452			seq_printf(s, "  urb%p, %d/%d\n", urb,
   1453				urb->actual_length,
   1454				urb->transfer_buffer_length);
   1455		}
   1456	}
   1457	if (!list_empty(&sl811->async))
   1458		seq_printf(s, "\n");
   1459
   1460	seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE);
   1461
   1462	for (i = 0; i < PERIODIC_SIZE; i++) {
   1463		ep = sl811->periodic[i];
   1464		if (!ep)
   1465			continue;
   1466		seq_printf(s, "%2d [%3d]:\n", i, sl811->load[i]);
   1467
   1468		/* DUMB: prints shared entries multiple times */
   1469		do {
   1470			seq_printf(s,
   1471				"   %s%sqh%d/%p (%sdev%d ep%d%s max %d) "
   1472					"err %d\n",
   1473				(ep == sl811->active_a) ? "(A) " : "",
   1474				(ep == sl811->active_b) ? "(B) " : "",
   1475				ep->period, ep,
   1476				(ep->udev->speed == USB_SPEED_FULL)
   1477					? "" : "ls ",
   1478				ep->udev->devnum, ep->epnum,
   1479				(ep->epnum == 0) ? ""
   1480					: ((ep->nextpid == USB_PID_IN)
   1481						? "in"
   1482						: "out"),
   1483				ep->maxpacket, ep->error_count);
   1484			ep = ep->next;
   1485		} while (ep);
   1486	}
   1487
   1488	spin_unlock_irq(&sl811->lock);
   1489	seq_printf(s, "\n");
   1490
   1491	return 0;
   1492}
   1493DEFINE_SHOW_ATTRIBUTE(sl811h_debug);
   1494
   1495/* expect just one sl811 per system */
   1496static void create_debug_file(struct sl811 *sl811)
   1497{
   1498	debugfs_create_file("sl811h", S_IRUGO, usb_debug_root, sl811,
   1499			    &sl811h_debug_fops);
   1500}
   1501
   1502static void remove_debug_file(struct sl811 *sl811)
   1503{
   1504	debugfs_remove(debugfs_lookup("sl811h", usb_debug_root));
   1505}
   1506
   1507/*-------------------------------------------------------------------------*/
   1508
   1509static void
   1510sl811h_stop(struct usb_hcd *hcd)
   1511{
   1512	struct sl811	*sl811 = hcd_to_sl811(hcd);
   1513	unsigned long	flags;
   1514
   1515	del_timer_sync(&hcd->rh_timer);
   1516
   1517	spin_lock_irqsave(&sl811->lock, flags);
   1518	port_power(sl811, 0);
   1519	spin_unlock_irqrestore(&sl811->lock, flags);
   1520}
   1521
   1522static int
   1523sl811h_start(struct usb_hcd *hcd)
   1524{
   1525	struct sl811		*sl811 = hcd_to_sl811(hcd);
   1526
   1527	/* chip has been reset, VBUS power is off */
   1528	hcd->state = HC_STATE_RUNNING;
   1529
   1530	if (sl811->board) {
   1531		if (!device_can_wakeup(hcd->self.controller))
   1532			device_init_wakeup(hcd->self.controller,
   1533				sl811->board->can_wakeup);
   1534		hcd->power_budget = sl811->board->power * 2;
   1535	}
   1536
   1537	/* enable power and interrupts */
   1538	port_power(sl811, 1);
   1539
   1540	return 0;
   1541}
   1542
   1543/*-------------------------------------------------------------------------*/
   1544
   1545static const struct hc_driver sl811h_hc_driver = {
   1546	.description =		hcd_name,
   1547	.hcd_priv_size =	sizeof(struct sl811),
   1548
   1549	/*
   1550	 * generic hardware linkage
   1551	 */
   1552	.irq =			sl811h_irq,
   1553	.flags =		HCD_USB11 | HCD_MEMORY,
   1554
   1555	/* Basic lifecycle operations */
   1556	.start =		sl811h_start,
   1557	.stop =			sl811h_stop,
   1558
   1559	/*
   1560	 * managing i/o requests and associated device resources
   1561	 */
   1562	.urb_enqueue =		sl811h_urb_enqueue,
   1563	.urb_dequeue =		sl811h_urb_dequeue,
   1564	.endpoint_disable =	sl811h_endpoint_disable,
   1565
   1566	/*
   1567	 * periodic schedule support
   1568	 */
   1569	.get_frame_number =	sl811h_get_frame,
   1570
   1571	/*
   1572	 * root hub support
   1573	 */
   1574	.hub_status_data =	sl811h_hub_status_data,
   1575	.hub_control =		sl811h_hub_control,
   1576	.bus_suspend =		sl811h_bus_suspend,
   1577	.bus_resume =		sl811h_bus_resume,
   1578};
   1579
   1580/*-------------------------------------------------------------------------*/
   1581
   1582static int
   1583sl811h_remove(struct platform_device *dev)
   1584{
   1585	struct usb_hcd		*hcd = platform_get_drvdata(dev);
   1586	struct sl811		*sl811 = hcd_to_sl811(hcd);
   1587	struct resource		*res;
   1588
   1589	remove_debug_file(sl811);
   1590	usb_remove_hcd(hcd);
   1591
   1592	/* some platforms may use IORESOURCE_IO */
   1593	res = platform_get_resource(dev, IORESOURCE_MEM, 1);
   1594	if (res)
   1595		iounmap(sl811->data_reg);
   1596
   1597	res = platform_get_resource(dev, IORESOURCE_MEM, 0);
   1598	if (res)
   1599		iounmap(sl811->addr_reg);
   1600
   1601	usb_put_hcd(hcd);
   1602	return 0;
   1603}
   1604
   1605static int
   1606sl811h_probe(struct platform_device *dev)
   1607{
   1608	struct usb_hcd		*hcd;
   1609	struct sl811		*sl811;
   1610	struct resource		*addr, *data, *ires;
   1611	int			irq;
   1612	void __iomem		*addr_reg;
   1613	void __iomem		*data_reg;
   1614	int			retval;
   1615	u8			tmp, ioaddr;
   1616	unsigned long		irqflags;
   1617
   1618	if (usb_disabled())
   1619		return -ENODEV;
   1620
   1621	/* the chip may be wired for either kind of addressing */
   1622	addr = platform_get_mem_or_io(dev, 0);
   1623	data = platform_get_mem_or_io(dev, 1);
   1624	if (!addr || !data || resource_type(addr) != resource_type(data))
   1625		return -ENODEV;
   1626
   1627	/* basic sanity checks first.  board-specific init logic should
   1628	 * have initialized these three resources and probably board
   1629	 * specific platform_data.  we don't probe for IRQs, and do only
   1630	 * minimal sanity checking.
   1631	 */
   1632	ires = platform_get_resource(dev, IORESOURCE_IRQ, 0);
   1633	if (dev->num_resources < 3 || !ires)
   1634		return -ENODEV;
   1635
   1636	irq = ires->start;
   1637	irqflags = ires->flags & IRQF_TRIGGER_MASK;
   1638
   1639	ioaddr = resource_type(addr) == IORESOURCE_IO;
   1640	if (ioaddr) {
   1641		/*
   1642		 * NOTE: 64-bit resource->start is getting truncated
   1643		 * to avoid compiler warning, assuming that ->start
   1644		 * is always 32-bit for this case
   1645		 */
   1646		addr_reg = (void __iomem *) (unsigned long) addr->start;
   1647		data_reg = (void __iomem *) (unsigned long) data->start;
   1648	} else {
   1649		addr_reg = ioremap(addr->start, 1);
   1650		if (addr_reg == NULL) {
   1651			retval = -ENOMEM;
   1652			goto err2;
   1653		}
   1654
   1655		data_reg = ioremap(data->start, 1);
   1656		if (data_reg == NULL) {
   1657			retval = -ENOMEM;
   1658			goto err4;
   1659		}
   1660	}
   1661
   1662	/* allocate and initialize hcd */
   1663	hcd = usb_create_hcd(&sl811h_hc_driver, &dev->dev, dev_name(&dev->dev));
   1664	if (!hcd) {
   1665		retval = -ENOMEM;
   1666		goto err5;
   1667	}
   1668	hcd->rsrc_start = addr->start;
   1669	sl811 = hcd_to_sl811(hcd);
   1670
   1671	spin_lock_init(&sl811->lock);
   1672	INIT_LIST_HEAD(&sl811->async);
   1673	sl811->board = dev_get_platdata(&dev->dev);
   1674	timer_setup(&sl811->timer, sl811h_timer, 0);
   1675	sl811->addr_reg = addr_reg;
   1676	sl811->data_reg = data_reg;
   1677
   1678	spin_lock_irq(&sl811->lock);
   1679	port_power(sl811, 0);
   1680	spin_unlock_irq(&sl811->lock);
   1681	msleep(200);
   1682
   1683	tmp = sl811_read(sl811, SL11H_HWREVREG);
   1684	switch (tmp >> 4) {
   1685	case 1:
   1686		hcd->product_desc = "SL811HS v1.2";
   1687		break;
   1688	case 2:
   1689		hcd->product_desc = "SL811HS v1.5";
   1690		break;
   1691	default:
   1692		/* reject case 0, SL11S is less functional */
   1693		dev_dbg(&dev->dev, "chiprev %02x\n", tmp);
   1694		retval = -ENXIO;
   1695		goto err6;
   1696	}
   1697
   1698	/* The chip's IRQ is level triggered, active high.  A requirement
   1699	 * for platform device setup is to cope with things like signal
   1700	 * inverters (e.g. CF is active low) or working only with edge
   1701	 * triggers (e.g. most ARM CPUs).  Initial driver stress testing
   1702	 * was on a system with single edge triggering, so most sorts of
   1703	 * triggering arrangement should work.
   1704	 *
   1705	 * Use resource IRQ flags if set by platform device setup.
   1706	 */
   1707	irqflags |= IRQF_SHARED;
   1708	retval = usb_add_hcd(hcd, irq, irqflags);
   1709	if (retval != 0)
   1710		goto err6;
   1711
   1712	device_wakeup_enable(hcd->self.controller);
   1713
   1714	create_debug_file(sl811);
   1715	return retval;
   1716
   1717 err6:
   1718	usb_put_hcd(hcd);
   1719 err5:
   1720	if (!ioaddr)
   1721		iounmap(data_reg);
   1722 err4:
   1723	if (!ioaddr)
   1724		iounmap(addr_reg);
   1725 err2:
   1726	dev_dbg(&dev->dev, "init error, %d\n", retval);
   1727	return retval;
   1728}
   1729
   1730#ifdef	CONFIG_PM
   1731
   1732/* for this device there's no useful distinction between the controller
   1733 * and its root hub.
   1734 */
   1735
   1736static int
   1737sl811h_suspend(struct platform_device *dev, pm_message_t state)
   1738{
   1739	struct usb_hcd	*hcd = platform_get_drvdata(dev);
   1740	struct sl811	*sl811 = hcd_to_sl811(hcd);
   1741	int		retval = 0;
   1742
   1743	switch (state.event) {
   1744	case PM_EVENT_FREEZE:
   1745		retval = sl811h_bus_suspend(hcd);
   1746		break;
   1747	case PM_EVENT_SUSPEND:
   1748	case PM_EVENT_HIBERNATE:
   1749	case PM_EVENT_PRETHAW:		/* explicitly discard hw state */
   1750		port_power(sl811, 0);
   1751		break;
   1752	}
   1753	return retval;
   1754}
   1755
   1756static int
   1757sl811h_resume(struct platform_device *dev)
   1758{
   1759	struct usb_hcd	*hcd = platform_get_drvdata(dev);
   1760	struct sl811	*sl811 = hcd_to_sl811(hcd);
   1761
   1762	/* with no "check to see if VBUS is still powered" board hook,
   1763	 * let's assume it'd only be powered to enable remote wakeup.
   1764	 */
   1765	if (!sl811->port1 || !device_can_wakeup(&hcd->self.root_hub->dev)) {
   1766		sl811->port1 = 0;
   1767		port_power(sl811, 1);
   1768		usb_root_hub_lost_power(hcd->self.root_hub);
   1769		return 0;
   1770	}
   1771
   1772	return sl811h_bus_resume(hcd);
   1773}
   1774
   1775#else
   1776
   1777#define	sl811h_suspend	NULL
   1778#define	sl811h_resume	NULL
   1779
   1780#endif
   1781
   1782
   1783/* this driver is exported so sl811_cs can depend on it */
   1784struct platform_driver sl811h_driver = {
   1785	.probe =	sl811h_probe,
   1786	.remove =	sl811h_remove,
   1787
   1788	.suspend =	sl811h_suspend,
   1789	.resume =	sl811h_resume,
   1790	.driver = {
   1791		.name =	hcd_name,
   1792	},
   1793};
   1794EXPORT_SYMBOL(sl811h_driver);
   1795
   1796module_platform_driver(sl811h_driver);