xref: /freebsd/sys/dev/usb/controller/ehci_imx.c (revision 7ef62cebc2f965b0f640263e179276928885e33d)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2010-2012 Semihalf
5  * Copyright (c) 2012 The FreeBSD Foundation
6  * Copyright (c) 2013 Ian Lepore <ian@freebsd.org>
7  * All rights reserved.
8  *
9  * Portions of this software were developed by Oleksandr Rybalko
10  * under sponsorship from the FreeBSD Foundation.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33 
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36 
37 /*
38  * EHCI driver for Freescale i.MX SoCs which incorporate the USBOH3 controller.
39  */
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/kernel.h>
44 #include <sys/module.h>
45 #include <sys/bus.h>
46 #include <sys/condvar.h>
47 #include <sys/rman.h>
48 
49 #include <dev/ofw/ofw_bus.h>
50 #include <dev/ofw/ofw_bus_subr.h>
51 
52 #include <dev/usb/usb.h>
53 #include <dev/usb/usbdi.h>
54 #include <dev/usb/usb_busdma.h>
55 #include <dev/usb/usb_process.h>
56 #include <dev/usb/usb_controller.h>
57 #include <dev/usb/usb_bus.h>
58 #include <dev/usb/controller/ehci.h>
59 #include <dev/usb/controller/ehcireg.h>
60 #include "usbdevs.h"
61 
62 #include <machine/bus.h>
63 #include <machine/resource.h>
64 
65 #include <arm/freescale/imx/imx_ccmvar.h>
66 
67 #include "opt_platform.h"
68 
69 /*
70  * Notes on the hardware and related FDT data seen in the wild.
71  *
72  * There are two sets of registers in the USBOH3 implementation; documentation
73  * refers to them as "core" and "non-core" registers.  A set of core register
74  * exists for each OTG or EHCI device.  There is a single set of non-core
75  * registers per USBOH3, and they control aspects of operation not directly
76  * related to the USB specs, such as whether interrupts from each of the core
77  * devices are able to generate a SoC wakeup event.
78  *
79  * In the FreeBSD universe we might be inclined to describe the core and
80  * non-core registers by using a pair of resource address/size values (two
81  * entries in the reg property for each core).  However, we have to work with
82  * existing FDT data (which mostly comes from the linux universe), and the way
83  * they've chosen to represent this is with an entry for a "usbmisc" device
84  * whose reg property describes the non-core registers. The way we handle FDT
85  * data, this means that the resources (memory-mapped register range) for the
86  * non-core registers belongs to a device other than the echi devices.
87  *
88  * Because the main ehci device cannot access registers in a range that's
89  * defined in the fdt data as belonging to another device, we implement a teeny
90  * little "usbmisc" driver which exists only to provide access to the usbmisc
91  * control register for each of the 4 usb controller instances.  That little
92  * driver is implemented here in this file, before the main driver.
93  *
94  * In addition to the single usbmisc device, the existing FDT data defines a
95  * separate device for each of the OTG or EHCI cores within the USBOH3.  Each of
96  * those devices has a set of core registers described by the reg property.
97  *
98  * The core registers for each of the four cores in the USBOH3 are divided into
99  * two parts: a set of imx-specific registers at an offset of 0 from the
100  * beginning of the register range, and the standard USB (EHCI or OTG) registers
101  * at an offset of 0x100 from the beginning of the register range.  The FreeBSD
102  * way of dealing with this might be to map out two ranges in the reg property,
103  * but that's not what the alternate universe has done.  To work with existing
104  * FDT data, we acquire the resource that maps all the core registers, then use
105  * bus_space_subregion() to create another resource that maps just the standard
106  * USB registers, which we provide to the standard USB code in the ehci_softc.
107  *
108  * The following compat strings have been seen for the OTG and EHCI cores.  The
109  * FDT compat table in this driver contains all these strings, but as of this
110  * writing, not all of these SoCs have been tested with the driver.  The fact
111  * that imx27 is common to all of them gives some hope that the driver will work
112  * on all these SoCs.
113  *   - "fsl,imx23-usb", "fsl,imx27-usb";
114  *   - "fsl,imx25-usb", "fsl,imx27-usb";
115  *   - "fsl,imx28-usb", "fsl,imx27-usb";
116  *   - "fsl,imx51-usb", "fsl,imx27-usb";
117  *   - "fsl,imx53-usb", "fsl,imx27-usb";
118  *   - "fsl,imx6q-usb", "fsl,imx27-usb";
119  *
120  * The FDT data for some SoCs contains the following properties, which we don't
121  * currently do anything with:
122  *   - fsl,usbmisc = <&usbmisc 0>;
123  *   - fsl,usbphy = <&usbphy0>;
124  *
125  * Some imx SoCs have FDT data related to USB PHY, some don't.  We have separate
126  * usbphy drivers where needed; this data is mentioned here just to keep all the
127  * imx-FDT-usb-related info in one place.  Here are the usbphy compat strings
128  * known to exist:
129  *   - "nop-usbphy"
130  *   - "usb-nop-xceiv";
131  *   - "fsl,imx23-usbphy"
132  *   - "fsl,imx28-usbphy", "fsl,imx23-usbphy";
133  *   - "fsl,imx6q-usbphy", "fsl,imx23-usbphy";
134  *
135  */
136 
137 /*-----------------------------------------------------------------------------
138  * imx_usbmisc driver
139  *---------------------------------------------------------------------------*/
140 
141 #define	USBNC_OVER_CUR_POL	  (1u << 8)
142 #define	USBNC_OVER_CUR_DIS	  (1u << 7)
143 
144 struct imx_usbmisc_softc {
145 	device_t	dev;
146 	struct resource	*mmio;
147 };
148 
149 static struct ofw_compat_data usbmisc_compat_data[] = {
150 	{"fsl,imx6q-usbmisc",	true},
151 	{"fsl,imx51-usbmisc",	true},
152 	{"fsl,imx25-usbmisc",	true},
153 	{NULL, 			false},
154 };
155 
156 static void
157 imx_usbmisc_set_ctrl(device_t dev, u_int index, uint32_t bits)
158 {
159 	struct imx_usbmisc_softc *sc;
160 	uint32_t reg;
161 
162 	sc = device_get_softc(dev);
163 	reg = bus_read_4(sc->mmio, index * sizeof(uint32_t));
164 	bus_write_4(sc->mmio, index * sizeof(uint32_t), reg | bits);
165 }
166 
167 #ifdef notyet
168 static void
169 imx_usbmisc_clr_ctrl(device_t dev, u_int index, uint32_t bits)
170 {
171 	struct imx_usbmisc_softc *sc;
172 	uint32_t reg;
173 
174 	sc = device_get_softc(dev);
175 	reg = bus_read_4(sc->mmio, index * sizeof(uint32_t));
176 	bus_write_4(sc->mmio, index * sizeof(uint32_t), reg & ~bits);
177 }
178 #endif
179 
180 static int
181 imx_usbmisc_probe(device_t dev)
182 {
183 
184 	if (!ofw_bus_status_okay(dev))
185 		return (ENXIO);
186 
187 	if (ofw_bus_search_compatible(dev, usbmisc_compat_data)->ocd_data) {
188 		device_set_desc(dev, "i.MX USB Misc Control");
189 		return (BUS_PROBE_DEFAULT);
190 	}
191 	return (ENXIO);
192 }
193 
194 static int
195 imx_usbmisc_detach(device_t dev)
196 {
197 	struct imx_usbmisc_softc *sc;
198 
199 	sc = device_get_softc(dev);
200 
201 	if (sc->mmio != NULL)
202 		bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mmio);
203 
204 	return (0);
205 }
206 
207 static int
208 imx_usbmisc_attach(device_t dev)
209 {
210 	struct imx_usbmisc_softc *sc;
211 	int rid;
212 
213 	sc = device_get_softc(dev);
214 
215 	/* Allocate bus_space resources. */
216 	rid = 0;
217 	sc->mmio = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
218 	    RF_ACTIVE);
219 	if (sc->mmio == NULL) {
220 		device_printf(dev, "Cannot allocate memory resources\n");
221 		return (ENXIO);
222 	}
223 
224 	OF_device_register_xref(OF_xref_from_node(ofw_bus_get_node(dev)), dev);
225 
226 	return (0);
227 }
228 
229 static device_method_t imx_usbmisc_methods[] = {
230 	/* Device interface */
231 	DEVMETHOD(device_probe, 	imx_usbmisc_probe),
232 	DEVMETHOD(device_attach,	imx_usbmisc_attach),
233 	DEVMETHOD(device_detach,	imx_usbmisc_detach),
234 
235 	DEVMETHOD_END
236 };
237 
238 static driver_t imx_usbmisc_driver = {
239 	"imx_usbmisc",
240 	imx_usbmisc_methods,
241 	sizeof(struct imx_usbmisc_softc)
242 };
243 
244 /*
245  * This driver needs to start before the ehci driver, but later than the usual
246  * "special" drivers like clocks and cpu.  Ehci starts at DEFAULT so
247  * DEFAULT-1000 seems good.
248  */
249 EARLY_DRIVER_MODULE(imx_usbmisc, simplebus, imx_usbmisc_driver,
250     0, 0, BUS_PASS_DEFAULT - 1000);
251 
252 /*-----------------------------------------------------------------------------
253  * imx_ehci driver...
254  *---------------------------------------------------------------------------*/
255 
256 /*
257  * Each EHCI device in the SoC has some SoC-specific per-device registers at an
258  * offset of 0, then the standard EHCI registers begin at an offset of 0x100.
259  */
260 #define	IMX_EHCI_REG_OFF	0x100
261 #define	IMX_EHCI_REG_SIZE	0x100
262 
263 struct imx_ehci_softc {
264 	ehci_softc_t	ehci_softc;
265 	device_t	dev;
266 	struct resource	*ehci_mem_res;	/* EHCI core regs. */
267 	struct resource	*ehci_irq_res;	/* EHCI core IRQ. */
268 };
269 
270 static struct ofw_compat_data compat_data[] = {
271 	{"fsl,imx6q-usb",	1},
272 	{"fsl,imx53-usb",	1},
273 	{"fsl,imx51-usb",	1},
274 	{"fsl,imx28-usb",	1},
275 	{"fsl,imx27-usb",	1},
276 	{"fsl,imx25-usb",	1},
277 	{"fsl,imx23-usb",	1},
278 	{NULL,		 	0},
279 };
280 
281 static void
282 imx_ehci_post_reset(struct ehci_softc *ehci_softc)
283 {
284         uint32_t usbmode;
285 
286         /* Force HOST mode */
287         usbmode = EOREAD4(ehci_softc, EHCI_USBMODE_NOLPM);
288         usbmode &= ~EHCI_UM_CM;
289         usbmode |= EHCI_UM_CM_HOST;
290         EOWRITE4(ehci_softc, EHCI_USBMODE_NOLPM, usbmode);
291 }
292 
293 static int
294 imx_ehci_probe(device_t dev)
295 {
296 
297 	if (!ofw_bus_status_okay(dev))
298 		return (ENXIO);
299 
300 	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data != 0) {
301 		device_set_desc(dev, "Freescale i.MX integrated USB controller");
302 		return (BUS_PROBE_DEFAULT);
303 	}
304 	return (ENXIO);
305 }
306 
307 static int
308 imx_ehci_detach(device_t dev)
309 {
310 	struct imx_ehci_softc *sc;
311 	ehci_softc_t *esc;
312 	int err;
313 
314 	sc = device_get_softc(dev);
315 
316 	esc = &sc->ehci_softc;
317 
318 	/* First detach all children; we can't detach if that fails. */
319 	if ((err = device_delete_children(dev)) != 0)
320 		return (err);
321 
322 	if (esc->sc_flags & EHCI_SCFLG_DONEINIT)
323 		ehci_detach(esc);
324 	if (esc->sc_intr_hdl != NULL)
325 		bus_teardown_intr(dev, esc->sc_irq_res,
326 		    esc->sc_intr_hdl);
327 	if (sc->ehci_irq_res != NULL)
328 		bus_release_resource(dev, SYS_RES_IRQ, 0,
329 		    sc->ehci_irq_res);
330 	if (sc->ehci_mem_res != NULL)
331 		bus_release_resource(dev, SYS_RES_MEMORY, 0,
332 		    sc->ehci_mem_res);
333 
334 	usb_bus_mem_free_all(&esc->sc_bus, &ehci_iterate_hw_softc);
335 
336 	return (0);
337 }
338 
339 static void
340 imx_ehci_disable_oc(struct imx_ehci_softc *sc)
341 {
342 	device_t usbmdev;
343 	pcell_t usbmprops[2];
344 	phandle_t node;
345 	ssize_t size;
346 	int index;
347 
348 	/* Get the reference to the usbmisc driver from the fdt data */
349 	node = ofw_bus_get_node(sc->dev);
350 	size = OF_getencprop(node, "fsl,usbmisc", usbmprops,
351 	    sizeof(usbmprops));
352 	if (size < sizeof(usbmprops)) {
353 		device_printf(sc->dev, "failed to retrieve fsl,usbmisc "
354 		   "property, cannot disable overcurrent protection");
355 		return;
356 	}
357 	/* Retrieve the device_t via the xref handle. */
358 	usbmdev = OF_device_from_xref(usbmprops[0]);
359 	if (usbmdev == NULL) {
360 		device_printf(sc->dev, "usbmisc device not found, "
361 		    "cannot disable overcurrent protection");
362 		return;
363 	}
364 	/* Call the device routine to set the overcurrent disable bit. */
365 	index = usbmprops[1];
366 	imx_usbmisc_set_ctrl(usbmdev, index, USBNC_OVER_CUR_DIS);
367 }
368 
369 static int
370 imx_ehci_attach(device_t dev)
371 {
372 	struct imx_ehci_softc *sc;
373 	ehci_softc_t *esc;
374 	int err, rid;
375 
376 	sc = device_get_softc(dev);
377 	sc->dev = dev;
378 	esc = &sc->ehci_softc;
379 	err = 0;
380 
381 	/* Allocate bus_space resources. */
382 	rid = 0;
383 	sc->ehci_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
384 	    RF_ACTIVE);
385 	if (sc->ehci_mem_res == NULL) {
386 		device_printf(dev, "Cannot allocate memory resources\n");
387 		err = ENXIO;
388 		goto out;
389 	}
390 
391 	rid = 0;
392 	sc->ehci_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
393 	    RF_ACTIVE);
394 	if (sc->ehci_irq_res == NULL) {
395 		device_printf(dev, "Cannot allocate IRQ resources\n");
396 		err = ENXIO;
397 		goto out;
398 	}
399 
400 	esc->sc_io_tag = rman_get_bustag(sc->ehci_mem_res);
401 	esc->sc_bus.parent = dev;
402 	esc->sc_bus.devices = esc->sc_devices;
403 	esc->sc_bus.devices_max = EHCI_MAX_DEVICES;
404 	esc->sc_bus.dma_bits = 32;
405 
406 	/* allocate all DMA memory */
407 	if (usb_bus_mem_alloc_all(&esc->sc_bus, USB_GET_DMA_TAG(dev),
408 	    &ehci_iterate_hw_softc) != 0) {
409 		device_printf(dev, "usb_bus_mem_alloc_all() failed\n");
410 		err = ENOMEM;
411 		goto out;
412 	}
413 
414 	/*
415 	 * Set handle to USB related registers subregion used by
416 	 * generic EHCI driver.
417 	 */
418 	err = bus_space_subregion(esc->sc_io_tag,
419 	    rman_get_bushandle(sc->ehci_mem_res),
420 	    IMX_EHCI_REG_OFF, IMX_EHCI_REG_SIZE, &esc->sc_io_hdl);
421 	if (err != 0) {
422 		device_printf(dev, "bus_space_subregion() failed\n");
423 		err = ENXIO;
424 		goto out;
425 	}
426 
427 	/* Setup interrupt handler. */
428 	err = bus_setup_intr(dev, sc->ehci_irq_res, INTR_TYPE_BIO | INTR_MPSAFE,
429 	    NULL, (driver_intr_t *)ehci_interrupt, esc, &esc->sc_intr_hdl);
430 	if (err != 0) {
431 		device_printf(dev, "Could not setup IRQ\n");
432 		goto out;
433 	}
434 
435 	/* Turn on clocks. */
436 	imx_ccm_usb_enable(dev);
437 
438 	/* Disable overcurrent detection, if configured to do so. */
439 	if (OF_hasprop(ofw_bus_get_node(sc->dev), "disable-over-current"))
440 		imx_ehci_disable_oc(sc);
441 
442 	/* Add USB bus device. */
443 	esc->sc_bus.bdev = device_add_child(dev, "usbus", -1);
444 	if (esc->sc_bus.bdev == NULL) {
445 		device_printf(dev, "Could not add USB device\n");
446 		goto out;
447 	}
448 	device_set_ivars(esc->sc_bus.bdev, &esc->sc_bus);
449 
450 	esc->sc_id_vendor = USB_VENDOR_FREESCALE;
451 	strlcpy(esc->sc_vendor, "Freescale", sizeof(esc->sc_vendor));
452 
453 	/*
454 	 * Set flags that affect ehci_init() behavior, and hook our post-reset
455 	 * code into the standard controller code.
456 	 */
457 	esc->sc_flags |= EHCI_SCFLG_NORESTERM | EHCI_SCFLG_TT;
458 	esc->sc_vendor_post_reset = imx_ehci_post_reset;
459 	esc->sc_vendor_get_port_speed = ehci_get_port_speed_portsc;
460 
461 	err = ehci_init(esc);
462 	if (err != 0) {
463 		device_printf(dev, "USB init failed, usb_err_t=%d\n",
464 		    err);
465 		goto out;
466 	}
467 	esc->sc_flags |= EHCI_SCFLG_DONEINIT;
468 
469 	/* Probe the bus. */
470 	err = device_probe_and_attach(esc->sc_bus.bdev);
471 	if (err != 0) {
472 		device_printf(dev,
473 		    "device_probe_and_attach() failed\n");
474 		goto out;
475 	}
476 
477 	err = 0;
478 
479 out:
480 
481 	if (err != 0)
482 		imx_ehci_detach(dev);
483 
484 	return (err);
485 }
486 
487 static device_method_t ehci_methods[] = {
488 	/* Device interface */
489 	DEVMETHOD(device_probe, imx_ehci_probe),
490 	DEVMETHOD(device_attach, imx_ehci_attach),
491 	DEVMETHOD(device_detach, imx_ehci_detach),
492 	DEVMETHOD(device_suspend, bus_generic_suspend),
493 	DEVMETHOD(device_resume, bus_generic_resume),
494 	DEVMETHOD(device_shutdown, bus_generic_shutdown),
495 
496 	/* Bus interface */
497 	DEVMETHOD(bus_print_child, bus_generic_print_child),
498 
499 	DEVMETHOD_END
500 };
501 
502 static driver_t ehci_driver = {
503 	"ehci",
504 	ehci_methods,
505 	sizeof(struct imx_ehci_softc)
506 };
507 
508 DRIVER_MODULE(imx_ehci, simplebus, ehci_driver, 0, 0);
509 MODULE_DEPEND(imx_ehci, usb, 1, 1, 1);
510