1/* $FreeBSD$ */
2/*-
3 * SPDX-License-Identifier: BSD-2-Clause-NetBSD
4 *
5 * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved.
6 * Copyright (c) 1998 Lennart Augustsson. All rights reserved.
7 * Copyright (c) 2008-2010 Hans Petter Selasky. All rights reserved.
8 * Copyright (c) 2019 Takanori Watanabe.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
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 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32/*
33 * USB spec: http://www.usb.org/developers/docs/usbspec.zip
34 */
35
36#ifdef USB_GLOBAL_INCLUDE_FILE
37#include USB_GLOBAL_INCLUDE_FILE
38#else
39#include <sys/stdint.h>
40#include <sys/stddef.h>
41#include <sys/param.h>
42#include <sys/queue.h>
43#include <sys/types.h>
44#include <sys/systm.h>
45#include <sys/kernel.h>
46#include <sys/bus.h>
47#include <sys/module.h>
48#include <sys/lock.h>
49#include <sys/mutex.h>
50#include <sys/condvar.h>
51#include <sys/sysctl.h>
52#include <sys/sx.h>
53#include <sys/unistd.h>
54#include <sys/callout.h>
55#include <sys/malloc.h>
56#include <sys/priv.h>
57
58#include <dev/usb/usb.h>
59#include <dev/usb/usbdi.h>
60#include <dev/usb/usbdi_util.h>
61
62#define	USB_DEBUG_VAR uhub_debug
63
64#include <dev/usb/usb_core.h>
65#include <dev/usb/usb_process.h>
66#include <dev/usb/usb_device.h>
67#include <dev/usb/usb_request.h>
68#include <dev/usb/usb_debug.h>
69#include <dev/usb/usb_hub.h>
70#include <dev/usb/usb_util.h>
71#include <dev/usb/usb_busdma.h>
72#include <dev/usb/usb_transfer.h>
73#include <dev/usb/usb_dynamic.h>
74
75#include <dev/usb/usb_controller.h>
76#include <dev/usb/usb_bus.h>
77#endif					/* USB_GLOBAL_INCLUDE_FILE */
78#include <dev/usb/usb_hub_private.h>
79#include <contrib/dev/acpica/include/acpi.h>
80#include <contrib/dev/acpica/include/accommon.h>
81#include <dev/acpica/acpivar.h>
82#include <sys/sbuf.h>
83
84#define ACPI_PLD_SIZE 20
85struct acpi_uhub_port {
86	ACPI_HANDLE handle;
87#define    ACPI_UPC_CONNECTABLE 0x80000000
88#define    ACPI_UPC_PORTTYPE(x) ((x)&0xff)
89	uint32_t upc;
90	uint8_t	pld[ACPI_PLD_SIZE];
91};
92
93struct acpi_uhub_softc {
94	struct uhub_softc usc;
95	uint8_t	nports;
96	ACPI_HANDLE ah;
97	struct acpi_uhub_port *port;
98};
99
100static UINT32
101acpi_uhub_find_rh_cb(ACPI_HANDLE ah, UINT32 nl, void *ctx, void **status)
102{
103	ACPI_DEVICE_INFO *devinfo;
104	UINT32 ret;
105
106	*status = NULL;
107	devinfo = NULL;
108
109	ret = AcpiGetObjectInfo(ah, &devinfo);
110	if (ACPI_SUCCESS(ret)) {
111		if ((devinfo->Valid & ACPI_VALID_ADR) &&
112		    (devinfo->Address == 0)) {
113			ret = AE_CTRL_TERMINATE;
114			*status = ah;
115		}
116		AcpiOsFree(devinfo);
117	}
118	return (ret);
119}
120
121static const char *
122acpi_uhub_upc_type(uint8_t type)
123{
124	const char *typelist[] = {"TypeA", "MiniAB", "Express",
125				  "USB3-A", "USB3-B", "USB-MicroB",
126				  "USB3-MicroAB", "USB3-PowerB",
127				  "TypeC-USB2", "TypeC-Switch",
128				  "TypeC-nonSwitch"};
129	const int last = sizeof(typelist) / sizeof(typelist[0]);
130
131	if (type == 0xff) {
132		return "Proprietary";
133	}
134
135	return (type < last) ? typelist[type] : "Unknown";
136}
137
138static int
139acpi_uhub_parse_upc(device_t dev, unsigned int p, ACPI_HANDLE ah, struct sysctl_oid_list *poid)
140{
141	ACPI_BUFFER buf;
142	struct acpi_uhub_softc *sc = device_get_softc(dev);
143	struct acpi_uhub_port *port = &sc->port[p - 1];
144
145	buf.Pointer = NULL;
146	buf.Length = ACPI_ALLOCATE_BUFFER;
147
148	if (AcpiEvaluateObject(ah, "_UPC", NULL, &buf) == AE_OK) {
149		ACPI_OBJECT *obj = buf.Pointer;
150		UINT64 porttypenum, conn;
151		uint8_t *connectable;
152
153		acpi_PkgInt(obj, 0, &conn);
154		acpi_PkgInt(obj, 1, &porttypenum);
155		connectable = conn ? "" : "non";
156
157		port->upc = porttypenum;
158		port->upc |= (conn) ? (ACPI_UPC_CONNECTABLE) : 0;
159
160		if (usb_debug)
161			device_printf(dev, "Port %u %sconnectable %s\n",
162			    p, connectable,
163			    acpi_uhub_upc_type(porttypenum));
164
165		SYSCTL_ADD_U32(
166		    device_get_sysctl_ctx(dev),
167		    poid, OID_AUTO,
168		    "upc",
169		    CTLFLAG_RD | CTLFLAG_MPSAFE,
170		    SYSCTL_NULL_U32_PTR, port->upc,
171		    "UPC value. MSB is visible flag");
172	}
173	AcpiOsFree(buf.Pointer);
174
175	return (0);
176}
177static int
178acpi_uhub_port_sysctl(SYSCTL_HANDLER_ARGS)
179{
180	struct acpi_uhub_port *port = oidp->oid_arg1;
181	struct sbuf sb;
182	int error;
183
184	sbuf_new_for_sysctl(&sb, NULL, 256, req);
185	sbuf_printf(&sb, "Handle %s\n", acpi_name(port->handle));
186	if (port->upc == 0xffffffff) {
187		sbuf_printf(&sb, "\tNo information\n");
188		goto end;
189	}
190	sbuf_printf(&sb, "\t");
191	if (port->upc & ACPI_UPC_CONNECTABLE) {
192		sbuf_printf(&sb, "Connectable ");
193	}
194	sbuf_printf(&sb, "%s port\n", acpi_uhub_upc_type(port->upc & 0xff));
195
196	if ((port->pld[0] & 0x80) == 0) {
197		sbuf_printf(&sb,
198		    "\tColor:#%02x%02x%02x\n",
199		    port->pld[1], port->pld[2],
200		    port->pld[3]);
201	}
202	sbuf_printf(&sb, "\tWidth %d mm Height %d mm\n",
203	    port->pld[4] | (port->pld[5] << 8),
204	    port->pld[6] | (port->pld[7] << 8));
205	if (port->pld[8] & 1) {
206		sbuf_printf(&sb, "\tVisible\n");
207	}
208	if (port->pld[8] & 2) {
209		sbuf_printf(&sb, "\tDock\n");
210	}
211	if (port->pld[8] & 4) {
212		sbuf_printf(&sb, "\tLid\n");
213	} {
214		int panelpos = (port->pld[8] >> 3) & 7;
215		const char *panposstr[] = {"Top", "Bottom", "Left",
216					   "Right", "Front", "Back",
217					   "Unknown", "Invalid"};
218		const char *shapestr[] = {
219			"Round", "Oval", "Square", "VRect", "HRect",
220			"VTrape", "HTrape", "Unknown", "Chamferd",
221			"Rsvd", "Rsvd", "Rsvd", "Rsvd",
222			"Rsvd", "Rsvd", "Rsvd", "Rsvd"};
223
224		sbuf_printf(&sb, "\tPanelPosition: %s\n", panposstr[panelpos]);
225		if (panelpos < 6) {
226			const char *posstr[] = {"Upper", "Center",
227			"Lower", "Invalid"};
228
229			sbuf_printf(&sb, "\tVertPosition: %s\n",
230			    posstr[(port->pld[8] >> 6) & 3]);
231			sbuf_printf(&sb, "\tHorizPosition: %s\n",
232			    posstr[(port->pld[9]) & 3]);
233		}
234		sbuf_printf(&sb, "\tShape: %s\n",
235		    shapestr[(port->pld[9] >> 2) & 0xf]);
236		sbuf_printf(&sb, "\tGroup Orientation %s\n",
237		    ((port->pld[9] >> 6) & 1) ? "Vertical" :
238		    "Horizontal");
239		sbuf_printf(&sb, "\tGroupToken %x\n",
240		    ((port->pld[9] >> 7)
241		    | (port->pld[10] << 1)) & 0xff);
242		sbuf_printf(&sb, "\tGroupPosition %x\n",
243		    ((port->pld[10] >> 7)
244		    | (port->pld[11] << 1)) & 0xff);
245		sbuf_printf(&sb, "\t%s %s %s\n",
246		    (port->pld[11] & 0x80) ?
247		    "Bay" : "",
248		    (port->pld[12] & 1) ? "Eject" : "",
249		    (port->pld[12] & 2) ? "OSPM" : ""
250		    );
251	}
252	if ((port->pld[0] & 0x7f) >= 2) {
253		sbuf_printf(&sb, "\tVOFF%d mm HOFF %dmm",
254		    port->pld[16] | (port->pld[17] << 8),
255		    port->pld[18] | (port->pld[19] << 8));
256	}
257
258end:
259	error = sbuf_finish(&sb);
260	sbuf_delete(&sb);
261	return (error);
262}
263
264static int
265acpi_uhub_parse_pld(device_t dev, unsigned int p, ACPI_HANDLE ah, struct sysctl_oid_list *tree)
266{
267	ACPI_BUFFER buf;
268	struct acpi_uhub_softc *sc = device_get_softc(dev);
269	struct acpi_uhub_port *port = &sc->port[p - 1];
270
271	buf.Pointer = NULL;
272	buf.Length = ACPI_ALLOCATE_BUFFER;
273
274	if (AcpiEvaluateObject(ah, "_PLD", NULL, &buf) == AE_OK) {
275		ACPI_OBJECT *obj;
276		unsigned char *resbuf;
277		int len;
278
279		obj = buf.Pointer;
280
281		if (obj->Type == ACPI_TYPE_PACKAGE
282		    && obj->Package.Elements[0].Type == ACPI_TYPE_BUFFER) {
283			ACPI_OBJECT *obj1;
284
285			obj1 = &obj->Package.Elements[0];
286			len = obj1->Buffer.Length;
287			resbuf = obj1->Buffer.Pointer;
288		} else if (obj->Type == ACPI_TYPE_BUFFER) {
289			len = obj->Buffer.Length;
290			resbuf = obj->Buffer.Pointer;
291		} else {
292			goto skip;
293		}
294		len = (len < ACPI_PLD_SIZE) ? len : ACPI_PLD_SIZE;
295		memcpy(port->pld, resbuf, len);
296		SYSCTL_ADD_OPAQUE(
297		    device_get_sysctl_ctx(dev), tree, OID_AUTO,
298		    "pldraw", CTLFLAG_RD | CTLFLAG_MPSAFE,
299		    port->pld, len, "A", "Raw PLD value");
300
301		if (usb_debug) {
302			device_printf(dev, "Revision:%d\n",
303			    resbuf[0] & 0x7f);
304			if ((resbuf[0] & 0x80) == 0) {
305				device_printf(dev,
306				    "Color:#%02x%02x%02x\n",
307				    resbuf[1], resbuf[2],
308				    resbuf[3]);
309			}
310			device_printf(dev, "Width %d mm Height %d mm\n",
311			    resbuf[4] | (resbuf[5] << 8),
312			    resbuf[6] | (resbuf[7] << 8));
313			if (resbuf[8] & 1) {
314				device_printf(dev, "Visible\n");
315			}
316			if (resbuf[8] & 2) {
317				device_printf(dev, "Dock\n");
318			}
319			if (resbuf[8] & 4) {
320				device_printf(dev, "Lid\n");
321			}
322			device_printf(dev, "PanelPosition: %d\n",
323			    (resbuf[8] >> 3) & 7);
324			device_printf(dev, "VertPosition: %d\n",
325			    (resbuf[8] >> 6) & 3);
326			device_printf(dev, "HorizPosition: %d\n",
327			    (resbuf[9]) & 3);
328			device_printf(dev, "Shape: %d\n",
329			    (resbuf[9] >> 2) & 0xf);
330			device_printf(dev, "80: %02x, %02x, %02x\n",
331			    resbuf[9], resbuf[10], resbuf[11]);
332			device_printf(dev, "96: %02x, %02x, %02x, %02x\n",
333			    resbuf[12], resbuf[13],
334			    resbuf[14], resbuf[15]);
335
336			if ((resbuf[0] & 0x7f) >= 2) {
337				device_printf(dev, "VOFF%d mm HOFF %dmm",
338				    resbuf[16] | (resbuf[17] << 8),
339				    resbuf[18] | (resbuf[19] << 8));
340			}
341		}
342	skip:
343		AcpiOsFree(buf.Pointer);
344	}
345	return (0);
346}
347
348static ACPI_STATUS
349acpi_uhub_find_rh(device_t dev, ACPI_HANDLE *ah)
350{
351	device_t grand;
352	ACPI_HANDLE gah;
353
354	*ah = NULL;
355	grand = device_get_parent(device_get_parent(dev));
356
357	if ((gah = acpi_get_handle(grand)) == NULL)
358		return (AE_ERROR);
359
360	return (AcpiWalkNamespace(ACPI_TYPE_DEVICE, gah, 1,
361	    acpi_uhub_find_rh_cb, NULL, dev, ah));
362}
363
364static ACPI_STATUS
365acpi_usb_hub_port_probe_cb(ACPI_HANDLE ah, UINT32 lv, void *ctx, void **rv)
366{
367	ACPI_DEVICE_INFO *devinfo;
368	device_t dev = ctx;
369	struct acpi_uhub_softc *sc = device_get_softc(dev);
370	UINT32 ret;
371
372	ret = AcpiGetObjectInfo(ah, &devinfo);
373	if (ACPI_SUCCESS(ret)) {
374		if ((devinfo->Valid & ACPI_VALID_ADR) &&
375		    (devinfo->Address > 0) &&
376		    (devinfo->Address <= (uint64_t)sc->nports)) {
377			char buf[] = "portXXX";
378			struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
379			struct sysctl_oid *oid;
380			struct sysctl_oid_list *tree;
381
382			snprintf(buf, sizeof(buf), "port%ju",
383			    (uintmax_t)devinfo->Address);
384			oid = SYSCTL_ADD_NODE(ctx,
385			    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
386			        OID_AUTO, buf, CTLFLAG_RD | CTLFLAG_MPSAFE,
387				NULL, "port nodes");
388			tree = SYSCTL_CHILDREN(oid);
389			sc->port[devinfo->Address - 1].handle = ah;
390			sc->port[devinfo->Address - 1].upc = 0xffffffff;
391			acpi_uhub_parse_upc(dev, devinfo->Address, ah, tree);
392			acpi_uhub_parse_pld(dev, devinfo->Address, ah, tree);
393			SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), tree,
394			    OID_AUTO, "info",
395			    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
396			    &sc->port[devinfo->Address - 1], 0,
397			    acpi_uhub_port_sysctl, "A", "Port information");
398		}
399		AcpiOsFree(devinfo);
400	}
401	return (AE_OK);
402}
403
404static ACPI_STATUS
405acpi_usb_hub_port_probe(device_t dev, ACPI_HANDLE ah)
406{
407	return (AcpiWalkNamespace(ACPI_TYPE_DEVICE,
408	    ah, 1,
409	    acpi_usb_hub_port_probe_cb,
410	    NULL, dev, NULL));
411}
412
413static int
414acpi_uhub_root_probe(device_t dev)
415{
416	ACPI_STATUS status;
417	ACPI_HANDLE ah;
418
419	if (acpi_disabled("usb"))
420		return (ENXIO);
421
422	status = acpi_uhub_find_rh(dev, &ah);
423	if (ACPI_SUCCESS(status) && ah != NULL &&
424	    uhub_probe(dev) <= 0) {
425		/* success prior than non-ACPI USB HUB */
426		return (BUS_PROBE_DEFAULT + 1);
427	}
428	return (ENXIO);
429}
430
431static int
432acpi_uhub_probe(device_t dev)
433{
434	ACPI_HANDLE ah;
435
436	if (acpi_disabled("usb"))
437		return (ENXIO);
438
439	ah = acpi_get_handle(dev);
440	if (ah == NULL)
441		return (ENXIO);
442
443	if (uhub_probe(dev) <= 0) {
444		/* success prior than non-ACPI USB HUB */
445		return (BUS_PROBE_DEFAULT + 1);
446	}
447	return (ENXIO);
448}
449static int
450acpi_uhub_attach_common(device_t dev)
451{
452	struct usb_hub *uh;
453	struct acpi_uhub_softc *sc = device_get_softc(dev);
454	ACPI_STATUS status;
455	int ret = ENXIO;
456
457	uh = sc->usc.sc_udev->hub;
458	sc->nports = uh->nports;
459	sc->port = malloc(sizeof(struct acpi_uhub_port) * uh->nports,
460	    M_USBDEV, M_WAITOK | M_ZERO);
461	status = acpi_usb_hub_port_probe(dev, sc->ah);
462
463	if (ACPI_SUCCESS(status)){
464		ret = 0;
465	}
466
467	return (ret);
468}
469
470static int
471acpi_uhub_detach(device_t dev)
472{
473	struct acpi_uhub_softc *sc = device_get_softc(dev);
474
475	free(sc->port, M_USBDEV);
476
477	return (uhub_detach(dev));
478}
479
480static int
481acpi_uhub_root_attach(device_t dev)
482{
483	int ret;
484	struct acpi_uhub_softc *sc = device_get_softc(dev);
485
486	if (ACPI_FAILURE(acpi_uhub_find_rh(dev, &sc->ah)) ||
487	    (sc->ah == NULL)) {
488		return (ENXIO);
489	}
490	if ((ret = uhub_attach(dev)) != 0) {
491		return (ret);
492	}
493
494	if ((ret = acpi_uhub_attach_common(dev)) != 0) {
495		acpi_uhub_detach(dev);
496	}
497	return ret;
498}
499
500static int
501acpi_uhub_attach(device_t dev)
502{
503	int ret;
504	struct acpi_uhub_softc *sc = device_get_softc(dev);
505
506	sc->ah = acpi_get_handle(dev);
507
508	if (sc->ah == NULL) {
509		return (ENXIO);
510	}
511	if ((ret = uhub_attach(dev)) != 0) {
512		return (ret);
513	}
514
515	if ((ret = acpi_uhub_attach_common(dev)) != 0) {
516		acpi_uhub_detach(dev);
517	}
518
519	return (ret);
520}
521
522static int
523acpi_uhub_read_ivar(device_t dev, device_t child, int idx, uintptr_t *res)
524{
525	struct hub_result hres;
526	struct acpi_uhub_softc *sc = device_get_softc(dev);
527	ACPI_HANDLE ah;
528
529	mtx_lock(&Giant);
530	uhub_find_iface_index(sc->usc.sc_udev->hub, child, &hres);
531	mtx_unlock(&Giant);
532
533	if ((idx == ACPI_IVAR_HANDLE) &&
534	    (hres.portno > 0) &&
535	    (hres.portno <= sc->nports) &&
536	    (ah = sc->port[hres.portno - 1].handle)) {
537		*res = (uintptr_t)ah;
538		return (0);
539	}
540	return (ENXIO);
541}
542
543static int
544acpi_uhub_child_location_string(device_t parent, device_t child,
545    char *buf, size_t buflen)
546{
547	ACPI_HANDLE ah;
548
549	uhub_child_location_string(parent, child, buf, buflen);
550
551	ah = acpi_get_handle(child);
552	if (ah != NULL) {
553		strlcat(buf, " handle=", buflen);
554		strlcat(buf, acpi_name(ah), buflen);
555	}
556	return (0);
557}
558
559static device_method_t acpi_uhub_methods[] = {
560	DEVMETHOD(device_probe, acpi_uhub_probe),
561	DEVMETHOD(device_attach, acpi_uhub_attach),
562	DEVMETHOD(device_detach, acpi_uhub_detach),
563	DEVMETHOD(bus_child_location_str, acpi_uhub_child_location_string),
564	DEVMETHOD(bus_read_ivar, acpi_uhub_read_ivar),
565	DEVMETHOD_END
566
567};
568
569static device_method_t acpi_uhub_root_methods[] = {
570	DEVMETHOD(device_probe, acpi_uhub_root_probe),
571	DEVMETHOD(device_attach, acpi_uhub_root_attach),
572	DEVMETHOD(device_detach, acpi_uhub_detach),
573	DEVMETHOD(bus_read_ivar, acpi_uhub_read_ivar),
574	DEVMETHOD(bus_child_location_str, acpi_uhub_child_location_string),
575	DEVMETHOD_END
576};
577
578static devclass_t uhub_devclass;
579extern driver_t uhub_driver;
580static kobj_class_t uhub_baseclasses[] = {&uhub_driver, NULL};
581
582static driver_t acpi_uhub_driver = {
583	.name = "uhub",
584	.methods = acpi_uhub_methods,
585	.size = sizeof(struct acpi_uhub_softc),
586	.baseclasses = uhub_baseclasses,
587};
588
589static driver_t acpi_uhub_root_driver = {
590	.name = "uhub",
591	.methods = acpi_uhub_root_methods,
592	.size = sizeof(struct acpi_uhub_softc),
593	.baseclasses = uhub_baseclasses,
594};
595
596DRIVER_MODULE(uacpi, uhub, acpi_uhub_driver, uhub_devclass, 0, 0);
597DRIVER_MODULE(uacpi, usbus, acpi_uhub_root_driver, uhub_devclass, 0, 0);
598
599MODULE_DEPEND(uacpi, acpi, 1, 1, 1);
600MODULE_DEPEND(uacpi, usb, 1, 1, 1);
601
602MODULE_VERSION(uacpi, 1);
603