xref: /freebsd/sys/dev/usb/controller/dwc_otg_fdt.c (revision ec273ebf3b6aed5fba8c56b6ece5ad8693a48ea7)
1 /*-
2  * Copyright (c) 2012 Hans Petter Selasky. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23  * SUCH DAMAGE.
24  */
25 
26 #include <sys/cdefs.h>
27 __FBSDID("$FreeBSD$");
28 
29 #include <sys/stdint.h>
30 #include <sys/stddef.h>
31 #include <sys/param.h>
32 #include <sys/queue.h>
33 #include <sys/types.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/bus.h>
37 #include <sys/module.h>
38 #include <sys/lock.h>
39 #include <sys/mutex.h>
40 #include <sys/condvar.h>
41 #include <sys/sysctl.h>
42 #include <sys/sx.h>
43 #include <sys/unistd.h>
44 #include <sys/callout.h>
45 #include <sys/malloc.h>
46 #include <sys/priv.h>
47 #include <sys/rman.h>
48 
49 #include <dev/fdt/fdt_common.h>
50 #include <dev/ofw/openfirm.h>
51 #include <dev/ofw/ofw_bus.h>
52 #include <dev/ofw/ofw_bus_subr.h>
53 
54 #include <dev/usb/usb.h>
55 #include <dev/usb/usbdi.h>
56 
57 #include <dev/usb/usb_core.h>
58 #include <dev/usb/usb_busdma.h>
59 #include <dev/usb/usb_process.h>
60 #include <dev/usb/usb_util.h>
61 
62 #include <dev/usb/usb_controller.h>
63 #include <dev/usb/usb_bus.h>
64 
65 #include <dev/usb/controller/dwc_otg.h>
66 
67 static device_probe_t dwc_otg_probe;
68 static device_attach_t dwc_otg_attach;
69 static device_detach_t dwc_otg_detach;
70 
71 struct dwc_otg_super_softc {
72 	struct dwc_otg_softc sc_otg;	/* must be first */
73 };
74 
75 static int
76 dwc_otg_probe(device_t dev)
77 {
78 
79 	if (!ofw_bus_status_okay(dev))
80 		return (ENXIO);
81 
82 	if (!ofw_bus_is_compatible(dev, "synopsys,designware-hs-otg2"))
83 		return (ENXIO);
84 
85 	device_set_desc(dev, "DWC OTG 2.0 integrated USB controller");
86 
87 	return (0);
88 }
89 
90 static int
91 dwc_otg_attach(device_t dev)
92 {
93 	struct dwc_otg_super_softc *sc = device_get_softc(dev);
94 	char usb_mode[24];
95 	int err;
96 	int rid;
97 
98 	/* initialise some bus fields */
99 	sc->sc_otg.sc_bus.parent = dev;
100 	sc->sc_otg.sc_bus.devices = sc->sc_otg.sc_devices;
101 	sc->sc_otg.sc_bus.devices_max = DWC_OTG_MAX_DEVICES;
102 	sc->sc_otg.sc_bus.dma_bits = 32;
103 
104 	/* get USB mode, if any */
105 	if (OF_getprop(ofw_bus_get_node(dev), "dr_mode",
106 	    &usb_mode, sizeof(usb_mode)) > 0) {
107 
108 		/* ensure proper zero termination */
109 		usb_mode[sizeof(usb_mode) - 1] = 0;
110 
111 		if (strcasecmp(usb_mode, "host") == 0)
112 			sc->sc_otg.sc_mode = DWC_MODE_HOST;
113 		else if (strcasecmp(usb_mode, "peripheral") == 0)
114 			sc->sc_otg.sc_mode = DWC_MODE_DEVICE;
115 		else if (strcasecmp(usb_mode, "otg") != 0) {
116 			device_printf(dev, "Invalid FDT dr_mode: %s\n",
117 			    usb_mode);
118 		}
119 	}
120 
121 	/* get all DMA memory */
122 	if (usb_bus_mem_alloc_all(&sc->sc_otg.sc_bus,
123 	    USB_GET_DMA_TAG(dev), NULL)) {
124 		return (ENOMEM);
125 	}
126 	rid = 0;
127 	sc->sc_otg.sc_io_res =
128 	    bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
129 
130 	if (!(sc->sc_otg.sc_io_res)) {
131 		err = ENOMEM;
132 		goto error;
133 	}
134 	sc->sc_otg.sc_io_tag = rman_get_bustag(sc->sc_otg.sc_io_res);
135 	sc->sc_otg.sc_io_hdl = rman_get_bushandle(sc->sc_otg.sc_io_res);
136 	sc->sc_otg.sc_io_size = rman_get_size(sc->sc_otg.sc_io_res);
137 
138 	rid = 0;
139 	sc->sc_otg.sc_irq_res =
140 	    bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE);
141 	if (sc->sc_otg.sc_irq_res == NULL)
142 		goto error;
143 
144 	sc->sc_otg.sc_bus.bdev = device_add_child(dev, "usbus", -1);
145 	if (sc->sc_otg.sc_bus.bdev == NULL)
146 		goto error;
147 
148 	device_set_ivars(sc->sc_otg.sc_bus.bdev, &sc->sc_otg.sc_bus);
149 
150 	err = bus_setup_intr(dev, sc->sc_otg.sc_irq_res, INTR_TYPE_TTY | INTR_MPSAFE,
151 	    &dwc_otg_filter_interrupt, &dwc_otg_interrupt, sc, &sc->sc_otg.sc_intr_hdl);
152 	if (err) {
153 		sc->sc_otg.sc_intr_hdl = NULL;
154 		goto error;
155 	}
156 	err = dwc_otg_init(&sc->sc_otg);
157 	if (err == 0) {
158 		err = device_probe_and_attach(sc->sc_otg.sc_bus.bdev);
159 	}
160 	if (err)
161 		goto error;
162 
163 
164 	return (0);
165 
166 error:
167 	dwc_otg_detach(dev);
168 	return (ENXIO);
169 }
170 
171 static int
172 dwc_otg_detach(device_t dev)
173 {
174 	struct dwc_otg_super_softc *sc = device_get_softc(dev);
175 	device_t bdev;
176 	int err;
177 
178 	if (sc->sc_otg.sc_bus.bdev) {
179 		bdev = sc->sc_otg.sc_bus.bdev;
180 		device_detach(bdev);
181 		device_delete_child(dev, bdev);
182 	}
183 	/* during module unload there are lots of children leftover */
184 	device_delete_children(dev);
185 
186 	if (sc->sc_otg.sc_irq_res && sc->sc_otg.sc_intr_hdl) {
187 		/*
188 		 * only call dwc_otg_uninit() after dwc_otg_init()
189 		 */
190 		dwc_otg_uninit(&sc->sc_otg);
191 
192 		err = bus_teardown_intr(dev, sc->sc_otg.sc_irq_res,
193 		    sc->sc_otg.sc_intr_hdl);
194 		sc->sc_otg.sc_intr_hdl = NULL;
195 	}
196 	/* free IRQ channel, if any */
197 	if (sc->sc_otg.sc_irq_res) {
198 		bus_release_resource(dev, SYS_RES_IRQ, 0,
199 		    sc->sc_otg.sc_irq_res);
200 		sc->sc_otg.sc_irq_res = NULL;
201 	}
202 	/* free memory resource, if any */
203 	if (sc->sc_otg.sc_io_res) {
204 		bus_release_resource(dev, SYS_RES_MEMORY, 0,
205 		    sc->sc_otg.sc_io_res);
206 		sc->sc_otg.sc_io_res = NULL;
207 	}
208 	usb_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL);
209 
210 	return (0);
211 }
212 
213 static device_method_t dwc_otg_methods[] = {
214 	/* Device interface */
215 	DEVMETHOD(device_probe, dwc_otg_probe),
216 	DEVMETHOD(device_attach, dwc_otg_attach),
217 	DEVMETHOD(device_detach, dwc_otg_detach),
218 	DEVMETHOD(device_suspend, bus_generic_suspend),
219 	DEVMETHOD(device_resume, bus_generic_resume),
220 	DEVMETHOD(device_shutdown, bus_generic_shutdown),
221 
222 	DEVMETHOD_END
223 };
224 
225 static driver_t dwc_otg_driver = {
226 	.name = "dwcotg",
227 	.methods = dwc_otg_methods,
228 	.size = sizeof(struct dwc_otg_super_softc),
229 };
230 
231 static devclass_t dwc_otg_devclass;
232 
233 DRIVER_MODULE(dwcotg, simplebus, dwc_otg_driver, dwc_otg_devclass, 0, 0);
234 MODULE_DEPEND(dwcotg, usb, 1, 1, 1);
235