1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) Andriy Gapon
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions, and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
19 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 */
28
29 /*
30 * Hardware information links:
31 * - CP2112 Datasheet
32 * https://www.silabs.com/documents/public/data-sheets/cp2112-datasheet.pdf
33 * - AN495: CP2112 Interface Specification
34 * https://www.silabs.com/documents/public/application-notes/an495-cp2112-interface-specification.pdf
35 * - CP2112 Errata
36 * https://www.silabs.com/documents/public/errata/cp2112-errata.pdf
37 */
38
39 #include <sys/cdefs.h>
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/condvar.h>
43 #include <sys/bus.h>
44 #include <sys/gpio.h>
45 #include <sys/kernel.h>
46 #include <sys/lock.h>
47 #include <sys/module.h>
48 #include <sys/mutex.h>
49 #include <sys/sdt.h>
50 #include <sys/sx.h>
51
52 #include <dev/gpio/gpiobusvar.h>
53
54 #include <dev/iicbus/iiconf.h>
55 #include <dev/iicbus/iicbus.h>
56 #include "iicbus_if.h"
57
58 #include <dev/usb/usb.h>
59 #include <dev/usb/usbdi.h>
60 #include <dev/usb/usbdi_util.h>
61 #include <dev/usb/usbhid.h>
62 #include "usbdevs.h"
63
64 #define USB_DEBUG_VAR usb_debug
65 #include <dev/usb/usb_debug.h>
66
67 #define SIZEOF_FIELD(_s, _f) sizeof(((struct _s *)NULL)->_f)
68
69 #define CP2112GPIO_LOCK(sc) sx_xlock(&sc->gpio_lock)
70 #define CP2112GPIO_UNLOCK(sc) sx_xunlock(&sc->gpio_lock)
71 #define CP2112GPIO_LOCKED(sc) sx_assert(&sc->gpio_lock, SX_XLOCKED)
72
73 #define CP2112_PART_NUM 0x0c
74 #define CP2112_GPIO_COUNT 8
75 #define CP2112_REPORT_SIZE 64
76
77 #define CP2112_REQ_RESET 0x1
78 #define CP2112_REQ_GPIO_CFG 0x2
79 #define CP2112_REQ_GPIO_GET 0x3
80 #define CP2112_REQ_GPIO_SET 0x4
81 #define CP2112_REQ_VERSION 0x5
82 #define CP2112_REQ_SMB_CFG 0x6
83
84 #define CP2112_REQ_SMB_READ 0x10
85 #define CP2112_REQ_SMB_WRITE_READ 0x11
86 #define CP2112_REQ_SMB_READ_FORCE_SEND 0x12
87 #define CP2112_REQ_SMB_READ_RESPONSE 0x13
88 #define CP2112_REQ_SMB_WRITE 0x14
89 #define CP2112_REQ_SMB_XFER_STATUS_REQ 0x15
90 #define CP2112_REQ_SMB_XFER_STATUS_RESP 0x16
91 #define CP2112_REQ_SMB_CANCEL 0x17
92
93 #define CP2112_REQ_LOCK 0x20
94 #define CP2112_REQ_USB_CFG 0x21
95
96 #define CP2112_IIC_MAX_READ_LEN 512
97 #define CP2112_IIC_REPSTART_VER 2 /* Erratum CP2112_E10. */
98
99 #define CP2112_GPIO_SPEC_CLK7 1 /* Pin 7 is clock output. */
100 #define CP2112_GPIO_SPEC_TX0 2 /* Pin 0 pulses on USB TX. */
101 #define CP2112_GPIO_SPEC_RX1 4 /* Pin 1 pulses on USB RX. */
102
103 #define CP2112_IIC_STATUS0_IDLE 0
104 #define CP2112_IIC_STATUS0_BUSY 1
105 #define CP2112_IIC_STATUS0_CMP 2
106 #define CP2112_IIC_STATUS0_ERROR 3
107
108 #define CP2112_IIC_STATUS1_TIMEOUT_NACK 0
109 #define CP2112_IIC_STATUS1_TIMEOUT_BUS 1
110 #define CP2112_IIC_STATUS1_ARB_LOST 2
111
112 /* CP2112_REQ_VERSION */
113 struct version_request {
114 uint8_t id;
115 uint8_t part_num;
116 uint8_t version;
117 } __packed;
118
119 /* CP2112_REQ_GPIO_GET */
120 struct gpio_get_req {
121 uint8_t id;
122 uint8_t state;
123 } __packed;
124
125 /* CP2112_REQ_GPIO_SET */
126 struct gpio_set_req {
127 uint8_t id;
128 uint8_t state;
129 uint8_t mask;
130 } __packed;
131
132 /* CP2112_REQ_GPIO_CFG */
133 struct gpio_config_req {
134 uint8_t id;
135 uint8_t output;
136 uint8_t pushpull;
137 uint8_t special;
138 uint8_t divider;
139 } __packed;
140
141 /* CP2112_REQ_SMB_XFER_STATUS_REQ */
142 struct i2c_xfer_status_req {
143 uint8_t id;
144 uint8_t request;
145 } __packed;
146
147 /* CP2112_REQ_SMB_XFER_STATUS_RESP */
148 struct i2c_xfer_status_resp {
149 uint8_t id;
150 uint8_t status0;
151 uint8_t status1;
152 uint16_t status2;
153 uint16_t status3;
154 } __packed;
155
156 /* CP2112_REQ_SMB_READ_FORCE_SEND */
157 struct i2c_data_read_force_send_req {
158 uint8_t id;
159 uint16_t len;
160 } __packed;
161
162 /* CP2112_REQ_SMB_READ_RESPONSE */
163 struct i2c_data_read_resp {
164 uint8_t id;
165 uint8_t status;
166 uint8_t len;
167 uint8_t data[61];
168 } __packed;
169
170 /* CP2112_REQ_SMB_READ */
171 struct i2c_write_read_req {
172 uint8_t id;
173 uint8_t slave;
174 uint16_t rlen;
175 uint8_t wlen;
176 uint8_t wdata[16];
177 } __packed;
178
179 /* CP2112_REQ_SMB_WRITE */
180 struct i2c_read_req {
181 uint8_t id;
182 uint8_t slave;
183 uint16_t len;
184 } __packed;
185
186 /* CP2112_REQ_SMB_WRITE_READ */
187 struct i2c_write_req {
188 uint8_t id;
189 uint8_t slave;
190 uint8_t len;
191 uint8_t data[61];
192 } __packed;
193
194 /* CP2112_REQ_SMB_CFG */
195 struct i2c_cfg_req {
196 uint8_t id;
197 uint32_t speed; /* Hz */
198 uint8_t slave_addr; /* ACK only */
199 uint8_t auto_send_read; /* boolean */
200 uint16_t write_timeout; /* 0-1000 ms, 0 ~ no timeout */
201 uint16_t read_timeout; /* 0-1000 ms, 0 ~ no timeout */
202 uint8_t scl_low_timeout;/* boolean */
203 uint16_t retry_count; /* 1-1000, 0 ~ forever */
204 } __packed;
205
206 enum cp2112_out_mode {
207 OUT_OD,
208 OUT_PP,
209 OUT_KEEP
210 };
211
212 enum {
213 CP2112_INTR_OUT = 0,
214 CP2112_INTR_IN,
215 CP2112_N_TRANSFER,
216 };
217
218 struct cp2112_softc {
219 device_t sc_gpio_dev;
220 device_t sc_iic_dev;
221 struct usb_device *sc_udev;
222 uint8_t sc_iface_index;
223 uint8_t sc_version;
224 };
225
226 struct cp2112gpio_softc {
227 struct sx gpio_lock;
228 device_t busdev;
229 int gpio_caps;
230 struct gpio_pin pins[CP2112_GPIO_COUNT];
231 };
232
233 struct cp2112iic_softc {
234 device_t dev;
235 device_t iicbus_dev;
236 struct usb_xfer *xfers[CP2112_N_TRANSFER];
237 u_char own_addr;
238 struct {
239 struct mtx lock;
240 struct cv cv;
241 struct {
242 uint8_t *data;
243 int len;
244 int done;
245 int error;
246 } in;
247 struct {
248 const uint8_t *data;
249 int len;
250 int done;
251 int error;
252 } out;
253 } io;
254 };
255
256 static int cp2112_detach(device_t dev);
257 static int cp2112gpio_detach(device_t dev);
258 static int cp2112iic_detach(device_t dev);
259
260 static const STRUCT_USB_HOST_ID cp2112_devs[] = {
261 { USB_VP(USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CP2112) },
262 { USB_VP(0x1009, USB_PRODUCT_SILABS_CP2112) }, /* XXX */
263 };
264
265 static int
cp2112_get_report(device_t dev,uint8_t id,void * data,uint16_t len)266 cp2112_get_report(device_t dev, uint8_t id, void *data, uint16_t len)
267 {
268 struct cp2112_softc *sc;
269 int err;
270
271 sc = device_get_softc(dev);
272 err = usbd_req_get_report(sc->sc_udev, NULL, data,
273 len, sc->sc_iface_index, UHID_FEATURE_REPORT, id);
274 return (err);
275 }
276
277 static int
cp2112_set_report(device_t dev,uint8_t id,void * data,uint16_t len)278 cp2112_set_report(device_t dev, uint8_t id, void *data, uint16_t len)
279 {
280 struct cp2112_softc *sc;
281 int err;
282
283 sc = device_get_softc(dev);
284 *(uint8_t *)data = id;
285 err = usbd_req_set_report(sc->sc_udev, NULL, data,
286 len, sc->sc_iface_index, UHID_FEATURE_REPORT, id);
287 return (err);
288 }
289
290 static int
cp2112_probe(device_t dev)291 cp2112_probe(device_t dev)
292 {
293 struct usb_attach_arg *uaa;
294
295 uaa = device_get_ivars(dev);
296 if (uaa->usb_mode != USB_MODE_HOST)
297 return (ENXIO);
298 if (uaa->info.bInterfaceClass != UICLASS_HID)
299 return (ENXIO);
300
301 if (usbd_lookup_id_by_uaa(cp2112_devs, sizeof(cp2112_devs), uaa) == 0)
302 return (BUS_PROBE_DEFAULT);
303 return (ENXIO);
304 }
305
306 static int
cp2112_attach(device_t dev)307 cp2112_attach(device_t dev)
308 {
309 struct version_request vdata;
310 struct usb_attach_arg *uaa;
311 struct cp2112_softc *sc;
312 int err;
313
314 uaa = device_get_ivars(dev);
315 sc = device_get_softc(dev);
316
317 device_set_usb_desc(dev);
318
319 sc->sc_udev = uaa->device;
320 sc->sc_iface_index = uaa->info.bIfaceIndex;
321
322 err = cp2112_get_report(dev, CP2112_REQ_VERSION, &vdata, sizeof(vdata));
323 if (err != 0)
324 goto detach;
325 device_printf(dev, "part number 0x%02x, version 0x%02x\n",
326 vdata.part_num, vdata.version);
327 if (vdata.part_num != CP2112_PART_NUM) {
328 device_printf(dev, "unsupported part number\n");
329 goto detach;
330 }
331 sc->sc_version = vdata.version;
332 sc->sc_gpio_dev = device_add_child(dev, "gpio", -1);
333 if (sc->sc_gpio_dev != NULL) {
334 err = device_probe_and_attach(sc->sc_gpio_dev);
335 if (err != 0) {
336 device_printf(dev, "failed to attach gpio child\n");
337 }
338 } else {
339 device_printf(dev, "failed to create gpio child\n");
340 }
341
342 sc->sc_iic_dev = device_add_child(dev, "iichb", -1);
343 if (sc->sc_iic_dev != NULL) {
344 err = device_probe_and_attach(sc->sc_iic_dev);
345 if (err != 0) {
346 device_printf(dev, "failed to attach iic child\n");
347 }
348 } else {
349 device_printf(dev, "failed to create iic child\n");
350 }
351
352 return (0);
353
354 detach:
355 cp2112_detach(dev);
356 return (ENXIO);
357 }
358
359 static int
cp2112_detach(device_t dev)360 cp2112_detach(device_t dev)
361 {
362 int err;
363
364 err = bus_generic_detach(dev);
365 if (err != 0)
366 return (err);
367 device_delete_children(dev);
368 return (0);
369 }
370
371 static int
cp2112_gpio_read_pin(device_t dev,uint32_t pin_num,bool * on)372 cp2112_gpio_read_pin(device_t dev, uint32_t pin_num, bool *on)
373 {
374 struct gpio_get_req data;
375 struct cp2112gpio_softc *sc __diagused;
376 int err;
377
378 sc = device_get_softc(dev);
379 CP2112GPIO_LOCKED(sc);
380
381 err = cp2112_get_report(device_get_parent(dev),
382 CP2112_REQ_GPIO_GET, &data, sizeof(data));
383 if (err != 0)
384 return (err);
385 *on = (data.state & ((uint8_t)1 << pin_num)) != 0;
386 return (0);
387
388 }
389
390 static int
cp2112_gpio_write_pin(device_t dev,uint32_t pin_num,bool on)391 cp2112_gpio_write_pin(device_t dev, uint32_t pin_num, bool on)
392 {
393 struct gpio_set_req data;
394 struct cp2112gpio_softc *sc __diagused;
395 int err;
396 bool actual;
397
398 sc = device_get_softc(dev);
399 CP2112GPIO_LOCKED(sc);
400
401 data.state = (uint8_t)on << pin_num;
402 data.mask = (uint8_t)1 << pin_num;
403 err = cp2112_set_report(device_get_parent(dev),
404 CP2112_REQ_GPIO_SET, &data, sizeof(data));
405 if (err != 0)
406 return (err);
407 err = cp2112_gpio_read_pin(dev, pin_num, &actual);
408 if (err != 0)
409 return (err);
410 if (actual != on)
411 return (EIO);
412 return (0);
413 }
414
415 static int
cp2112_gpio_configure_write_pin(device_t dev,uint32_t pin_num,bool output,enum cp2112_out_mode * mode)416 cp2112_gpio_configure_write_pin(device_t dev, uint32_t pin_num,
417 bool output, enum cp2112_out_mode *mode)
418 {
419 struct gpio_config_req data;
420 struct cp2112gpio_softc *sc __diagused;
421 int err;
422 uint8_t mask;
423
424 sc = device_get_softc(dev);
425 CP2112GPIO_LOCKED(sc);
426
427 err = cp2112_get_report(device_get_parent(dev),
428 CP2112_REQ_GPIO_CFG, &data, sizeof(data));
429 if (err != 0)
430 return (err);
431
432 mask = (uint8_t)1 << pin_num;
433 if (output) {
434 data.output |= mask;
435 switch (*mode) {
436 case OUT_PP:
437 data.pushpull |= mask;
438 break;
439 case OUT_OD:
440 data.pushpull &= ~mask;
441 break;
442 default:
443 break;
444 }
445 } else {
446 data.output &= ~mask;
447 }
448
449 err = cp2112_set_report(device_get_parent(dev),
450 CP2112_REQ_GPIO_CFG, &data, sizeof(data));
451 if (err != 0)
452 return (err);
453
454 /* Read back and verify. */
455 err = cp2112_get_report(device_get_parent(dev),
456 CP2112_REQ_GPIO_CFG, &data, sizeof(data));
457 if (err != 0)
458 return (err);
459
460 if (((data.output & mask) != 0) != output)
461 return (EIO);
462 if (output) {
463 switch (*mode) {
464 case OUT_PP:
465 if ((data.pushpull & mask) == 0)
466 return (EIO);
467 break;
468 case OUT_OD:
469 if ((data.pushpull & mask) != 0)
470 return (EIO);
471 break;
472 default:
473 *mode = (data.pushpull & mask) != 0 ?
474 OUT_PP : OUT_OD;
475 break;
476 }
477 }
478 return (0);
479 }
480
481 static device_t
cp2112_gpio_get_bus(device_t dev)482 cp2112_gpio_get_bus(device_t dev)
483 {
484 struct cp2112gpio_softc *sc;
485
486 sc = device_get_softc(dev);
487 return (sc->busdev);
488 }
489
490 static int
cp2112_gpio_pin_max(device_t dev,int * maxpin)491 cp2112_gpio_pin_max(device_t dev, int *maxpin)
492 {
493
494 *maxpin = CP2112_GPIO_COUNT - 1;
495 return (0);
496 }
497
498 static int
cp2112_gpio_pin_set(device_t dev,uint32_t pin_num,uint32_t pin_value)499 cp2112_gpio_pin_set(device_t dev, uint32_t pin_num, uint32_t pin_value)
500 {
501 struct cp2112gpio_softc *sc;
502 int err;
503
504 if (pin_num >= CP2112_GPIO_COUNT)
505 return (EINVAL);
506
507 sc = device_get_softc(dev);
508 CP2112GPIO_LOCK(sc);
509 err = cp2112_gpio_write_pin(dev, pin_num, pin_value != 0);
510 CP2112GPIO_UNLOCK(sc);
511
512 return (err);
513 }
514
515 static int
cp2112_gpio_pin_get(device_t dev,uint32_t pin_num,uint32_t * pin_value)516 cp2112_gpio_pin_get(device_t dev, uint32_t pin_num, uint32_t *pin_value)
517 {
518 struct cp2112gpio_softc *sc;
519 int err;
520 bool on;
521
522 if (pin_num >= CP2112_GPIO_COUNT)
523 return (EINVAL);
524
525 sc = device_get_softc(dev);
526 CP2112GPIO_LOCK(sc);
527 err = cp2112_gpio_read_pin(dev, pin_num, &on);
528 CP2112GPIO_UNLOCK(sc);
529
530 if (err == 0)
531 *pin_value = on;
532 return (err);
533 }
534
535 static int
cp2112_gpio_pin_toggle(device_t dev,uint32_t pin_num)536 cp2112_gpio_pin_toggle(device_t dev, uint32_t pin_num)
537 {
538 struct cp2112gpio_softc *sc;
539 int err;
540 bool on;
541
542 if (pin_num >= CP2112_GPIO_COUNT)
543 return (EINVAL);
544
545 sc = device_get_softc(dev);
546 CP2112GPIO_LOCK(sc);
547 err = cp2112_gpio_read_pin(dev, pin_num, &on);
548 if (err == 0)
549 err = cp2112_gpio_write_pin(dev, pin_num, !on);
550 CP2112GPIO_UNLOCK(sc);
551
552 return (err);
553 }
554
555 static int
cp2112_gpio_pin_getcaps(device_t dev,uint32_t pin_num,uint32_t * caps)556 cp2112_gpio_pin_getcaps(device_t dev, uint32_t pin_num, uint32_t *caps)
557 {
558 struct cp2112gpio_softc *sc;
559
560 if (pin_num >= CP2112_GPIO_COUNT)
561 return (EINVAL);
562
563 sc = device_get_softc(dev);
564 CP2112GPIO_LOCK(sc);
565 *caps = sc->gpio_caps;
566 CP2112GPIO_UNLOCK(sc);
567
568 return (0);
569 }
570
571 static int
cp2112_gpio_pin_getflags(device_t dev,uint32_t pin_num,uint32_t * flags)572 cp2112_gpio_pin_getflags(device_t dev, uint32_t pin_num, uint32_t *flags)
573 {
574 struct cp2112gpio_softc *sc;
575
576 if (pin_num >= CP2112_GPIO_COUNT)
577 return (EINVAL);
578
579 sc = device_get_softc(dev);
580 CP2112GPIO_LOCK(sc);
581 *flags = sc->pins[pin_num].gp_flags;
582 CP2112GPIO_UNLOCK(sc);
583
584 return (0);
585 }
586
587 static int
cp2112_gpio_pin_getname(device_t dev,uint32_t pin_num,char * name)588 cp2112_gpio_pin_getname(device_t dev, uint32_t pin_num, char *name)
589 {
590 struct cp2112gpio_softc *sc;
591
592 if (pin_num >= CP2112_GPIO_COUNT)
593 return (EINVAL);
594
595 sc = device_get_softc(dev);
596 CP2112GPIO_LOCK(sc);
597 memcpy(name, sc->pins[pin_num].gp_name, GPIOMAXNAME);
598 CP2112GPIO_UNLOCK(sc);
599
600 return (0);
601 }
602
603 static int
cp2112_gpio_pin_setflags(device_t dev,uint32_t pin_num,uint32_t flags)604 cp2112_gpio_pin_setflags(device_t dev, uint32_t pin_num, uint32_t flags)
605 {
606 struct cp2112gpio_softc *sc;
607 struct gpio_pin *pin;
608 enum cp2112_out_mode out_mode;
609 int err;
610
611 if (pin_num >= CP2112_GPIO_COUNT)
612 return (EINVAL);
613
614 sc = device_get_softc(dev);
615 if ((flags & sc->gpio_caps) != flags)
616 return (EINVAL);
617
618 if ((flags & (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT)) == 0)
619 return (EINVAL);
620 if ((flags & (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT)) ==
621 (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT)) {
622 return (EINVAL);
623 }
624 if ((flags & GPIO_PIN_INPUT) != 0) {
625 if ((flags & (GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL)) != 0)
626 return (EINVAL);
627 } else {
628 if ((flags & (GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL)) ==
629 (GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL))
630 return (EINVAL);
631 }
632
633 /*
634 * If neither push-pull or open-drain is explicitly requested, then
635 * preserve the current state.
636 */
637 out_mode = OUT_KEEP;
638 if ((flags & GPIO_PIN_OUTPUT) != 0) {
639 if ((flags & GPIO_PIN_OPENDRAIN) != 0)
640 out_mode = OUT_OD;
641 if ((flags & GPIO_PIN_PUSHPULL) != 0)
642 out_mode = OUT_PP;
643 }
644
645 CP2112GPIO_LOCK(sc);
646 pin = &sc->pins[pin_num];
647 err = cp2112_gpio_configure_write_pin(dev, pin_num,
648 (flags & GPIO_PIN_OUTPUT) != 0, &out_mode);
649 if (err == 0) {
650 /*
651 * If neither open-drain or push-pull was requested, then see
652 * what hardware actually had. Otherwise, it has been
653 * reconfigured as requested.
654 */
655 if ((flags & GPIO_PIN_OUTPUT) != 0 &&
656 (flags & (GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL)) == 0) {
657 KASSERT(out_mode != OUT_KEEP,
658 ("impossible current output mode"));
659 if (out_mode == OUT_OD)
660 flags |= GPIO_PIN_OPENDRAIN;
661 else
662 flags |= GPIO_PIN_PUSHPULL;
663 }
664 pin->gp_flags = flags;
665 }
666 CP2112GPIO_UNLOCK(sc);
667
668 return (err);
669 }
670
671 static int
cp2112gpio_probe(device_t dev)672 cp2112gpio_probe(device_t dev)
673 {
674 device_set_desc(dev, "CP2112 GPIO interface");
675 return (BUS_PROBE_SPECIFIC);
676 }
677
678 static int
cp2112gpio_attach(device_t dev)679 cp2112gpio_attach(device_t dev)
680 {
681 struct gpio_config_req data;
682 struct cp2112gpio_softc *sc;
683 device_t cp2112;
684 int err;
685 int i;
686 uint8_t mask;
687
688 cp2112 = device_get_parent(dev);
689 sc = device_get_softc(dev);
690 sx_init(&sc->gpio_lock, "cp2112 lock");
691
692 sc->gpio_caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_OPENDRAIN |
693 GPIO_PIN_PUSHPULL;
694
695 err = cp2112_get_report(cp2112, CP2112_REQ_GPIO_CFG,
696 &data, sizeof(data));
697 if (err != 0)
698 goto detach;
699
700 for (i = 0; i < CP2112_GPIO_COUNT; i++) {
701 struct gpio_pin *pin;
702
703 mask = (uint8_t)1 << i;
704 pin = &sc->pins[i];
705 pin->gp_flags = 0;
706
707 snprintf(pin->gp_name, GPIOMAXNAME, "GPIO%u", i);
708 pin->gp_name[GPIOMAXNAME - 1] = '\0';
709
710 if ((i == 0 && (data.special & CP2112_GPIO_SPEC_TX0) != 0) ||
711 (i == 1 && (data.special & CP2112_GPIO_SPEC_RX1) != 0) ||
712 (i == 7 && (data.special & CP2112_GPIO_SPEC_CLK7) != 0)) {
713 /* Special mode means that a pin is not for GPIO. */
714 } else if ((data.output & mask) != 0) {
715 pin->gp_flags |= GPIO_PIN_OUTPUT;
716 if ((data.pushpull & mask) != 0)
717 pin->gp_flags |= GPIO_PIN_PUSHPULL;
718 else
719 pin->gp_flags |= GPIO_PIN_OPENDRAIN;
720 } else {
721 pin->gp_flags |= GPIO_PIN_INPUT;
722 }
723 }
724
725 sc->busdev = gpiobus_attach_bus(dev);
726 if (sc->busdev == NULL) {
727 device_printf(dev, "gpiobus_attach_bus failed\n");
728 goto detach;
729 }
730 return (0);
731
732 detach:
733 cp2112gpio_detach(dev);
734 return (ENXIO);
735 }
736
737 static int
cp2112gpio_detach(device_t dev)738 cp2112gpio_detach(device_t dev)
739 {
740 struct cp2112gpio_softc *sc;
741
742 sc = device_get_softc(dev);
743 if (sc->busdev != NULL)
744 gpiobus_detach_bus(dev);
745 sx_destroy(&sc->gpio_lock);
746 return (0);
747 }
748
749 static void
cp2112iic_intr_write_callback(struct usb_xfer * xfer,usb_error_t error)750 cp2112iic_intr_write_callback(struct usb_xfer *xfer, usb_error_t error)
751 {
752 struct cp2112iic_softc *sc;
753 struct usb_page_cache *pc;
754
755 sc = usbd_xfer_softc(xfer);
756
757 mtx_assert(&sc->io.lock, MA_OWNED);
758
759 switch (USB_GET_STATE(xfer)) {
760 case USB_ST_SETUP:
761 pc = usbd_xfer_get_frame(xfer, 0);
762 usbd_copy_in(pc, 0, sc->io.out.data, sc->io.out.len);
763 usbd_xfer_set_frame_len(xfer, 0, sc->io.out.len);
764 usbd_xfer_set_frames(xfer, 1);
765 usbd_transfer_submit(xfer);
766 break;
767 case USB_ST_TRANSFERRED:
768 sc->io.out.error = 0;
769 sc->io.out.done = 1;
770 cv_signal(&sc->io.cv);
771 break;
772 default: /* Error */
773 device_printf(sc->dev, "write intr state %d error %d\n",
774 USB_GET_STATE(xfer), error);
775 sc->io.out.error = IIC_EBUSERR;
776 cv_signal(&sc->io.cv);
777 if (error != USB_ERR_CANCELLED) {
778 /* try to clear stall first */
779 usbd_xfer_set_stall(xfer);
780 }
781 break;
782 }
783 }
784
785 static void
cp2112iic_intr_read_callback(struct usb_xfer * xfer,usb_error_t error)786 cp2112iic_intr_read_callback(struct usb_xfer *xfer, usb_error_t error)
787 {
788 struct cp2112iic_softc *sc = usbd_xfer_softc(xfer);
789 struct usb_page_cache *pc;
790 int act_len, len;
791
792 mtx_assert(&sc->io.lock, MA_OWNED);
793 usbd_xfer_status(xfer, &act_len, NULL, NULL, NULL);
794
795 switch (USB_GET_STATE(xfer)) {
796 case USB_ST_TRANSFERRED:
797 if (sc->io.in.done) {
798 device_printf(sc->dev,
799 "interrupt while previous is pending, ignored\n");
800 } else if (sc->io.in.len == 0) {
801 uint8_t buf[8];
802
803 /*
804 * There is a spurious Transfer Status Response and
805 * zero-length Read Response during hardware
806 * configuration. Possibly they carry some information
807 * about the initial bus state.
808 */
809 if (device_is_attached(sc->dev)) {
810 device_printf(sc->dev,
811 "unsolicited interrupt, ignored\n");
812 if (bootverbose) {
813 pc = usbd_xfer_get_frame(xfer, 0);
814 len = MIN(sizeof(buf), act_len);
815 usbd_copy_out(pc, 0, buf, len);
816 device_printf(sc->dev, "data: %*D\n",
817 len, buf, " ");
818 }
819 } else {
820 pc = usbd_xfer_get_frame(xfer, 0);
821 len = MIN(sizeof(buf), act_len);
822 usbd_copy_out(pc, 0, buf, len);
823 if (buf[0] == CP2112_REQ_SMB_XFER_STATUS_RESP) {
824 device_printf(sc->dev,
825 "initial bus status0 = 0x%02x, "
826 "status1 = 0x%02x\n",
827 buf[1], buf[2]);
828 }
829 }
830 } else if (act_len == CP2112_REPORT_SIZE) {
831 pc = usbd_xfer_get_frame(xfer, 0);
832 usbd_copy_out(pc, 0, sc->io.in.data, sc->io.in.len);
833 sc->io.in.error = 0;
834 sc->io.in.done = 1;
835 } else {
836 device_printf(sc->dev,
837 "unexpected input report length %u\n", act_len);
838 sc->io.in.error = IIC_EBUSERR;
839 sc->io.in.done = 1;
840 }
841 cv_signal(&sc->io.cv);
842 case USB_ST_SETUP:
843 tr_setup:
844 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
845 usbd_transfer_submit(xfer);
846 break;
847
848 default: /* Error */
849 device_printf(sc->dev, "read intr state %d error %d\n",
850 USB_GET_STATE(xfer), error);
851
852 sc->io.in.error = IIC_EBUSERR;
853 sc->io.in.done = 1;
854 cv_signal(&sc->io.cv);
855 if (error != USB_ERR_CANCELLED) {
856 /* try to clear stall first */
857 usbd_xfer_set_stall(xfer);
858 goto tr_setup;
859 }
860 break;
861 }
862 }
863
864 static const struct usb_config cp2112iic_config[CP2112_N_TRANSFER] = {
865 [CP2112_INTR_OUT] = {
866 .type = UE_INTERRUPT,
867 .endpoint = UE_ADDR_ANY,
868 .direction = UE_DIR_OUT,
869 .flags = { .pipe_bof = 1, .no_pipe_ok = 1, },
870 .bufsize = 0, /* use wMaxPacketSize */
871 .callback = &cp2112iic_intr_write_callback,
872 },
873 [CP2112_INTR_IN] = {
874 .type = UE_INTERRUPT,
875 .endpoint = UE_ADDR_ANY,
876 .direction = UE_DIR_IN,
877 .flags = { .pipe_bof = 1, .short_xfer_ok = 1, },
878 .bufsize = 0, /* use wMaxPacketSize */
879 .callback = &cp2112iic_intr_read_callback,
880 },
881 };
882
883 static int
cp2112iic_send_req(struct cp2112iic_softc * sc,const void * data,uint16_t len)884 cp2112iic_send_req(struct cp2112iic_softc *sc, const void *data,
885 uint16_t len)
886 {
887 int err;
888
889 mtx_assert(&sc->io.lock, MA_OWNED);
890 KASSERT(sc->io.out.done == 0, ("%s: conflicting request", __func__));
891
892 sc->io.out.data = data;
893 sc->io.out.len = len;
894
895 DTRACE_PROBE1(send__req, uint8_t, *(const uint8_t *)data);
896
897 usbd_transfer_start(sc->xfers[CP2112_INTR_OUT]);
898
899 while (!sc->io.out.done)
900 cv_wait(&sc->io.cv, &sc->io.lock);
901
902 usbd_transfer_stop(sc->xfers[CP2112_INTR_OUT]);
903
904 sc->io.out.done = 0;
905 sc->io.out.data = NULL;
906 sc->io.out.len = 0;
907 err = sc->io.out.error;
908 if (err != 0) {
909 device_printf(sc->dev, "output report 0x%02x failed: %d\n",
910 *(const uint8_t*)data, err);
911 }
912 return (err);
913 }
914
915 static int
cp2112iic_req_resp(struct cp2112iic_softc * sc,const void * req_data,uint16_t req_len,void * resp_data,uint16_t resp_len)916 cp2112iic_req_resp(struct cp2112iic_softc *sc, const void *req_data,
917 uint16_t req_len, void *resp_data, uint16_t resp_len)
918 {
919 int err;
920
921 mtx_assert(&sc->io.lock, MA_OWNED);
922
923 /*
924 * Prepare to receive a response interrupt even before the
925 * request transfer is confirmed (USB_ST_TRANSFERED).
926 */
927 KASSERT(sc->io.in.done == 0, ("%s: conflicting request", __func__));
928 sc->io.in.len = resp_len;
929 sc->io.in.data = resp_data;
930
931 err = cp2112iic_send_req(sc, req_data, req_len);
932 if (err != 0) {
933 sc->io.in.len = 0;
934 sc->io.in.data = NULL;
935 return (err);
936 }
937
938 while (!sc->io.in.done)
939 cv_wait(&sc->io.cv, &sc->io.lock);
940
941 err = sc->io.in.error;
942 sc->io.in.done = 0;
943 sc->io.in.error = 0;
944 sc->io.in.len = 0;
945 sc->io.in.data = NULL;
946 return (err);
947 }
948
949 static int
cp2112iic_check_req_status(struct cp2112iic_softc * sc)950 cp2112iic_check_req_status(struct cp2112iic_softc *sc)
951 {
952 struct i2c_xfer_status_req xfer_status_req;
953 struct i2c_xfer_status_resp xfer_status_resp;
954 int err;
955
956 mtx_assert(&sc->io.lock, MA_OWNED);
957
958 do {
959 xfer_status_req.id = CP2112_REQ_SMB_XFER_STATUS_REQ;
960 xfer_status_req.request = 1;
961 err = cp2112iic_req_resp(sc,
962 &xfer_status_req, sizeof(xfer_status_req),
963 &xfer_status_resp, sizeof(xfer_status_resp));
964
965 if (xfer_status_resp.id != CP2112_REQ_SMB_XFER_STATUS_RESP) {
966 device_printf(sc->dev,
967 "unexpected response 0x%02x to status request\n",
968 xfer_status_resp.id);
969 err = IIC_EBUSERR;
970 goto out;
971 }
972
973 DTRACE_PROBE4(xfer__status, uint8_t, xfer_status_resp.status0,
974 uint8_t, xfer_status_resp.status1,
975 uint16_t, be16toh(xfer_status_resp.status2),
976 uint16_t, be16toh(xfer_status_resp.status3));
977
978 switch (xfer_status_resp.status0) {
979 case CP2112_IIC_STATUS0_IDLE:
980 err = IIC_ESTATUS;
981 break;
982 case CP2112_IIC_STATUS0_BUSY:
983 err = ERESTART; /* non-I2C, special handling */
984 break;
985 case CP2112_IIC_STATUS0_CMP:
986 err = IIC_NOERR;
987 break;
988 case CP2112_IIC_STATUS0_ERROR:
989 switch (xfer_status_resp.status1) {
990 case CP2112_IIC_STATUS1_TIMEOUT_NACK:
991 err = IIC_ENOACK;
992 break;
993 case CP2112_IIC_STATUS1_TIMEOUT_BUS:
994 err = IIC_ETIMEOUT;
995 break;
996 case CP2112_IIC_STATUS1_ARB_LOST:
997 err = IIC_EBUSBSY;
998 break;
999 default:
1000 device_printf(sc->dev,
1001 "i2c error, status = 0x%02x\n",
1002 xfer_status_resp.status1);
1003 err = IIC_ESTATUS;
1004 break;
1005 }
1006 break;
1007 default:
1008 device_printf(sc->dev,
1009 "unknown i2c xfer status0 0x%02x\n",
1010 xfer_status_resp.status0);
1011 err = IIC_EBUSERR;
1012 break;
1013 }
1014
1015 } while (err == ERESTART);
1016 out:
1017 return (err);
1018 }
1019
1020 static int
cp2112iic_read_data(struct cp2112iic_softc * sc,void * data,uint16_t in_len,uint16_t * out_len)1021 cp2112iic_read_data(struct cp2112iic_softc *sc, void *data, uint16_t in_len,
1022 uint16_t *out_len)
1023 {
1024 struct i2c_data_read_force_send_req data_read_force_send;
1025 struct i2c_data_read_resp data_read_resp;
1026 int err;
1027
1028 mtx_assert(&sc->io.lock, MA_OWNED);
1029
1030 /*
1031 * Prepare to receive a response interrupt even before the request
1032 * transfer is confirmed (USB_ST_TRANSFERED).
1033 */
1034
1035 if (in_len > sizeof(data_read_resp.data))
1036 in_len = sizeof(data_read_resp.data);
1037 data_read_force_send.id = CP2112_REQ_SMB_READ_FORCE_SEND;
1038 data_read_force_send.len = htobe16(in_len);
1039 err = cp2112iic_req_resp(sc,
1040 &data_read_force_send, sizeof(data_read_force_send),
1041 &data_read_resp, sizeof(data_read_resp));
1042 if (err != 0)
1043 goto out;
1044
1045 if (data_read_resp.id != CP2112_REQ_SMB_READ_RESPONSE) {
1046 device_printf(sc->dev,
1047 "unexpected response 0x%02x to data read request\n",
1048 data_read_resp.id);
1049 err = IIC_EBUSERR;
1050 goto out;
1051 }
1052
1053 DTRACE_PROBE2(read__response, uint8_t, data_read_resp.status,
1054 uint8_t, data_read_resp.len);
1055
1056 /*
1057 * We expect either the request completed status or, more typical for
1058 * this driver, the bus idle status because of the preceding
1059 * Force Read Status command (which is not an I2C request).
1060 */
1061 if (data_read_resp.status != CP2112_IIC_STATUS0_CMP &&
1062 data_read_resp.status != CP2112_IIC_STATUS0_IDLE) {
1063 err = IIC_EBUSERR;
1064 goto out;
1065 }
1066 if (data_read_resp.len > in_len) {
1067 device_printf(sc->dev, "device returns more data than asked\n");
1068 err = IIC_EOVERFLOW;
1069 goto out;
1070 }
1071
1072 *out_len = data_read_resp.len;
1073 if (*out_len > 0)
1074 memcpy(data, data_read_resp.data, *out_len);
1075 out:
1076 return (err);
1077 }
1078
1079 static int
cp2112iic_transfer(device_t dev,struct iic_msg * msgs,uint32_t nmsgs)1080 cp2112iic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
1081 {
1082 struct cp2112iic_softc *sc = device_get_softc(dev);
1083 struct cp2112_softc *psc = device_get_softc(device_get_parent(dev));
1084 const char *reason = NULL;
1085 uint32_t i;
1086 uint16_t read_off, to_read;
1087 int err;
1088
1089 /*
1090 * The hardware interface imposes limits on allowed I2C messages.
1091 * It is not possible to explicitly send a start or stop.
1092 * It is not possible to do a zero length transfer.
1093 * For this reason it's impossible to send a message with no data
1094 * at all (like an SMBus quick message).
1095 * Each read or write transfer beginning with the start condition
1096 * and ends with the stop condition. The only exception is that
1097 * it is possible to have a write transfer followed by a read
1098 * transfer to the same slave with the repeated start condition
1099 * between them.
1100 */
1101 for (i = 0; i < nmsgs; i++) {
1102 if (i == 0 && (msgs[i].flags & IIC_M_NOSTART) != 0) {
1103 reason = "first message without start";
1104 break;
1105 }
1106 if (i == nmsgs - 1 && (msgs[i].flags & IIC_M_NOSTOP) != 0) {
1107 reason = "last message without stop";
1108 break;
1109 }
1110 if (msgs[i].len == 0) {
1111 reason = "message with no data";
1112 break;
1113 }
1114 if ((msgs[i].flags & IIC_M_RD) != 0 &&
1115 msgs[i].len > CP2112_IIC_MAX_READ_LEN) {
1116 reason = "too long read";
1117 break;
1118 }
1119 if ((msgs[i].flags & IIC_M_RD) == 0 &&
1120 msgs[i].len > SIZEOF_FIELD(i2c_write_req, data)) {
1121 reason = "too long write";
1122 break;
1123 }
1124 if ((msgs[i].flags & IIC_M_NOSTART) != 0) {
1125 reason = "message without start or repeated start";
1126 break;
1127 }
1128 if ((msgs[i].flags & IIC_M_NOSTOP) != 0 &&
1129 (msgs[i].flags & IIC_M_RD) != 0) {
1130 reason = "read without stop";
1131 break;
1132 }
1133 if ((msgs[i].flags & IIC_M_NOSTOP) != 0 &&
1134 psc->sc_version < CP2112_IIC_REPSTART_VER) {
1135 reason = "write without stop";
1136 break;
1137 }
1138 if ((msgs[i].flags & IIC_M_NOSTOP) != 0 &&
1139 msgs[i].len > SIZEOF_FIELD(i2c_write_read_req, wdata)) {
1140 reason = "too long write without stop";
1141 break;
1142 }
1143 if (i > 0) {
1144 if ((msgs[i - 1].flags & IIC_M_NOSTOP) != 0 &&
1145 msgs[i].slave != msgs[i - 1].slave) {
1146 reason = "change of slave without stop";
1147 break;
1148 }
1149 if ((msgs[i - 1].flags & IIC_M_NOSTOP) != 0 &&
1150 (msgs[i].flags & IIC_M_RD) == 0) {
1151 reason = "write after repeated start";
1152 break;
1153 }
1154 }
1155 }
1156 if (reason != NULL) {
1157 if (bootverbose)
1158 device_printf(dev, "unsupported i2c message: %s\n",
1159 reason);
1160 return (IIC_ENOTSUPP);
1161 }
1162
1163 mtx_lock(&sc->io.lock);
1164
1165 for (i = 0; i < nmsgs; i++) {
1166 if (i + 1 < nmsgs && (msgs[i].flags & IIC_M_NOSTOP) != 0) {
1167 /*
1168 * Combine <write><repeated start><read> into a single
1169 * CP2112 operation.
1170 */
1171 struct i2c_write_read_req req;
1172
1173 KASSERT((msgs[i].flags & IIC_M_RD) == 0,
1174 ("read without stop"));
1175 KASSERT((msgs[i + 1].flags & IIC_M_RD) != 0,
1176 ("write after write without stop"));
1177 req.id = CP2112_REQ_SMB_WRITE_READ;
1178 req.slave = msgs[i].slave & ~LSB;
1179 to_read = msgs[i + 1].len;
1180 req.rlen = htobe16(to_read);
1181 req.wlen = msgs[i].len;
1182 memcpy(req.wdata, msgs[i].buf, msgs[i].len);
1183 err = cp2112iic_send_req(sc, &req, msgs[i].len + 5);
1184
1185 /*
1186 * The next message is already handled.
1187 * Also needed for read data to go into the right msg.
1188 */
1189 i++;
1190 } else if ((msgs[i].flags & IIC_M_RD) != 0) {
1191 struct i2c_read_req req;
1192
1193 req.id = CP2112_REQ_SMB_READ;
1194 req.slave = msgs[i].slave & ~LSB;
1195 to_read = msgs[i].len;
1196 req.len = htobe16(to_read);
1197 err = cp2112iic_send_req(sc, &req, sizeof(req));
1198 } else {
1199 struct i2c_write_req req;
1200
1201 req.id = CP2112_REQ_SMB_WRITE;
1202 req.slave = msgs[i].slave & ~LSB;
1203 req.len = msgs[i].len;
1204 memcpy(req.data, msgs[i].buf, msgs[i].len);
1205 to_read = 0;
1206 err = cp2112iic_send_req(sc, &req, msgs[i].len + 3);
1207 }
1208 if (err != 0)
1209 break;
1210
1211 err = cp2112iic_check_req_status(sc);
1212 if (err != 0)
1213 break;
1214
1215 read_off = 0;
1216 while (to_read > 0) {
1217 uint16_t act_read;
1218
1219 err = cp2112iic_read_data(sc, msgs[i].buf + read_off,
1220 to_read, &act_read);
1221 if (err != 0)
1222 break;
1223 KASSERT(act_read <= to_read, ("cp2112iic_read_data "
1224 "returned more data than asked"));
1225 read_off += act_read;
1226 to_read -= act_read;
1227 }
1228 if (err != 0)
1229 break;
1230 }
1231
1232 mtx_unlock(&sc->io.lock);
1233 return (err);
1234 }
1235
1236 static int
cp2112iic_reset(device_t dev,u_char speed,u_char addr,u_char * oldaddr)1237 cp2112iic_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
1238 {
1239 struct i2c_cfg_req i2c_cfg;
1240 struct cp2112iic_softc *sc;
1241 device_t cp2112;
1242 u_int busfreq;
1243 int err;
1244
1245 sc = device_get_softc(dev);
1246 cp2112 = device_get_parent(dev);
1247 if (sc->iicbus_dev == NULL)
1248 busfreq = 100000;
1249 else
1250 busfreq = IICBUS_GET_FREQUENCY(sc->iicbus_dev, speed);
1251
1252 err = cp2112_get_report(cp2112, CP2112_REQ_SMB_CFG,
1253 &i2c_cfg, sizeof(i2c_cfg));
1254 if (err != 0) {
1255 device_printf(dev, "failed to get CP2112_REQ_SMB_CFG report\n");
1256 return (err);
1257 }
1258
1259 if (oldaddr != NULL)
1260 *oldaddr = i2c_cfg.slave_addr;
1261 /*
1262 * For simplicity we do not enable Auto Send Read
1263 * because of erratum CP2112_E101 (fixed in version 3).
1264 *
1265 * TODO: set I2C parameters based on configuration preferences:
1266 * - read and write timeouts (no timeout by default),
1267 * - SCL low timeout (disabled by default),
1268 * etc.
1269 *
1270 * TODO: should the device reset request (0x01) be sent?
1271 * If the device disconnects as a result, then no.
1272 */
1273 i2c_cfg.speed = htobe32(busfreq);
1274 if (addr != 0)
1275 i2c_cfg.slave_addr = addr;
1276 i2c_cfg.auto_send_read = 0;
1277 i2c_cfg.retry_count = htobe16(1);
1278 i2c_cfg.scl_low_timeout = 0;
1279 if (bootverbose) {
1280 device_printf(dev, "speed %d Hz\n", be32toh(i2c_cfg.speed));
1281 device_printf(dev, "slave addr 0x%02x\n", i2c_cfg.slave_addr);
1282 device_printf(dev, "auto send read %s\n",
1283 i2c_cfg.auto_send_read ? "on" : "off");
1284 device_printf(dev, "write timeout %d ms (0 - disabled)\n",
1285 be16toh(i2c_cfg.write_timeout));
1286 device_printf(dev, "read timeout %d ms (0 - disabled)\n",
1287 be16toh(i2c_cfg.read_timeout));
1288 device_printf(dev, "scl low timeout %s\n",
1289 i2c_cfg.scl_low_timeout ? "on" : "off");
1290 device_printf(dev, "retry count %d (0 - no limit)\n",
1291 be16toh(i2c_cfg.retry_count));
1292 }
1293 err = cp2112_set_report(cp2112, CP2112_REQ_SMB_CFG,
1294 &i2c_cfg, sizeof(i2c_cfg));
1295 if (err != 0) {
1296 device_printf(dev, "failed to set CP2112_REQ_SMB_CFG report\n");
1297 return (err);
1298 }
1299 return (0);
1300 }
1301
1302 static int
cp2112iic_probe(device_t dev)1303 cp2112iic_probe(device_t dev)
1304 {
1305 device_set_desc(dev, "CP2112 I2C interface");
1306 return (BUS_PROBE_SPECIFIC);
1307 }
1308
1309 static int
cp2112iic_attach(device_t dev)1310 cp2112iic_attach(device_t dev)
1311 {
1312 struct cp2112iic_softc *sc;
1313 struct cp2112_softc *psc;
1314 device_t cp2112;
1315 int err;
1316
1317 sc = device_get_softc(dev);
1318 sc->dev = dev;
1319 cp2112 = device_get_parent(dev);
1320 psc = device_get_softc(cp2112);
1321
1322 mtx_init(&sc->io.lock, "cp2112iic lock", NULL, MTX_DEF | MTX_RECURSE);
1323 cv_init(&sc->io.cv, "cp2112iic cv");
1324
1325 err = usbd_transfer_setup(psc->sc_udev,
1326 &psc->sc_iface_index, sc->xfers, cp2112iic_config,
1327 nitems(cp2112iic_config), sc, &sc->io.lock);
1328 if (err != 0) {
1329 device_printf(dev, "usbd_transfer_setup failed %d\n", err);
1330 goto detach;
1331 }
1332
1333 /* Prepare to receive interrupts. */
1334 mtx_lock(&sc->io.lock);
1335 usbd_transfer_start(sc->xfers[CP2112_INTR_IN]);
1336 mtx_unlock(&sc->io.lock);
1337
1338 sc->iicbus_dev = device_add_child(dev, "iicbus", -1);
1339 if (sc->iicbus_dev == NULL) {
1340 device_printf(dev, "iicbus creation failed\n");
1341 err = ENXIO;
1342 goto detach;
1343 }
1344 bus_generic_attach(dev);
1345 return (0);
1346
1347 detach:
1348 cp2112iic_detach(dev);
1349 return (err);
1350 }
1351
1352 static int
cp2112iic_detach(device_t dev)1353 cp2112iic_detach(device_t dev)
1354 {
1355 struct cp2112iic_softc *sc;
1356 int err;
1357
1358 sc = device_get_softc(dev);
1359 err = bus_generic_detach(dev);
1360 if (err != 0)
1361 return (err);
1362 device_delete_children(dev);
1363
1364 mtx_lock(&sc->io.lock);
1365 usbd_transfer_stop(sc->xfers[CP2112_INTR_IN]);
1366 mtx_unlock(&sc->io.lock);
1367 usbd_transfer_unsetup(sc->xfers, nitems(cp2112iic_config));
1368
1369 cv_destroy(&sc->io.cv);
1370 mtx_destroy(&sc->io.lock);
1371
1372 return (0);
1373 }
1374
1375 static device_method_t cp2112hid_methods[] = {
1376 DEVMETHOD(device_probe, cp2112_probe),
1377 DEVMETHOD(device_attach, cp2112_attach),
1378 DEVMETHOD(device_detach, cp2112_detach),
1379
1380 DEVMETHOD_END
1381 };
1382
1383 static driver_t cp2112hid_driver = {
1384 .name = "cp2112hid",
1385 .methods = cp2112hid_methods,
1386 .size = sizeof(struct cp2112_softc),
1387 };
1388
1389 DRIVER_MODULE(cp2112hid, uhub, cp2112hid_driver, NULL, NULL);
1390 MODULE_DEPEND(cp2112hid, usb, 1, 1, 1);
1391 MODULE_VERSION(cp2112hid, 1);
1392 USB_PNP_HOST_INFO(cp2112_devs);
1393
1394 static device_method_t cp2112gpio_methods[] = {
1395 /* Device */
1396 DEVMETHOD(device_probe, cp2112gpio_probe),
1397 DEVMETHOD(device_attach, cp2112gpio_attach),
1398 DEVMETHOD(device_detach, cp2112gpio_detach),
1399
1400 /* GPIO */
1401 DEVMETHOD(gpio_get_bus, cp2112_gpio_get_bus),
1402 DEVMETHOD(gpio_pin_max, cp2112_gpio_pin_max),
1403 DEVMETHOD(gpio_pin_get, cp2112_gpio_pin_get),
1404 DEVMETHOD(gpio_pin_set, cp2112_gpio_pin_set),
1405 DEVMETHOD(gpio_pin_toggle, cp2112_gpio_pin_toggle),
1406 DEVMETHOD(gpio_pin_getname, cp2112_gpio_pin_getname),
1407 DEVMETHOD(gpio_pin_getcaps, cp2112_gpio_pin_getcaps),
1408 DEVMETHOD(gpio_pin_getflags, cp2112_gpio_pin_getflags),
1409 DEVMETHOD(gpio_pin_setflags, cp2112_gpio_pin_setflags),
1410
1411 DEVMETHOD_END
1412 };
1413
1414 static driver_t cp2112gpio_driver = {
1415 .name = "gpio",
1416 .methods = cp2112gpio_methods,
1417 .size = sizeof(struct cp2112gpio_softc),
1418 };
1419
1420 DRIVER_MODULE(cp2112gpio, cp2112hid, cp2112gpio_driver, NULL, NULL);
1421 MODULE_DEPEND(cp2112gpio, cp2112hid, 1, 1, 1);
1422 MODULE_DEPEND(cp2112gpio, gpiobus, 1, 1, 1);
1423 MODULE_VERSION(cp2112gpio, 1);
1424
1425 static device_method_t cp2112iic_methods[] = {
1426 /* Device interface */
1427 DEVMETHOD(device_probe, cp2112iic_probe),
1428 DEVMETHOD(device_attach, cp2112iic_attach),
1429 DEVMETHOD(device_detach, cp2112iic_detach),
1430
1431 /* I2C methods */
1432 DEVMETHOD(iicbus_transfer, cp2112iic_transfer),
1433 DEVMETHOD(iicbus_reset, cp2112iic_reset),
1434 DEVMETHOD(iicbus_callback, iicbus_null_callback),
1435
1436 DEVMETHOD_END
1437 };
1438
1439 static driver_t cp2112iic_driver = {
1440 "iichb",
1441 cp2112iic_methods,
1442 sizeof(struct cp2112iic_softc)
1443 };
1444
1445 DRIVER_MODULE(cp2112iic, cp2112hid, cp2112iic_driver, NULL, NULL);
1446 MODULE_DEPEND(cp2112iic, cp2112hid, 1, 1, 1);
1447 MODULE_DEPEND(cp2112iic, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
1448 MODULE_VERSION(cp2112iic, 1);
1449