[deliverable/linux.git] / drivers / usb / host / ohci-at91.c

/*
 * OHCI HCD (Host Controller Driver) for USB.
 *
 *  Copyright (C) 2004 SAN People (Pty) Ltd.
 *  Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
 *
 * AT91 Bus Glue
 *
 * Based on fragments of 2.4 driver by Rick Bronson.
 * Based on ohci-omap.c
 *
 * This file is licenced under the GPL.
 */

#include <linux/clk.h>
#include <linux/platform_device.h>

#include <mach/hardware.h>
#include <asm/gpio.h>

#include <mach/board.h>
#include <mach/cpu.h>

#ifndef CONFIG_ARCH_AT91
#error "CONFIG_ARCH_AT91 must be defined."
#endif

/* interface and function clocks; sometimes also an AHB clock */
static struct clk *iclk, *fclk, *hclk;
static int clocked;

extern int usb_disabled(void);

/*-------------------------------------------------------------------------*/

static void at91_start_clock(void)
{
	clk_enable(hclk);
	clk_enable(iclk);
	clk_enable(fclk);
	clocked = 1;
}

static void at91_stop_clock(void)
{
	clk_disable(fclk);
	clk_disable(iclk);
	clk_disable(hclk);
	clocked = 0;
}

static void at91_start_hc(struct platform_device *pdev)
{
	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	struct ohci_regs __iomem *regs = hcd->regs;

	dev_dbg(&pdev->dev, "start\n");

	/*
	 * Start the USB clocks.
	 */
	at91_start_clock();

	/*
	 * The USB host controller must remain in reset.
	 */
	writel(0, &regs->control);
}

static void at91_stop_hc(struct platform_device *pdev)
{
	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	struct ohci_regs __iomem *regs = hcd->regs;

	dev_dbg(&pdev->dev, "stop\n");

	/*
	 * Put the USB host controller into reset.
	 */
	writel(0, &regs->control);

	/*
	 * Stop the USB clocks.
	 */
	at91_stop_clock();
}


/*-------------------------------------------------------------------------*/

static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);

/* configure so an HC device and id are always provided */
/* always called with process context; sleeping is OK */


/**
 * usb_hcd_at91_probe - initialize AT91-based HCDs
 * Context: !in_interrupt()
 *
 * Allocates basic resources for this USB host controller, and
 * then invokes the start() method for the HCD associated with it
 * through the hotplug entry's driver_data.
 */
static int usb_hcd_at91_probe(const struct hc_driver *driver,
			struct platform_device *pdev)
{
	int retval;
	struct usb_hcd *hcd = NULL;

	if (pdev->num_resources != 2) {
		pr_debug("hcd probe: invalid num_resources");
		return -ENODEV;
	}

	if ((pdev->resource[0].flags != IORESOURCE_MEM)
			|| (pdev->resource[1].flags != IORESOURCE_IRQ)) {
		pr_debug("hcd probe: invalid resource type\n");
		return -ENODEV;
	}

	hcd = usb_create_hcd(driver, &pdev->dev, "at91");
	if (!hcd)
		return -ENOMEM;
	hcd->rsrc_start = pdev->resource[0].start;
	hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;

	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
		pr_debug("request_mem_region failed\n");
		retval = -EBUSY;
		goto err1;
	}

	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
	if (!hcd->regs) {
		pr_debug("ioremap failed\n");
		retval = -EIO;
		goto err2;
	}

	iclk = clk_get(&pdev->dev, "ohci_clk");
	fclk = clk_get(&pdev->dev, "uhpck");
	hclk = clk_get(&pdev->dev, "hclk");

	at91_start_hc(pdev);
	ohci_hcd_init(hcd_to_ohci(hcd));

	retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
	if (retval == 0)
		return retval;

	/* Error handling */
	at91_stop_hc(pdev);

	clk_put(hclk);
	clk_put(fclk);
	clk_put(iclk);

	iounmap(hcd->regs);

 err2:
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);

 err1:
	usb_put_hcd(hcd);
	return retval;
}


/* may be called with controller, bus, and devices active */

/**
 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
 * @dev: USB Host Controller being removed
 * Context: !in_interrupt()
 *
 * Reverses the effect of usb_hcd_at91_probe(), first invoking
 * the HCD's stop() method.  It is always called from a thread
 * context, "rmmod" or something similar.
 *
 */
static void usb_hcd_at91_remove(struct usb_hcd *hcd,
				struct platform_device *pdev)
{
	usb_remove_hcd(hcd);
	at91_stop_hc(pdev);
	iounmap(hcd->regs);
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	usb_put_hcd(hcd);

	clk_put(hclk);
	clk_put(fclk);
	clk_put(iclk);
	fclk = iclk = hclk = NULL;

	dev_set_drvdata(&pdev->dev, NULL);
}

/*-------------------------------------------------------------------------*/

static int __devinit
ohci_at91_start (struct usb_hcd *hcd)
{
	struct at91_usbh_data	*board = hcd->self.controller->platform_data;
	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);
	int			ret;

	if ((ret = ohci_init(ohci)) < 0)
		return ret;

	ohci->num_ports = board->ports;

	if ((ret = ohci_run(ohci)) < 0) {
		err("can't start %s", hcd->self.bus_name);
		ohci_stop(hcd);
		return ret;
	}
	return 0;
}

static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable)
{
	if (port < 0 || port >= 2)
		return;

	gpio_set_value(pdata->vbus_pin[port], !pdata->vbus_pin_inverted ^ enable);
}

static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
{
	if (port < 0 || port >= 2)
		return -EINVAL;

	return gpio_get_value(pdata->vbus_pin[port]) ^ !pdata->vbus_pin_inverted;
}

/*
 * Update the status data from the hub with the over-current indicator change.
 */
static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
{
	struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
	int length = ohci_hub_status_data(hcd, buf);
	int port;

	for (port = 0; port < ARRAY_SIZE(pdata->overcurrent_pin); port++) {
		if (pdata->overcurrent_changed[port]) {
			if (! length)
				length = 1;
			buf[0] |= 1 << (port + 1);
		}
	}

	return length;
}

/*
 * Look at the control requests to the root hub and see if we need to override.
 */
static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
				 u16 wIndex, char *buf, u16 wLength)
{
	struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
	struct usb_hub_descriptor *desc;
	int ret = -EINVAL;
	u32 *data = (u32 *)buf;

	dev_dbg(hcd->self.controller,
		"ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
		hcd, typeReq, wValue, wIndex, buf, wLength);

	switch (typeReq) {
	case SetPortFeature:
		if (wValue == USB_PORT_FEAT_POWER) {
			dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n");
			ohci_at91_usb_set_power(pdata, wIndex - 1, 1);
			goto out;
		}
		break;

	case ClearPortFeature:
		switch (wValue) {
		case USB_PORT_FEAT_C_OVER_CURRENT:
			dev_dbg(hcd->self.controller,
				"ClearPortFeature: C_OVER_CURRENT\n");

			if (wIndex == 1 || wIndex == 2) {
				pdata->overcurrent_changed[wIndex-1] = 0;
				pdata->overcurrent_status[wIndex-1] = 0;
			}

			goto out;

		case USB_PORT_FEAT_OVER_CURRENT:
			dev_dbg(hcd->self.controller,
				"ClearPortFeature: OVER_CURRENT\n");

			if (wIndex == 1 || wIndex == 2) {
				pdata->overcurrent_status[wIndex-1] = 0;
			}

			goto out;

		case USB_PORT_FEAT_POWER:
			dev_dbg(hcd->self.controller,
				"ClearPortFeature: POWER\n");

			if (wIndex == 1 || wIndex == 2) {
				ohci_at91_usb_set_power(pdata, wIndex - 1, 0);
				return 0;
			}
		}
		break;
	}

	ret = ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
	if (ret)
		goto out;

	switch (typeReq) {
	case GetHubDescriptor:

		/* update the hub's descriptor */

		desc = (struct usb_hub_descriptor *)buf;

		dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n",
			desc->wHubCharacteristics);

		/* remove the old configurations for power-switching, and
		 * over-current protection, and insert our new configuration
		 */

		desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
		desc->wHubCharacteristics |= cpu_to_le16(0x0001);

		if (pdata->overcurrent_supported) {
			desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
			desc->wHubCharacteristics |=  cpu_to_le16(0x0008|0x0001);
		}

		dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
			desc->wHubCharacteristics);

		return ret;

	case GetPortStatus:
		/* check port status */

		dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);

		if (wIndex == 1 || wIndex == 2) {
			if (! ohci_at91_usb_get_power(pdata, wIndex-1)) {
				*data &= ~cpu_to_le32(RH_PS_PPS);
			}

			if (pdata->overcurrent_changed[wIndex-1]) {
				*data |= cpu_to_le32(RH_PS_OCIC);
			}

			if (pdata->overcurrent_status[wIndex-1]) {
				*data |= cpu_to_le32(RH_PS_POCI);
			}
		}
	}

 out:
	return ret;
}

/*-------------------------------------------------------------------------*/

static const struct hc_driver ohci_at91_hc_driver = {
	.description =		hcd_name,
	.product_desc =		"AT91 OHCI",
	.hcd_priv_size =	sizeof(struct ohci_hcd),

	/*
	 * generic hardware linkage
	 */
	.irq =			ohci_irq,
	.flags =		HCD_USB11 | HCD_MEMORY,

	/*
	 * basic lifecycle operations
	 */
	.start =		ohci_at91_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_at91_hub_status_data,
	.hub_control =		ohci_at91_hub_control,
#ifdef CONFIG_PM
	.bus_suspend =		ohci_bus_suspend,
	.bus_resume =		ohci_bus_resume,
#endif
	.start_port_reset =	ohci_start_port_reset,
};

/*-------------------------------------------------------------------------*/

static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
{
	struct platform_device *pdev = data;
	struct at91_usbh_data *pdata = pdev->dev.platform_data;
	int val, gpio, port;

	/* From the GPIO notifying the over-current situation, find
	 * out the corresponding port */
	gpio = irq_to_gpio(irq);
	for (port = 0; port < ARRAY_SIZE(pdata->overcurrent_pin); port++) {
		if (pdata->overcurrent_pin[port] == gpio)
			break;
	}

	if (port == ARRAY_SIZE(pdata->overcurrent_pin)) {
		dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n");
		return IRQ_HANDLED;
	}

	val = gpio_get_value(gpio);

	/* When notified of an over-current situation, disable power
	   on the corresponding port, and mark this port in
	   over-current. */
	if (! val) {
		ohci_at91_usb_set_power(pdata, port, 0);
		pdata->overcurrent_status[port]  = 1;
		pdata->overcurrent_changed[port] = 1;
	}

	dev_dbg(& pdev->dev, "overcurrent situation %s\n",
		val ? "exited" : "notified");

	return IRQ_HANDLED;
}

/*-------------------------------------------------------------------------*/

static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
{
	struct at91_usbh_data	*pdata = pdev->dev.platform_data;
	int			i;

	if (pdata) {
		for (i = 0; i < ARRAY_SIZE(pdata->vbus_pin); i++) {
			if (pdata->vbus_pin[i] <= 0)
				continue;
			gpio_request(pdata->vbus_pin[i], "ohci_vbus");
			ohci_at91_usb_set_power(pdata, i, 1);
		}

		for (i = 0; i < ARRAY_SIZE(pdata->overcurrent_pin); i++) {
			int ret;

			if (pdata->overcurrent_pin[i] <= 0)
				continue;
			gpio_request(pdata->overcurrent_pin[i], "ohci_overcurrent");

			ret = request_irq(gpio_to_irq(pdata->overcurrent_pin[i]),
					  ohci_hcd_at91_overcurrent_irq,
					  IRQF_SHARED, "ohci_overcurrent", pdev);
			if (ret) {
				gpio_free(pdata->overcurrent_pin[i]);
				dev_warn(& pdev->dev, "cannot get GPIO IRQ for overcurrent\n");
			}
		}
	}

	device_init_wakeup(&pdev->dev, 1);
	return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev);
}

static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
{
	struct at91_usbh_data	*pdata = pdev->dev.platform_data;
	int			i;

	if (pdata) {
		for (i = 0; i < ARRAY_SIZE(pdata->vbus_pin); i++) {
			if (pdata->vbus_pin[i] <= 0)
				continue;
			ohci_at91_usb_set_power(pdata, i, 0);
			gpio_free(pdata->vbus_pin[i]);
		}

		for (i = 0; i < ARRAY_SIZE(pdata->overcurrent_pin); i++) {
			if (pdata->overcurrent_pin[i] <= 0)
				continue;
			free_irq(gpio_to_irq(pdata->overcurrent_pin[i]), pdev);
			gpio_free(pdata->overcurrent_pin[i]);
		}
	}

	device_init_wakeup(&pdev->dev, 0);
	usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
	return 0;
}

#ifdef CONFIG_PM

static int
ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
{
	struct usb_hcd	*hcd = platform_get_drvdata(pdev);
	struct ohci_hcd	*ohci = hcd_to_ohci(hcd);

	if (device_may_wakeup(&pdev->dev))
		enable_irq_wake(hcd->irq);

	/*
	 * The integrated transceivers seem unable to notice disconnect,
	 * reconnect, or wakeup without the 48 MHz clock active.  so for
	 * correctness, always discard connection state (using reset).
	 *
	 * REVISIT: some boards will be able to turn VBUS off...
	 */
	if (at91_suspend_entering_slow_clock()) {
		ohci_usb_reset (ohci);
		/* flush the writes */
		(void) ohci_readl (ohci, &ohci->regs->control);
		at91_stop_clock();
	}

	return 0;
}

static int ohci_hcd_at91_drv_resume(struct platform_device *pdev)
{
	struct usb_hcd	*hcd = platform_get_drvdata(pdev);

	if (device_may_wakeup(&pdev->dev))
		disable_irq_wake(hcd->irq);

	if (!clocked)
		at91_start_clock();

	ohci_finish_controller_resume(hcd);
	return 0;
}
#else
#define ohci_hcd_at91_drv_suspend NULL
#define ohci_hcd_at91_drv_resume  NULL
#endif

MODULE_ALIAS("platform:at91_ohci");

static struct platform_driver ohci_hcd_at91_driver = {
	.probe		= ohci_hcd_at91_drv_probe,
	.remove		= ohci_hcd_at91_drv_remove,
	.shutdown	= usb_hcd_platform_shutdown,
	.suspend	= ohci_hcd_at91_drv_suspend,
	.resume		= ohci_hcd_at91_drv_resume,
	.driver		= {
		.name	= "at91_ohci",
		.owner	= THIS_MODULE,
	},
};
Commit	Line	Data
39a269c0 AV	1	/*
	2	* OHCI HCD (Host Controller Driver) for USB.
	3	*
	4	* Copyright (C) 2004 SAN People (Pty) Ltd.
	5	* Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
	6	*
0365ee0a	7	* AT91 Bus Glue
39a269c0 AV	8	*
	9	* Based on fragments of 2.4 driver by Rick Bronson.
	10	* Based on ohci-omap.c
	11	*
	12	* This file is licenced under the GPL.
	13	*/
	14
	15	#include <linux/clk.h>
	16	#include <linux/platform_device.h>
	17
a09e64fb	18	#include <mach/hardware.h>
4bde4a4c DB	19	#include <asm/gpio.h>
4bde4a4c DB	20
a09e64fb RK	21	#include <mach/board.h>
a09e64fb RK	22	#include <mach/cpu.h>
39a269c0	23
0365ee0a DB	24	#ifndef CONFIG_ARCH_AT91
0365ee0a DB	25	#error "CONFIG_ARCH_AT91 must be defined."
39a269c0 AV	26	#endif
39a269c0 AV	27
ed077bb7 AV	28	/* interface and function clocks; sometimes also an AHB clock */
ed077bb7 AV	29	static struct clk iclk, fclk, *hclk;
0365ee0a	30	static int clocked;
39a269c0 AV	31
	32	extern int usb_disabled(void);
	33
	34	/-------------------------------------------------------------------------/
	35
ed077bb7 AV	36	static void at91_start_clock(void)
ed077bb7 AV	37	{
0af4316b	38	clk_enable(hclk);
ed077bb7 AV	39	clk_enable(iclk);
	40	clk_enable(fclk);
	41	clocked = 1;
	42	}
	43
	44	static void at91_stop_clock(void)
	45	{
	46	clk_disable(fclk);
	47	clk_disable(iclk);
0af4316b	48	clk_disable(hclk);
ed077bb7 AV	49	clocked = 0;
	50	}
	51
39a269c0 AV	52	static void at91_start_hc(struct platform_device *pdev)
	53	{
	54	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	55	struct ohci_regs __iomem *regs = hcd->regs;
	56
0365ee0a	57	dev_dbg(&pdev->dev, "start\n");
39a269c0 AV	58
	59	/*
	60	* Start the USB clocks.
	61	*/
ed077bb7	62	at91_start_clock();
39a269c0 AV	63
	64	/*
	65	* The USB host controller must remain in reset.
	66	*/
	67	writel(0, &regs->control);
	68	}
	69
	70	static void at91_stop_hc(struct platform_device *pdev)
	71	{
	72	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	73	struct ohci_regs __iomem *regs = hcd->regs;
	74
0365ee0a	75	dev_dbg(&pdev->dev, "stop\n");
39a269c0 AV	76
	77	/*
	78	* Put the USB host controller into reset.
	79	*/
	80	writel(0, &regs->control);
	81
	82	/*
	83	* Stop the USB clocks.
	84	*/
ed077bb7	85	at91_stop_clock();
39a269c0 AV	86	}
	87
	88
	89	/-------------------------------------------------------------------------/
	90
421b4bf5	91	static void usb_hcd_at91_remove (struct usb_hcd , struct platform_device );
39a269c0 AV	92
	93	/* configure so an HC device and id are always provided */
	94	/* always called with process context; sleeping is OK */
	95
	96
	97	/**
0365ee0a	98	* usb_hcd_at91_probe - initialize AT91-based HCDs
39a269c0 AV	99	* Context: !in_interrupt()
	100	*
	101	* Allocates basic resources for this USB host controller, and
	102	* then invokes the start() method for the HCD associated with it
	103	* through the hotplug entry's driver_data.
39a269c0	104	*/
0365ee0a DB	105	static int usb_hcd_at91_probe(const struct hc_driver *driver,
0365ee0a DB	106	struct platform_device *pdev)
39a269c0 AV	107	{
	108	int retval;
	109	struct usb_hcd *hcd = NULL;
	110
	111	if (pdev->num_resources != 2) {
	112	pr_debug("hcd probe: invalid num_resources");
	113	return -ENODEV;
	114	}
	115
0365ee0a DB	116	if ((pdev->resource[0].flags != IORESOURCE_MEM)
0365ee0a DB	117	\|\| (pdev->resource[1].flags != IORESOURCE_IRQ)) {
39a269c0 AV	118	pr_debug("hcd probe: invalid resource type\n");
	119	return -ENODEV;
	120	}
	121
0365ee0a	122	hcd = usb_create_hcd(driver, &pdev->dev, "at91");
39a269c0 AV	123	if (!hcd)
	124	return -ENOMEM;
	125	hcd->rsrc_start = pdev->resource[0].start;
	126	hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
	127
	128	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
	129	pr_debug("request_mem_region failed\n");
	130	retval = -EBUSY;
	131	goto err1;
	132	}
	133
	134	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
	135	if (!hcd->regs) {
	136	pr_debug("ioremap failed\n");
	137	retval = -EIO;
	138	goto err2;
	139	}
	140
	141	iclk = clk_get(&pdev->dev, "ohci_clk");
	142	fclk = clk_get(&pdev->dev, "uhpck");
0af4316b	143	hclk = clk_get(&pdev->dev, "hclk");
39a269c0 AV	144
	145	at91_start_hc(pdev);
	146	ohci_hcd_init(hcd_to_ohci(hcd));
	147
2f2cac3c	148	retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
39a269c0 AV	149	if (retval == 0)
	150	return retval;
	151
	152	/* Error handling */
	153	at91_stop_hc(pdev);
	154
0af4316b	155	clk_put(hclk);
39a269c0 AV	156	clk_put(fclk);
	157	clk_put(iclk);
	158
	159	iounmap(hcd->regs);
	160
	161	err2:
	162	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	163
	164	err1:
	165	usb_put_hcd(hcd);
	166	return retval;
	167	}
	168
	169
39a269c0 AV	170	/* may be called with controller, bus, and devices active */
	171
	172	/**
0365ee0a	173	* usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
39a269c0 AV	174	* @dev: USB Host Controller being removed
	175	* Context: !in_interrupt()
	176	*
	177	* Reverses the effect of usb_hcd_at91_probe(), first invoking
	178	* the HCD's stop() method. It is always called from a thread
0365ee0a	179	* context, "rmmod" or something similar.
39a269c0 AV	180	*
39a269c0 AV	181	*/
421b4bf5	182	static void usb_hcd_at91_remove(struct usb_hcd *hcd,
0365ee0a	183	struct platform_device *pdev)
39a269c0 AV	184	{
	185	usb_remove_hcd(hcd);
	186	at91_stop_hc(pdev);
	187	iounmap(hcd->regs);
68ba61b8	188	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
421b4bf5	189	usb_put_hcd(hcd);
39a269c0	190
0af4316b	191	clk_put(hclk);
68ba61b8 DB	192	clk_put(fclk);
68ba61b8 DB	193	clk_put(iclk);
ed077bb7	194	fclk = iclk = hclk = NULL;
39a269c0 AV	195
39a269c0 AV	196	dev_set_drvdata(&pdev->dev, NULL);
39a269c0 AV	197	}
	198
	199	/-------------------------------------------------------------------------/
	200
	201	static int __devinit
	202	ohci_at91_start (struct usb_hcd *hcd)
	203	{
0365ee0a	204	struct at91_usbh_data *board = hcd->self.controller->platform_data;
39a269c0 AV	205	struct ohci_hcd *ohci = hcd_to_ohci (hcd);
	206	int ret;
	207
	208	if ((ret = ohci_init(ohci)) < 0)
	209	return ret;
	210
cd22afda	211	ohci->num_ports = board->ports;
0365ee0a	212
39a269c0 AV	213	if ((ret = ohci_run(ohci)) < 0) {
	214	err("can't start %s", hcd->self.bus_name);
	215	ohci_stop(hcd);
	216	return ret;
	217	}
39a269c0 AV	218	return 0;
	219	}
	220
aa6e52a3 TP	221	static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable)
	222	{
	223	if (port < 0 \|\| port >= 2)
	224	return;
	225
	226	gpio_set_value(pdata->vbus_pin[port], !pdata->vbus_pin_inverted ^ enable);
	227	}
	228
	229	static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
	230	{
	231	if (port < 0 \|\| port >= 2)
	232	return -EINVAL;
	233
	234	return gpio_get_value(pdata->vbus_pin[port]) ^ !pdata->vbus_pin_inverted;
	235	}
	236
	237	/*
	238	* Update the status data from the hub with the over-current indicator change.
	239	*/
	240	static int ohci_at91_hub_status_data(struct usb_hcd hcd, char buf)
	241	{
	242	struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
	243	int length = ohci_hub_status_data(hcd, buf);
	244	int port;
	245
	246	for (port = 0; port < ARRAY_SIZE(pdata->overcurrent_pin); port++) {
	247	if (pdata->overcurrent_changed[port]) {
	248	if (! length)
	249	length = 1;
	250	buf[0] \|= 1 << (port + 1);
	251	}
	252	}
	253
	254	return length;
	255	}
	256
	257	/*
	258	* Look at the control requests to the root hub and see if we need to override.
	259	*/
	260	static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
	261	u16 wIndex, char *buf, u16 wLength)
	262	{
	263	struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
	264	struct usb_hub_descriptor *desc;
	265	int ret = -EINVAL;
	266	u32 data = (u32 )buf;
	267
	268	dev_dbg(hcd->self.controller,
	269	"ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
	270	hcd, typeReq, wValue, wIndex, buf, wLength);
	271
	272	switch (typeReq) {
	273	case SetPortFeature:
	274	if (wValue == USB_PORT_FEAT_POWER) {
	275	dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n");
	276	ohci_at91_usb_set_power(pdata, wIndex - 1, 1);
	277	goto out;
	278	}
	279	break;
	280
	281	case ClearPortFeature:
	282	switch (wValue) {
	283	case USB_PORT_FEAT_C_OVER_CURRENT:
	284	dev_dbg(hcd->self.controller,
285	"ClearPortFeature: C_OVER_CURRENT\n");
286
287	if (wIndex == 1 \|\| wIndex == 2) {
288	pdata->overcurrent_changed[wIndex-1] = 0;
289	pdata->overcurrent_status[wIndex-1] = 0;
290	}
291
292	goto out;
293
294	case USB_PORT_FEAT_OVER_CURRENT:
295	dev_dbg(hcd->self.controller,
296	"ClearPortFeature: OVER_CURRENT\n");
297
298	if (wIndex == 1 \|\| wIndex == 2) {
299	pdata->overcurrent_status[wIndex-1] = 0;
300	}
301
302	goto out;
303
304	case USB_PORT_FEAT_POWER:
305	dev_dbg(hcd->self.controller,
306	"ClearPortFeature: POWER\n");
307
308	if (wIndex == 1 \|\| wIndex == 2) {
309	ohci_at91_usb_set_power(pdata, wIndex - 1, 0);
310	return 0;
311	}
312	}
313	break;
314	}
315
316	ret = ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
317	if (ret)
318	goto out;
319
320	switch (typeReq) {
321	case GetHubDescriptor:
322
323	/* update the hub's descriptor */
324
325	desc = (struct usb_hub_descriptor *)buf;
326
327	dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n",
328	desc->wHubCharacteristics);
329
330	/* remove the old configurations for power-switching, and
331	* over-current protection, and insert our new configuration
332	*/
333
334	desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
335	desc->wHubCharacteristics \|= cpu_to_le16(0x0001);
336
337	if (pdata->overcurrent_supported) {
338	desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
339	desc->wHubCharacteristics \|= cpu_to_le16(0x0008\|0x0001);
340	}
341
342	dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
343	desc->wHubCharacteristics);
344
345	return ret;
346
347	case GetPortStatus:
348	/* check port status */
349
350	dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);
351
352	if (wIndex == 1 \|\| wIndex == 2) {
353	if (! ohci_at91_usb_get_power(pdata, wIndex-1)) {
354	*data &= ~cpu_to_le32(RH_PS_PPS);
355	}
356
357	if (pdata->overcurrent_changed[wIndex-1]) {
358	*data \|= cpu_to_le32(RH_PS_OCIC);
359	}
360
361	if (pdata->overcurrent_status[wIndex-1]) {
362	*data \|= cpu_to_le32(RH_PS_POCI);
363	}
364	}
365	}
366
367	out:
368	return ret;
369	}
370
39a269c0 AV	371	/-------------------------------------------------------------------------/
	372
	373	static const struct hc_driver ohci_at91_hc_driver = {
	374	.description = hcd_name,
0365ee0a	375	.product_desc = "AT91 OHCI",
39a269c0 AV	376	.hcd_priv_size = sizeof(struct ohci_hcd),
	377
	378	/*
	379	* generic hardware linkage
	380	*/
	381	.irq = ohci_irq,
	382	.flags = HCD_USB11 \| HCD_MEMORY,
	383
	384	/*
	385	* basic lifecycle operations
	386	*/
	387	.start = ohci_at91_start,
	388	.stop = ohci_stop,
dd9048af	389	.shutdown = ohci_shutdown,
39a269c0 AV	390
	391	/*
	392	* managing i/o requests and associated device resources
	393	*/
	394	.urb_enqueue = ohci_urb_enqueue,
	395	.urb_dequeue = ohci_urb_dequeue,
	396	.endpoint_disable = ohci_endpoint_disable,
	397
	398	/*
	399	* scheduling support
	400	*/
	401	.get_frame_number = ohci_get_frame,
	402
	403	/*
	404	* root hub support
	405	*/
aa6e52a3 TP	406	.hub_status_data = ohci_at91_hub_status_data,
aa6e52a3 TP	407	.hub_control = ohci_at91_hub_control,
39a269c0	408	#ifdef CONFIG_PM
68ba61b8 DB	409	.bus_suspend = ohci_bus_suspend,
68ba61b8 DB	410	.bus_resume = ohci_bus_resume,
39a269c0 AV	411	#endif
	412	.start_port_reset = ohci_start_port_reset,
	413	};
	414
	415	/-------------------------------------------------------------------------/
	416
aa6e52a3 TP	417	static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
	418	{
	419	struct platform_device *pdev = data;
	420	struct at91_usbh_data *pdata = pdev->dev.platform_data;
	421	int val, gpio, port;
	422
	423	/* From the GPIO notifying the over-current situation, find
	424	* out the corresponding port */
	425	gpio = irq_to_gpio(irq);
	426	for (port = 0; port < ARRAY_SIZE(pdata->overcurrent_pin); port++) {
	427	if (pdata->overcurrent_pin[port] == gpio)
	428	break;
	429	}
	430
	431	if (port == ARRAY_SIZE(pdata->overcurrent_pin)) {
	432	dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n");
	433	return IRQ_HANDLED;
	434	}
	435
	436	val = gpio_get_value(gpio);
	437
	438	/* When notified of an over-current situation, disable power
	439	on the corresponding port, and mark this port in
	440	over-current. */
	441	if (! val) {
	442	ohci_at91_usb_set_power(pdata, port, 0);
	443	pdata->overcurrent_status[port] = 1;
	444	pdata->overcurrent_changed[port] = 1;
	445	}
	446
	447	dev_dbg(& pdev->dev, "overcurrent situation %s\n",
	448	val ? "exited" : "notified");
	449
	450	return IRQ_HANDLED;
	451	}
	452
	453	/-------------------------------------------------------------------------/
	454
0365ee0a	455	static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
39a269c0	456	{
4bde4a4c DB	457	struct at91_usbh_data *pdata = pdev->dev.platform_data;
	458	int i;
	459
	460	if (pdata) {
3d6fdf75	461	for (i = 0; i < ARRAY_SIZE(pdata->vbus_pin); i++) {
4bde4a4c DB	462	if (pdata->vbus_pin[i] <= 0)
	463	continue;
	464	gpio_request(pdata->vbus_pin[i], "ohci_vbus");
aa6e52a3 TP	465	ohci_at91_usb_set_power(pdata, i, 1);
	466	}
	467
	468	for (i = 0; i < ARRAY_SIZE(pdata->overcurrent_pin); i++) {
	469	int ret;
	470
	471	if (pdata->overcurrent_pin[i] <= 0)
	472	continue;
	473	gpio_request(pdata->overcurrent_pin[i], "ohci_overcurrent");
	474
	475	ret = request_irq(gpio_to_irq(pdata->overcurrent_pin[i]),
	476	ohci_hcd_at91_overcurrent_irq,
	477	IRQF_SHARED, "ohci_overcurrent", pdev);
	478	if (ret) {
	479	gpio_free(pdata->overcurrent_pin[i]);
	480	dev_warn(& pdev->dev, "cannot get GPIO IRQ for overcurrent\n");
	481	}
4bde4a4c DB	482	}
	483	}
	484
0365ee0a DB	485	device_init_wakeup(&pdev->dev, 1);
0365ee0a DB	486	return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev);
39a269c0 AV	487	}
39a269c0 AV	488
0365ee0a	489	static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
39a269c0	490	{
4bde4a4c DB	491	struct at91_usbh_data *pdata = pdev->dev.platform_data;
	492	int i;
	493
	494	if (pdata) {
3d6fdf75	495	for (i = 0; i < ARRAY_SIZE(pdata->vbus_pin); i++) {
4bde4a4c DB	496	if (pdata->vbus_pin[i] <= 0)
4bde4a4c DB	497	continue;
aa6e52a3	498	ohci_at91_usb_set_power(pdata, i, 0);
4bde4a4c DB	499	gpio_free(pdata->vbus_pin[i]);
4bde4a4c DB	500	}
aa6e52a3 TP	501
	502	for (i = 0; i < ARRAY_SIZE(pdata->overcurrent_pin); i++) {
	503	if (pdata->overcurrent_pin[i] <= 0)
	504	continue;
	505	free_irq(gpio_to_irq(pdata->overcurrent_pin[i]), pdev);
	506	gpio_free(pdata->overcurrent_pin[i]);
	507	}
4bde4a4c DB	508	}
4bde4a4c DB	509
0365ee0a	510	device_init_wakeup(&pdev->dev, 0);
421b4bf5 PZ	511	usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
421b4bf5 PZ	512	return 0;
39a269c0 AV	513	}
	514
	515	#ifdef CONFIG_PM
39a269c0	516
68ba61b8	517	static int
0365ee0a	518	ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
68ba61b8	519	{
0365ee0a DB	520	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	521	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
	522
	523	if (device_may_wakeup(&pdev->dev))
	524	enable_irq_wake(hcd->irq);
0365ee0a DB	525
	526	/*
	527	* The integrated transceivers seem unable to notice disconnect,
	528	* reconnect, or wakeup without the 48 MHz clock active. so for
	529	* correctness, always discard connection state (using reset).
	530	*
	531	* REVISIT: some boards will be able to turn VBUS off...
	532	*/
	533	if (at91_suspend_entering_slow_clock()) {
	534	ohci_usb_reset (ohci);
869aa98c PV	535	/* flush the writes */
869aa98c PV	536	(void) ohci_readl (ohci, &ohci->regs->control);
ed077bb7	537	at91_stop_clock();
0365ee0a	538	}
39a269c0 AV	539
	540	return 0;
	541	}
	542
0365ee0a	543	static int ohci_hcd_at91_drv_resume(struct platform_device *pdev)
39a269c0	544	{
6dde896e MP	545	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	546
	547	if (device_may_wakeup(&pdev->dev))
	548	disable_irq_wake(hcd->irq);
	549
ed077bb7 AV	550	if (!clocked)
ed077bb7 AV	551	at91_start_clock();
39a269c0	552
43bbb7e0	553	ohci_finish_controller_resume(hcd);
39a269c0 AV	554	return 0;
	555	}
	556	#else
	557	#define ohci_hcd_at91_drv_suspend NULL
	558	#define ohci_hcd_at91_drv_resume NULL
	559	#endif
	560
f4fce61d	561	MODULE_ALIAS("platform:at91_ohci");
68ba61b8	562
39a269c0 AV	563	static struct platform_driver ohci_hcd_at91_driver = {
	564	.probe = ohci_hcd_at91_drv_probe,
	565	.remove = ohci_hcd_at91_drv_remove,
64a21d02	566	.shutdown = usb_hcd_platform_shutdown,
39a269c0 AV	567	.suspend = ohci_hcd_at91_drv_suspend,
	568	.resume = ohci_hcd_at91_drv_resume,
	569	.driver = {
0365ee0a	570	.name = "at91_ohci",
39a269c0 AV	571	.owner = THIS_MODULE,
	572	},
	573	};