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