[deliverable/linux.git] / drivers / usb / dwc3 / dwc3-pci.c

/**
 * dwc3-pci.c - PCI Specific glue layer
 *
 * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
 *
 * Authors: Felipe Balbi <balbi@ti.com>,
 *	    Sebastian Andrzej Siewior <bigeasy@linutronix.de>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The names of the above-listed copyright holders may not be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * ALTERNATIVELY, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2, as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/pci.h>
#include <linux/platform_device.h>

#include <linux/usb/otg.h>
#include <linux/usb/nop-usb-xceiv.h>

#include "core.h"

/* FIXME define these in <linux/pci_ids.h> */
#define PCI_VENDOR_ID_SYNOPSYS		0x16c3
#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3	0xabcd

struct dwc3_pci {
	struct device		*dev;
	struct platform_device	*dwc3;
	struct platform_device	*usb2_phy;
	struct platform_device	*usb3_phy;
};

static int __devinit dwc3_pci_register_phys(struct dwc3_pci *glue)
{
	struct nop_usb_xceiv_platform_data pdata;
	struct platform_device	*pdev;
	int			ret;

	memset(&pdata, 0x00, sizeof(pdata));

	pdev = platform_device_alloc("nop_usb_xceiv", 0);
	if (!pdev)
		return -ENOMEM;

	glue->usb2_phy = pdev;
	pdata.type = USB_PHY_TYPE_USB2;

	ret = platform_device_add_data(glue->usb2_phy, &pdata, sizeof(pdata));
	if (ret)
		goto err1;

	pdev = platform_device_alloc("nop_usb_xceiv", 1);
	if (!pdev) {
		ret = -ENOMEM;
		goto err1;
	}

	glue->usb3_phy = pdev;
	pdata.type = USB_PHY_TYPE_USB3;

	ret = platform_device_add_data(glue->usb3_phy, &pdata, sizeof(pdata));
	if (ret)
		goto err2;

	ret = platform_device_add(glue->usb2_phy);
	if (ret)
		goto err2;

	ret = platform_device_add(glue->usb3_phy);
	if (ret)
		goto err3;

	return 0;

err3:
	platform_device_del(glue->usb2_phy);

err2:
	platform_device_put(glue->usb3_phy);

err1:
	platform_device_put(glue->usb2_phy);

	return ret;
}

static int __devinit dwc3_pci_probe(struct pci_dev *pci,
		const struct pci_device_id *id)
{
	struct resource		res[2];
	struct platform_device	*dwc3;
	struct dwc3_pci		*glue;
	int			ret = -ENOMEM;
	struct device		*dev = &pci->dev;

	glue = devm_kzalloc(dev, sizeof(*glue), GFP_KERNEL);
	if (!glue) {
		dev_err(dev, "not enough memory\n");
		return -ENOMEM;
	}

	glue->dev = dev;

	ret = pci_enable_device(pci);
	if (ret) {
		dev_err(dev, "failed to enable pci device\n");
		return -ENODEV;
	}

	pci_set_power_state(pci, PCI_D0);
	pci_set_master(pci);

	ret = dwc3_pci_register_phys(glue);
	if (ret) {
		dev_err(dev, "couldn't register PHYs\n");
		return ret;
	}

	dwc3 = platform_device_alloc("dwc3", PLATFORM_DEVID_AUTO);
	if (!dwc3) {
		dev_err(dev, "couldn't allocate dwc3 device\n");
		ret = -ENOMEM;
		goto err1;
	}

	memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));

	res[0].start	= pci_resource_start(pci, 0);
	res[0].end	= pci_resource_end(pci, 0);
	res[0].name	= "dwc_usb3";
	res[0].flags	= IORESOURCE_MEM;

	res[1].start	= pci->irq;
	res[1].name	= "dwc_usb3";
	res[1].flags	= IORESOURCE_IRQ;

	ret = platform_device_add_resources(dwc3, res, ARRAY_SIZE(res));
	if (ret) {
		dev_err(dev, "couldn't add resources to dwc3 device\n");
		goto err1;
	}

	pci_set_drvdata(pci, glue);

	dma_set_coherent_mask(&dwc3->dev, dev->coherent_dma_mask);

	dwc3->dev.dma_mask = dev->dma_mask;
	dwc3->dev.dma_parms = dev->dma_parms;
	dwc3->dev.parent = dev;
	glue->dwc3 = dwc3;

	ret = platform_device_add(dwc3);
	if (ret) {
		dev_err(dev, "failed to register dwc3 device\n");
		goto err3;
	}

	return 0;

err3:
	pci_set_drvdata(pci, NULL);
	platform_device_put(dwc3);
err1:
	pci_disable_device(pci);

	return ret;
}

static void __devexit dwc3_pci_remove(struct pci_dev *pci)
{
	struct dwc3_pci	*glue = pci_get_drvdata(pci);

	platform_device_unregister(glue->usb2_phy);
	platform_device_unregister(glue->usb3_phy);
	platform_device_unregister(glue->dwc3);
	pci_set_drvdata(pci, NULL);
	pci_disable_device(pci);
}

static DEFINE_PCI_DEVICE_TABLE(dwc3_pci_id_table) = {
	{
		PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
				PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3),
	},
	{  }	/* Terminating Entry */
};
MODULE_DEVICE_TABLE(pci, dwc3_pci_id_table);

static struct pci_driver dwc3_pci_driver = {
	.name		= "dwc3-pci",
	.id_table	= dwc3_pci_id_table,
	.probe		= dwc3_pci_probe,
	.remove		= __devexit_p(dwc3_pci_remove),
};

MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("DesignWare USB3 PCI Glue Layer");

module_pci_driver(dwc3_pci_driver);
Commit	Line	Data
72246da4 FB	1	/**
	2	* dwc3-pci.c - PCI Specific glue layer
	3	*
	4	* Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
72246da4 FB	5	*
	6	* Authors: Felipe Balbi <balbi@ti.com>,
	7	* Sebastian Andrzej Siewior <bigeasy@linutronix.de>
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions
	11	* are met:
	12	* 1. Redistributions of source code must retain the above copyright
	13	* notice, this list of conditions, and the following disclaimer,
	14	* without modification.
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in the
	17	* documentation and/or other materials provided with the distribution.
	18	* 3. The names of the above-listed copyright holders may not be used
	19	* to endorse or promote products derived from this software without
	20	* specific prior written permission.
	21	*
	22	* ALTERNATIVELY, this software may be distributed under the terms of the
	23	* GNU General Public License ("GPL") version 2, as published by the Free
	24	* Software Foundation.
	25	*
	26	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
	27	* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	28	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	29	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
	30	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	31	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	32	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	33	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	34	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	35	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	36	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	37	*/
	38
	39	#include <linux/kernel.h>
46a57283	40	#include <linux/module.h>
72246da4 FB	41	#include <linux/slab.h>
	42	#include <linux/pci.h>
	43	#include <linux/platform_device.h>
	44
e3ec3eb7 FB	45	#include <linux/usb/otg.h>
	46	#include <linux/usb/nop-usb-xceiv.h>
	47
8300dd23 FB	48	#include "core.h"
8300dd23 FB	49
72246da4 FB	50	/* FIXME define these in <linux/pci_ids.h> */
	51	#define PCI_VENDOR_ID_SYNOPSYS 0x16c3
	52	#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3 0xabcd
	53
72246da4 FB	54	struct dwc3_pci {
	55	struct device *dev;
	56	struct platform_device *dwc3;
e3ec3eb7 FB	57	struct platform_device *usb2_phy;
e3ec3eb7 FB	58	struct platform_device *usb3_phy;
72246da4 FB	59	};
72246da4 FB	60
e3ec3eb7 FB	61	static int __devinit dwc3_pci_register_phys(struct dwc3_pci *glue)
	62	{
	63	struct nop_usb_xceiv_platform_data pdata;
	64	struct platform_device *pdev;
	65	int ret;
	66
	67	memset(&pdata, 0x00, sizeof(pdata));
	68
	69	pdev = platform_device_alloc("nop_usb_xceiv", 0);
	70	if (!pdev)
	71	return -ENOMEM;
	72
	73	glue->usb2_phy = pdev;
	74	pdata.type = USB_PHY_TYPE_USB2;
	75
	76	ret = platform_device_add_data(glue->usb2_phy, &pdata, sizeof(pdata));
	77	if (ret)
	78	goto err1;
	79
	80	pdev = platform_device_alloc("nop_usb_xceiv", 1);
	81	if (!pdev) {
	82	ret = -ENOMEM;
	83	goto err1;
	84	}
	85
	86	glue->usb3_phy = pdev;
	87	pdata.type = USB_PHY_TYPE_USB3;
	88
	89	ret = platform_device_add_data(glue->usb3_phy, &pdata, sizeof(pdata));
	90	if (ret)
	91	goto err2;
	92
	93	ret = platform_device_add(glue->usb2_phy);
	94	if (ret)
	95	goto err2;
	96
	97	ret = platform_device_add(glue->usb3_phy);
	98	if (ret)
	99	goto err3;
	100
	101	return 0;
	102
	103	err3:
	104	platform_device_del(glue->usb2_phy);
	105
	106	err2:
	107	platform_device_put(glue->usb3_phy);
	108
	109	err1:
	110	platform_device_put(glue->usb2_phy);
	111
	112	return ret;
	113	}
	114
72246da4 FB	115	static int __devinit dwc3_pci_probe(struct pci_dev *pci,
	116	const struct pci_device_id *id)
	117	{
	118	struct resource res[2];
	119	struct platform_device *dwc3;
	120	struct dwc3_pci *glue;
	121	int ret = -ENOMEM;
802ca850	122	struct device *dev = &pci->dev;
72246da4	123
802ca850	124	glue = devm_kzalloc(dev, sizeof(*glue), GFP_KERNEL);
72246da4	125	if (!glue) {
802ca850 CP	126	dev_err(dev, "not enough memory\n");
802ca850 CP	127	return -ENOMEM;
72246da4 FB	128	}
72246da4 FB	129
1d046793	130	glue->dev = dev;
72246da4 FB	131
	132	ret = pci_enable_device(pci);
	133	if (ret) {
802ca850 CP	134	dev_err(dev, "failed to enable pci device\n");
802ca850 CP	135	return -ENODEV;
72246da4 FB	136	}
	137
	138	pci_set_power_state(pci, PCI_D0);
	139	pci_set_master(pci);
	140
e3ec3eb7 FB	141	ret = dwc3_pci_register_phys(glue);
	142	if (ret) {
	143	dev_err(dev, "couldn't register PHYs\n");
	144	return ret;
	145	}
	146
124dafde	147	dwc3 = platform_device_alloc("dwc3", PLATFORM_DEVID_AUTO);
72246da4	148	if (!dwc3) {
802ca850	149	dev_err(dev, "couldn't allocate dwc3 device\n");
28f1a0d9	150	ret = -ENOMEM;
802ca850	151	goto err1;
72246da4 FB	152	}
	153
	154	memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));
	155
	156	res[0].start = pci_resource_start(pci, 0);
	157	res[0].end = pci_resource_end(pci, 0);
	158	res[0].name = "dwc_usb3";
	159	res[0].flags = IORESOURCE_MEM;
	160
	161	res[1].start = pci->irq;
	162	res[1].name = "dwc_usb3";
	163	res[1].flags = IORESOURCE_IRQ;
	164
	165	ret = platform_device_add_resources(dwc3, res, ARRAY_SIZE(res));
	166	if (ret) {
802ca850	167	dev_err(dev, "couldn't add resources to dwc3 device\n");
124dafde	168	goto err1;
72246da4 FB	169	}
	170
	171	pci_set_drvdata(pci, glue);
	172
802ca850	173	dma_set_coherent_mask(&dwc3->dev, dev->coherent_dma_mask);
72246da4	174
802ca850 CP	175	dwc3->dev.dma_mask = dev->dma_mask;
	176	dwc3->dev.dma_parms = dev->dma_parms;
	177	dwc3->dev.parent = dev;
1d046793	178	glue->dwc3 = dwc3;
72246da4 FB	179
	180	ret = platform_device_add(dwc3);
	181	if (ret) {
802ca850 CP	182	dev_err(dev, "failed to register dwc3 device\n");
802ca850 CP	183	goto err3;
72246da4 FB	184	}
	185
	186	return 0;
	187
802ca850	188	err3:
72246da4 FB	189	pci_set_drvdata(pci, NULL);
72246da4 FB	190	platform_device_put(dwc3);
72246da4	191	err1:
802ca850	192	pci_disable_device(pci);
72246da4	193
72246da4 FB	194	return ret;
	195	}
	196
	197	static void __devexit dwc3_pci_remove(struct pci_dev *pci)
	198	{
	199	struct dwc3_pci *glue = pci_get_drvdata(pci);
	200
e3ec3eb7 FB	201	platform_device_unregister(glue->usb2_phy);
e3ec3eb7 FB	202	platform_device_unregister(glue->usb3_phy);
72246da4 FB	203	platform_device_unregister(glue->dwc3);
	204	pci_set_drvdata(pci, NULL);
	205	pci_disable_device(pci);
72246da4 FB	206	}
	207
	208	static DEFINE_PCI_DEVICE_TABLE(dwc3_pci_id_table) = {
	209	{
	210	PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
	211	PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3),
	212	},
	213	{ } /* Terminating Entry */
	214	};
	215	MODULE_DEVICE_TABLE(pci, dwc3_pci_id_table);
	216
	217	static struct pci_driver dwc3_pci_driver = {
0949e99b	218	.name = "dwc3-pci",
72246da4 FB	219	.id_table = dwc3_pci_id_table,
	220	.probe = dwc3_pci_probe,
	221	.remove = __devexit_p(dwc3_pci_remove),
	222	};
	223
	224	MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
	225	MODULE_LICENSE("Dual BSD/GPL");
	226	MODULE_DESCRIPTION("DesignWare USB3 PCI Glue Layer");
	227
95656336	228	module_pci_driver(dwc3_pci_driver);