99#endif
100
101int
102gpio_check_flags(uint32_t caps, uint32_t flags)
103{
104
105 /* Check for unwanted flags. */
106 if ((flags & caps) == 0 || (flags & caps) != flags)
107 return (EINVAL);
108 /* Cannot mix input/output together. */
109 if (flags & GPIO_PIN_INPUT && flags & GPIO_PIN_OUTPUT)
110 return (EINVAL);
111 /* Cannot mix pull-up/pull-down together. */
112 if (flags & GPIO_PIN_PULLUP && flags & GPIO_PIN_PULLDOWN)
113 return (EINVAL);
114
115 return (0);
116}
117
118static void
119gpiobus_print_pins(struct gpiobus_ivar *devi, char *buf, size_t buflen)
120{
121 char tmp[128];
122 int i, range_start, range_stop, need_coma;
123
124 if (devi->npins == 0)
125 return;
126
127 need_coma = 0;
128 range_start = range_stop = devi->pins[0];
129 for (i = 1; i < devi->npins; i++) {
130 if (devi->pins[i] != (range_stop + 1)) {
131 if (need_coma)
132 strlcat(buf, ",", buflen);
133 memset(tmp, 0, sizeof(tmp));
134 if (range_start != range_stop)
135 snprintf(tmp, sizeof(tmp) - 1, "%d-%d",
136 range_start, range_stop);
137 else
138 snprintf(tmp, sizeof(tmp) - 1, "%d",
139 range_start);
140 strlcat(buf, tmp, buflen);
141
142 range_start = range_stop = devi->pins[i];
143 need_coma = 1;
144 }
145 else
146 range_stop++;
147 }
148
149 if (need_coma)
150 strlcat(buf, ",", buflen);
151 memset(tmp, 0, sizeof(tmp));
152 if (range_start != range_stop)
153 snprintf(tmp, sizeof(tmp) - 1, "%d-%d",
154 range_start, range_stop);
155 else
156 snprintf(tmp, sizeof(tmp) - 1, "%d",
157 range_start);
158 strlcat(buf, tmp, buflen);
159}
160
161device_t
162gpiobus_attach_bus(device_t dev)
163{
164 device_t busdev;
165
166 busdev = device_add_child(dev, "gpiobus", -1);
167 if (busdev == NULL)
168 return (NULL);
169 if (device_add_child(dev, "gpioc", -1) == NULL) {
170 device_delete_child(dev, busdev);
171 return (NULL);
172 }
173#ifdef FDT
174 ofw_gpiobus_register_provider(dev);
175#endif
176 bus_generic_attach(dev);
177
178 return (busdev);
179}
180
181int
182gpiobus_detach_bus(device_t dev)
183{
184 int err;
185
186#ifdef FDT
187 ofw_gpiobus_unregister_provider(dev);
188#endif
189 err = bus_generic_detach(dev);
190 if (err != 0)
191 return (err);
192
193 return (device_delete_children(dev));
194}
195
196int
197gpiobus_init_softc(device_t dev)
198{
199 struct gpiobus_softc *sc;
200
201 sc = GPIOBUS_SOFTC(dev);
202 sc->sc_busdev = dev;
203 sc->sc_dev = device_get_parent(dev);
204 sc->sc_intr_rman.rm_type = RMAN_ARRAY;
205 sc->sc_intr_rman.rm_descr = "GPIO Interrupts";
206 if (rman_init(&sc->sc_intr_rman) != 0 ||
207 rman_manage_region(&sc->sc_intr_rman, 0, ~0) != 0)
208 panic("%s: failed to set up rman.", __func__);
209
210 if (GPIO_PIN_MAX(sc->sc_dev, &sc->sc_npins) != 0)
211 return (ENXIO);
212
213 KASSERT(sc->sc_npins >= 0, ("GPIO device with no pins"));
214
215 /* Pins = GPIO_PIN_MAX() + 1 */
216 sc->sc_npins++;
217
218 sc->sc_pins = malloc(sizeof(*sc->sc_pins) * sc->sc_npins, M_DEVBUF,
219 M_NOWAIT | M_ZERO);
220 if (sc->sc_pins == NULL)
221 return (ENOMEM);
222
223 /* Initialize the bus lock. */
224 GPIOBUS_LOCK_INIT(sc);
225
226 return (0);
227}
228
229int
230gpiobus_alloc_ivars(struct gpiobus_ivar *devi)
231{
232
233 /* Allocate pins and flags memory. */
234 devi->pins = malloc(sizeof(uint32_t) * devi->npins, M_DEVBUF,
235 M_NOWAIT | M_ZERO);
236 if (devi->pins == NULL)
237 return (ENOMEM);
238 devi->flags = malloc(sizeof(uint32_t) * devi->npins, M_DEVBUF,
239 M_NOWAIT | M_ZERO);
240 if (devi->flags == NULL) {
241 free(devi->pins, M_DEVBUF);
242 return (ENOMEM);
243 }
244
245 return (0);
246}
247
248void
249gpiobus_free_ivars(struct gpiobus_ivar *devi)
250{
251
252 if (devi->flags) {
253 free(devi->flags, M_DEVBUF);
254 devi->flags = NULL;
255 }
256 if (devi->pins) {
257 free(devi->pins, M_DEVBUF);
258 devi->pins = NULL;
259 }
260}
261
262int
263gpiobus_acquire_pin(device_t bus, uint32_t pin)
264{
265 struct gpiobus_softc *sc;
266
267 sc = device_get_softc(bus);
268 /* Consistency check. */
269 if (pin >= sc->sc_npins) {
270 device_printf(bus,
271 "invalid pin %d, max: %d\n", pin, sc->sc_npins - 1);
272 return (-1);
273 }
274 /* Mark pin as mapped and give warning if it's already mapped. */
275 if (sc->sc_pins[pin].mapped) {
276 device_printf(bus, "warning: pin %d is already mapped\n", pin);
277 return (-1);
278 }
279 sc->sc_pins[pin].mapped = 1;
280
281 return (0);
282}
283
284/* Release mapped pin */
285int
286gpiobus_release_pin(device_t bus, uint32_t pin)
287{
288 struct gpiobus_softc *sc;
289
290 sc = device_get_softc(bus);
291 /* Consistency check. */
292 if (pin >= sc->sc_npins) {
293 device_printf(bus,
294 "gpiobus_acquire_pin: invalid pin %d, max=%d\n",
295 pin, sc->sc_npins - 1);
296 return (-1);
297 }
298
299 if (!sc->sc_pins[pin].mapped) {
300 device_printf(bus, "gpiobus_acquire_pin: pin %d is not mapped\n", pin);
301 return (-1);
302 }
303 sc->sc_pins[pin].mapped = 0;
304
305 return (0);
306}
307
308static int
309gpiobus_parse_pins(struct gpiobus_softc *sc, device_t child, int mask)
310{
311 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
312 int i, npins;
313
314 npins = 0;
315 for (i = 0; i < 32; i++) {
316 if (mask & (1 << i))
317 npins++;
318 }
319 if (npins == 0) {
320 device_printf(child, "empty pin mask\n");
321 return (EINVAL);
322 }
323 devi->npins = npins;
324 if (gpiobus_alloc_ivars(devi) != 0) {
325 device_printf(child, "cannot allocate device ivars\n");
326 return (EINVAL);
327 }
328 npins = 0;
329 for (i = 0; i < 32; i++) {
330 if ((mask & (1 << i)) == 0)
331 continue;
332 /* Reserve the GPIO pin. */
333 if (gpiobus_acquire_pin(sc->sc_busdev, i) != 0) {
334 gpiobus_free_ivars(devi);
335 return (EINVAL);
336 }
337 devi->pins[npins++] = i;
338 /* Use the child name as pin name. */
339 GPIOBUS_PIN_SETNAME(sc->sc_busdev, i,
340 device_get_nameunit(child));
341 }
342
343 return (0);
344}
345
346static int
347gpiobus_probe(device_t dev)
348{
349 device_set_desc(dev, "GPIO bus");
350
351 return (BUS_PROBE_GENERIC);
352}
353
354static int
355gpiobus_attach(device_t dev)
356{
357 int err;
358
359 err = gpiobus_init_softc(dev);
360 if (err != 0)
361 return (err);
362
363 /*
364 * Get parent's pins and mark them as unmapped
365 */
366 bus_generic_probe(dev);
367 bus_enumerate_hinted_children(dev);
368
369 return (bus_generic_attach(dev));
370}
371
372/*
373 * Since this is not a self-enumerating bus, and since we always add
374 * children in attach, we have to always delete children here.
375 */
376static int
377gpiobus_detach(device_t dev)
378{
379 struct gpiobus_softc *sc;
380 struct gpiobus_ivar *devi;
381 device_t *devlist;
382 int i, err, ndevs;
383
384 sc = GPIOBUS_SOFTC(dev);
385 KASSERT(mtx_initialized(&sc->sc_mtx),
386 ("gpiobus mutex not initialized"));
387 GPIOBUS_LOCK_DESTROY(sc);
388
389 if ((err = bus_generic_detach(dev)) != 0)
390 return (err);
391
392 if ((err = device_get_children(dev, &devlist, &ndevs)) != 0)
393 return (err);
394 for (i = 0; i < ndevs; i++) {
395 devi = GPIOBUS_IVAR(devlist[i]);
396 gpiobus_free_ivars(devi);
397 resource_list_free(&devi->rl);
398 free(devi, M_DEVBUF);
399 device_delete_child(dev, devlist[i]);
400 }
401 free(devlist, M_TEMP);
402 rman_fini(&sc->sc_intr_rman);
403 if (sc->sc_pins) {
404 for (i = 0; i < sc->sc_npins; i++) {
405 if (sc->sc_pins[i].name != NULL)
406 free(sc->sc_pins[i].name, M_DEVBUF);
407 sc->sc_pins[i].name = NULL;
408 }
409 free(sc->sc_pins, M_DEVBUF);
410 sc->sc_pins = NULL;
411 }
412
413 return (0);
414}
415
416static int
417gpiobus_suspend(device_t dev)
418{
419
420 return (bus_generic_suspend(dev));
421}
422
423static int
424gpiobus_resume(device_t dev)
425{
426
427 return (bus_generic_resume(dev));
428}
429
430static void
431gpiobus_probe_nomatch(device_t dev, device_t child)
432{
433 char pins[128];
434 struct gpiobus_ivar *devi;
435
436 devi = GPIOBUS_IVAR(child);
437 memset(pins, 0, sizeof(pins));
438 gpiobus_print_pins(devi, pins, sizeof(pins));
439 if (devi->npins > 1)
440 device_printf(dev, "<unknown device> at pins %s", pins);
441 else
442 device_printf(dev, "<unknown device> at pin %s", pins);
443 resource_list_print_type(&devi->rl, "irq", SYS_RES_IRQ, "%jd");
444 printf("\n");
445}
446
447static int
448gpiobus_print_child(device_t dev, device_t child)
449{
450 char pins[128];
451 int retval = 0;
452 struct gpiobus_ivar *devi;
453
454 devi = GPIOBUS_IVAR(child);
455 memset(pins, 0, sizeof(pins));
456 retval += bus_print_child_header(dev, child);
457 if (devi->npins > 0) {
458 if (devi->npins > 1)
459 retval += printf(" at pins ");
460 else
461 retval += printf(" at pin ");
462 gpiobus_print_pins(devi, pins, sizeof(pins));
463 retval += printf("%s", pins);
464 }
465 resource_list_print_type(&devi->rl, "irq", SYS_RES_IRQ, "%jd");
466 retval += bus_print_child_footer(dev, child);
467
468 return (retval);
469}
470
471static int
472gpiobus_child_location_str(device_t bus, device_t child, char *buf,
473 size_t buflen)
474{
475 struct gpiobus_ivar *devi;
476
477 devi = GPIOBUS_IVAR(child);
478 if (devi->npins > 1)
479 strlcpy(buf, "pins=", buflen);
480 else
481 strlcpy(buf, "pin=", buflen);
482 gpiobus_print_pins(devi, buf, buflen);
483
484 return (0);
485}
486
487static int
488gpiobus_child_pnpinfo_str(device_t bus, device_t child, char *buf,
489 size_t buflen)
490{
491
492 *buf = '\0';
493 return (0);
494}
495
496static device_t
497gpiobus_add_child(device_t dev, u_int order, const char *name, int unit)
498{
499 device_t child;
500 struct gpiobus_ivar *devi;
501
502 child = device_add_child_ordered(dev, order, name, unit);
503 if (child == NULL)
504 return (child);
505 devi = malloc(sizeof(struct gpiobus_ivar), M_DEVBUF, M_NOWAIT | M_ZERO);
506 if (devi == NULL) {
507 device_delete_child(dev, child);
508 return (NULL);
509 }
510 resource_list_init(&devi->rl);
511 device_set_ivars(child, devi);
512
513 return (child);
514}
515
516static void
517gpiobus_hinted_child(device_t bus, const char *dname, int dunit)
518{
519 struct gpiobus_softc *sc = GPIOBUS_SOFTC(bus);
520 struct gpiobus_ivar *devi;
521 device_t child;
522 int irq, pins;
523
524 child = BUS_ADD_CHILD(bus, 0, dname, dunit);
525 devi = GPIOBUS_IVAR(child);
526 resource_int_value(dname, dunit, "pins", &pins);
527 if (gpiobus_parse_pins(sc, child, pins)) {
528 resource_list_free(&devi->rl);
529 free(devi, M_DEVBUF);
530 device_delete_child(bus, child);
531 }
532 if (resource_int_value(dname, dunit, "irq", &irq) == 0) {
533 if (bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1) != 0)
534 device_printf(bus,
535 "warning: bus_set_resource() failed\n");
536 }
537}
538
539static int
540gpiobus_set_resource(device_t dev, device_t child, int type, int rid,
541 rman_res_t start, rman_res_t count)
542{
543 struct gpiobus_ivar *devi;
544 struct resource_list_entry *rle;
545
546 dprintf("%s: entry (%p, %p, %d, %d, %p, %ld)\n",
547 __func__, dev, child, type, rid, (void *)(intptr_t)start, count);
548 devi = GPIOBUS_IVAR(child);
549 rle = resource_list_add(&devi->rl, type, rid, start,
550 start + count - 1, count);
551 if (rle == NULL)
552 return (ENXIO);
553
554 return (0);
555}
556
557static struct resource *
558gpiobus_alloc_resource(device_t bus, device_t child, int type, int *rid,
559 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
560{
561 struct gpiobus_softc *sc;
562 struct resource *rv;
563 struct resource_list *rl;
564 struct resource_list_entry *rle;
565 int isdefault;
566
567 if (type != SYS_RES_IRQ)
568 return (NULL);
569 isdefault = (RMAN_IS_DEFAULT_RANGE(start, end) && count == 1);
570 rle = NULL;
571 if (isdefault) {
572 rl = BUS_GET_RESOURCE_LIST(bus, child);
573 if (rl == NULL)
574 return (NULL);
575 rle = resource_list_find(rl, type, *rid);
576 if (rle == NULL)
577 return (NULL);
578 if (rle->res != NULL)
579 panic("%s: resource entry is busy", __func__);
580 start = rle->start;
581 count = rle->count;
582 end = rle->end;
583 }
584 sc = device_get_softc(bus);
585 rv = rman_reserve_resource(&sc->sc_intr_rman, start, end, count, flags,
586 child);
587 if (rv == NULL)
588 return (NULL);
589 rman_set_rid(rv, *rid);
590 if ((flags & RF_ACTIVE) != 0 &&
591 bus_activate_resource(child, type, *rid, rv) != 0) {
592 rman_release_resource(rv);
593 return (NULL);
594 }
595
596 return (rv);
597}
598
599static int
600gpiobus_release_resource(device_t bus __unused, device_t child, int type,
601 int rid, struct resource *r)
602{
603 int error;
604
605 if (rman_get_flags(r) & RF_ACTIVE) {
606 error = bus_deactivate_resource(child, type, rid, r);
607 if (error)
608 return (error);
609 }
610
611 return (rman_release_resource(r));
612}
613
614static struct resource_list *
615gpiobus_get_resource_list(device_t bus __unused, device_t child)
616{
617 struct gpiobus_ivar *ivar;
618
619 ivar = GPIOBUS_IVAR(child);
620
621 return (&ivar->rl);
622}
623
624static int
625gpiobus_acquire_bus(device_t busdev, device_t child, int how)
626{
627 struct gpiobus_softc *sc;
628
629 sc = device_get_softc(busdev);
630 GPIOBUS_ASSERT_UNLOCKED(sc);
631 GPIOBUS_LOCK(sc);
632 if (sc->sc_owner != NULL) {
633 if (sc->sc_owner == child)
634 panic("%s: %s still owns the bus.",
635 device_get_nameunit(busdev),
636 device_get_nameunit(child));
637 if (how == GPIOBUS_DONTWAIT) {
638 GPIOBUS_UNLOCK(sc);
639 return (EWOULDBLOCK);
640 }
641 while (sc->sc_owner != NULL)
642 mtx_sleep(sc, &sc->sc_mtx, 0, "gpiobuswait", 0);
643 }
644 sc->sc_owner = child;
645 GPIOBUS_UNLOCK(sc);
646
647 return (0);
648}
649
650static void
651gpiobus_release_bus(device_t busdev, device_t child)
652{
653 struct gpiobus_softc *sc;
654
655 sc = device_get_softc(busdev);
656 GPIOBUS_ASSERT_UNLOCKED(sc);
657 GPIOBUS_LOCK(sc);
658 if (sc->sc_owner == NULL)
659 panic("%s: %s releasing unowned bus.",
660 device_get_nameunit(busdev),
661 device_get_nameunit(child));
662 if (sc->sc_owner != child)
663 panic("%s: %s trying to release bus owned by %s",
664 device_get_nameunit(busdev),
665 device_get_nameunit(child),
666 device_get_nameunit(sc->sc_owner));
667 sc->sc_owner = NULL;
668 wakeup(sc);
669 GPIOBUS_UNLOCK(sc);
670}
671
672static int
673gpiobus_pin_setflags(device_t dev, device_t child, uint32_t pin,
674 uint32_t flags)
675{
676 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
677 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
678 uint32_t caps;
679
680 if (pin >= devi->npins)
681 return (EINVAL);
682 if (GPIO_PIN_GETCAPS(sc->sc_dev, devi->pins[pin], &caps) != 0)
683 return (EINVAL);
684 if (gpio_check_flags(caps, flags) != 0)
685 return (EINVAL);
686
687 return (GPIO_PIN_SETFLAGS(sc->sc_dev, devi->pins[pin], flags));
688}
689
690static int
691gpiobus_pin_getflags(device_t dev, device_t child, uint32_t pin,
692 uint32_t *flags)
693{
694 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
695 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
696
697 if (pin >= devi->npins)
698 return (EINVAL);
699
700 return GPIO_PIN_GETFLAGS(sc->sc_dev, devi->pins[pin], flags);
701}
702
703static int
704gpiobus_pin_getcaps(device_t dev, device_t child, uint32_t pin,
705 uint32_t *caps)
706{
707 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
708 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
709
710 if (pin >= devi->npins)
711 return (EINVAL);
712
713 return GPIO_PIN_GETCAPS(sc->sc_dev, devi->pins[pin], caps);
714}
715
716static int
717gpiobus_pin_set(device_t dev, device_t child, uint32_t pin,
718 unsigned int value)
719{
720 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
721 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
722
723 if (pin >= devi->npins)
724 return (EINVAL);
725
726 return GPIO_PIN_SET(sc->sc_dev, devi->pins[pin], value);
727}
728
729static int
730gpiobus_pin_get(device_t dev, device_t child, uint32_t pin,
731 unsigned int *value)
732{
733 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
734 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
735
736 if (pin >= devi->npins)
737 return (EINVAL);
738
739 return GPIO_PIN_GET(sc->sc_dev, devi->pins[pin], value);
740}
741
742static int
743gpiobus_pin_toggle(device_t dev, device_t child, uint32_t pin)
744{
745 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
746 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
747
748 if (pin >= devi->npins)
749 return (EINVAL);
750
751 return GPIO_PIN_TOGGLE(sc->sc_dev, devi->pins[pin]);
752}
753
754static int
755gpiobus_pin_getname(device_t dev, uint32_t pin, char *name)
756{
757 struct gpiobus_softc *sc;
758
759 sc = GPIOBUS_SOFTC(dev);
760 if (pin > sc->sc_npins)
761 return (EINVAL);
762 /* Did we have a name for this pin ? */
763 if (sc->sc_pins[pin].name != NULL) {
764 memcpy(name, sc->sc_pins[pin].name, GPIOMAXNAME);
765 return (0);
766 }
767
768 /* Return the default pin name. */
769 return (GPIO_PIN_GETNAME(device_get_parent(dev), pin, name));
770}
771
772static int
773gpiobus_pin_setname(device_t dev, uint32_t pin, const char *name)
774{
775 struct gpiobus_softc *sc;
776
777 sc = GPIOBUS_SOFTC(dev);
778 if (pin > sc->sc_npins)
779 return (EINVAL);
780 if (name == NULL)
781 return (EINVAL);
782 /* Save the pin name. */
783 if (sc->sc_pins[pin].name == NULL)
784 sc->sc_pins[pin].name = malloc(GPIOMAXNAME, M_DEVBUF,
785 M_WAITOK | M_ZERO);
786 strlcpy(sc->sc_pins[pin].name, name, GPIOMAXNAME);
787
788 return (0);
789}
790
791static device_method_t gpiobus_methods[] = {
792 /* Device interface */
793 DEVMETHOD(device_probe, gpiobus_probe),
794 DEVMETHOD(device_attach, gpiobus_attach),
795 DEVMETHOD(device_detach, gpiobus_detach),
796 DEVMETHOD(device_shutdown, bus_generic_shutdown),
797 DEVMETHOD(device_suspend, gpiobus_suspend),
798 DEVMETHOD(device_resume, gpiobus_resume),
799
800 /* Bus interface */
801 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
802 DEVMETHOD(bus_config_intr, bus_generic_config_intr),
803 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
804 DEVMETHOD(bus_set_resource, gpiobus_set_resource),
805 DEVMETHOD(bus_alloc_resource, gpiobus_alloc_resource),
806 DEVMETHOD(bus_release_resource, gpiobus_release_resource),
807 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
808 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
809 DEVMETHOD(bus_get_resource_list, gpiobus_get_resource_list),
810 DEVMETHOD(bus_add_child, gpiobus_add_child),
811 DEVMETHOD(bus_probe_nomatch, gpiobus_probe_nomatch),
812 DEVMETHOD(bus_print_child, gpiobus_print_child),
813 DEVMETHOD(bus_child_pnpinfo_str, gpiobus_child_pnpinfo_str),
814 DEVMETHOD(bus_child_location_str, gpiobus_child_location_str),
815 DEVMETHOD(bus_hinted_child, gpiobus_hinted_child),
816
817 /* GPIO protocol */
818 DEVMETHOD(gpiobus_acquire_bus, gpiobus_acquire_bus),
819 DEVMETHOD(gpiobus_release_bus, gpiobus_release_bus),
820 DEVMETHOD(gpiobus_pin_getflags, gpiobus_pin_getflags),
821 DEVMETHOD(gpiobus_pin_getcaps, gpiobus_pin_getcaps),
822 DEVMETHOD(gpiobus_pin_setflags, gpiobus_pin_setflags),
823 DEVMETHOD(gpiobus_pin_get, gpiobus_pin_get),
824 DEVMETHOD(gpiobus_pin_set, gpiobus_pin_set),
825 DEVMETHOD(gpiobus_pin_toggle, gpiobus_pin_toggle),
826 DEVMETHOD(gpiobus_pin_getname, gpiobus_pin_getname),
827 DEVMETHOD(gpiobus_pin_setname, gpiobus_pin_setname),
828
829 DEVMETHOD_END
830};
831
832driver_t gpiobus_driver = {
833 "gpiobus",
834 gpiobus_methods,
835 sizeof(struct gpiobus_softc)
836};
837
838devclass_t gpiobus_devclass;
839
840DRIVER_MODULE(gpiobus, gpio, gpiobus_driver, gpiobus_devclass, 0, 0);
841MODULE_VERSION(gpiobus, 1);
| 107#endif
108
109int
110gpio_check_flags(uint32_t caps, uint32_t flags)
111{
112
113 /* Check for unwanted flags. */
114 if ((flags & caps) == 0 || (flags & caps) != flags)
115 return (EINVAL);
116 /* Cannot mix input/output together. */
117 if (flags & GPIO_PIN_INPUT && flags & GPIO_PIN_OUTPUT)
118 return (EINVAL);
119 /* Cannot mix pull-up/pull-down together. */
120 if (flags & GPIO_PIN_PULLUP && flags & GPIO_PIN_PULLDOWN)
121 return (EINVAL);
122
123 return (0);
124}
125
126static void
127gpiobus_print_pins(struct gpiobus_ivar *devi, char *buf, size_t buflen)
128{
129 char tmp[128];
130 int i, range_start, range_stop, need_coma;
131
132 if (devi->npins == 0)
133 return;
134
135 need_coma = 0;
136 range_start = range_stop = devi->pins[0];
137 for (i = 1; i < devi->npins; i++) {
138 if (devi->pins[i] != (range_stop + 1)) {
139 if (need_coma)
140 strlcat(buf, ",", buflen);
141 memset(tmp, 0, sizeof(tmp));
142 if (range_start != range_stop)
143 snprintf(tmp, sizeof(tmp) - 1, "%d-%d",
144 range_start, range_stop);
145 else
146 snprintf(tmp, sizeof(tmp) - 1, "%d",
147 range_start);
148 strlcat(buf, tmp, buflen);
149
150 range_start = range_stop = devi->pins[i];
151 need_coma = 1;
152 }
153 else
154 range_stop++;
155 }
156
157 if (need_coma)
158 strlcat(buf, ",", buflen);
159 memset(tmp, 0, sizeof(tmp));
160 if (range_start != range_stop)
161 snprintf(tmp, sizeof(tmp) - 1, "%d-%d",
162 range_start, range_stop);
163 else
164 snprintf(tmp, sizeof(tmp) - 1, "%d",
165 range_start);
166 strlcat(buf, tmp, buflen);
167}
168
169device_t
170gpiobus_attach_bus(device_t dev)
171{
172 device_t busdev;
173
174 busdev = device_add_child(dev, "gpiobus", -1);
175 if (busdev == NULL)
176 return (NULL);
177 if (device_add_child(dev, "gpioc", -1) == NULL) {
178 device_delete_child(dev, busdev);
179 return (NULL);
180 }
181#ifdef FDT
182 ofw_gpiobus_register_provider(dev);
183#endif
184 bus_generic_attach(dev);
185
186 return (busdev);
187}
188
189int
190gpiobus_detach_bus(device_t dev)
191{
192 int err;
193
194#ifdef FDT
195 ofw_gpiobus_unregister_provider(dev);
196#endif
197 err = bus_generic_detach(dev);
198 if (err != 0)
199 return (err);
200
201 return (device_delete_children(dev));
202}
203
204int
205gpiobus_init_softc(device_t dev)
206{
207 struct gpiobus_softc *sc;
208
209 sc = GPIOBUS_SOFTC(dev);
210 sc->sc_busdev = dev;
211 sc->sc_dev = device_get_parent(dev);
212 sc->sc_intr_rman.rm_type = RMAN_ARRAY;
213 sc->sc_intr_rman.rm_descr = "GPIO Interrupts";
214 if (rman_init(&sc->sc_intr_rman) != 0 ||
215 rman_manage_region(&sc->sc_intr_rman, 0, ~0) != 0)
216 panic("%s: failed to set up rman.", __func__);
217
218 if (GPIO_PIN_MAX(sc->sc_dev, &sc->sc_npins) != 0)
219 return (ENXIO);
220
221 KASSERT(sc->sc_npins >= 0, ("GPIO device with no pins"));
222
223 /* Pins = GPIO_PIN_MAX() + 1 */
224 sc->sc_npins++;
225
226 sc->sc_pins = malloc(sizeof(*sc->sc_pins) * sc->sc_npins, M_DEVBUF,
227 M_NOWAIT | M_ZERO);
228 if (sc->sc_pins == NULL)
229 return (ENOMEM);
230
231 /* Initialize the bus lock. */
232 GPIOBUS_LOCK_INIT(sc);
233
234 return (0);
235}
236
237int
238gpiobus_alloc_ivars(struct gpiobus_ivar *devi)
239{
240
241 /* Allocate pins and flags memory. */
242 devi->pins = malloc(sizeof(uint32_t) * devi->npins, M_DEVBUF,
243 M_NOWAIT | M_ZERO);
244 if (devi->pins == NULL)
245 return (ENOMEM);
246 devi->flags = malloc(sizeof(uint32_t) * devi->npins, M_DEVBUF,
247 M_NOWAIT | M_ZERO);
248 if (devi->flags == NULL) {
249 free(devi->pins, M_DEVBUF);
250 return (ENOMEM);
251 }
252
253 return (0);
254}
255
256void
257gpiobus_free_ivars(struct gpiobus_ivar *devi)
258{
259
260 if (devi->flags) {
261 free(devi->flags, M_DEVBUF);
262 devi->flags = NULL;
263 }
264 if (devi->pins) {
265 free(devi->pins, M_DEVBUF);
266 devi->pins = NULL;
267 }
268}
269
270int
271gpiobus_acquire_pin(device_t bus, uint32_t pin)
272{
273 struct gpiobus_softc *sc;
274
275 sc = device_get_softc(bus);
276 /* Consistency check. */
277 if (pin >= sc->sc_npins) {
278 device_printf(bus,
279 "invalid pin %d, max: %d\n", pin, sc->sc_npins - 1);
280 return (-1);
281 }
282 /* Mark pin as mapped and give warning if it's already mapped. */
283 if (sc->sc_pins[pin].mapped) {
284 device_printf(bus, "warning: pin %d is already mapped\n", pin);
285 return (-1);
286 }
287 sc->sc_pins[pin].mapped = 1;
288
289 return (0);
290}
291
292/* Release mapped pin */
293int
294gpiobus_release_pin(device_t bus, uint32_t pin)
295{
296 struct gpiobus_softc *sc;
297
298 sc = device_get_softc(bus);
299 /* Consistency check. */
300 if (pin >= sc->sc_npins) {
301 device_printf(bus,
302 "gpiobus_acquire_pin: invalid pin %d, max=%d\n",
303 pin, sc->sc_npins - 1);
304 return (-1);
305 }
306
307 if (!sc->sc_pins[pin].mapped) {
308 device_printf(bus, "gpiobus_acquire_pin: pin %d is not mapped\n", pin);
309 return (-1);
310 }
311 sc->sc_pins[pin].mapped = 0;
312
313 return (0);
314}
315
316static int
317gpiobus_parse_pins(struct gpiobus_softc *sc, device_t child, int mask)
318{
319 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
320 int i, npins;
321
322 npins = 0;
323 for (i = 0; i < 32; i++) {
324 if (mask & (1 << i))
325 npins++;
326 }
327 if (npins == 0) {
328 device_printf(child, "empty pin mask\n");
329 return (EINVAL);
330 }
331 devi->npins = npins;
332 if (gpiobus_alloc_ivars(devi) != 0) {
333 device_printf(child, "cannot allocate device ivars\n");
334 return (EINVAL);
335 }
336 npins = 0;
337 for (i = 0; i < 32; i++) {
338 if ((mask & (1 << i)) == 0)
339 continue;
340 /* Reserve the GPIO pin. */
341 if (gpiobus_acquire_pin(sc->sc_busdev, i) != 0) {
342 gpiobus_free_ivars(devi);
343 return (EINVAL);
344 }
345 devi->pins[npins++] = i;
346 /* Use the child name as pin name. */
347 GPIOBUS_PIN_SETNAME(sc->sc_busdev, i,
348 device_get_nameunit(child));
349 }
350
351 return (0);
352}
353
354static int
355gpiobus_probe(device_t dev)
356{
357 device_set_desc(dev, "GPIO bus");
358
359 return (BUS_PROBE_GENERIC);
360}
361
362static int
363gpiobus_attach(device_t dev)
364{
365 int err;
366
367 err = gpiobus_init_softc(dev);
368 if (err != 0)
369 return (err);
370
371 /*
372 * Get parent's pins and mark them as unmapped
373 */
374 bus_generic_probe(dev);
375 bus_enumerate_hinted_children(dev);
376
377 return (bus_generic_attach(dev));
378}
379
380/*
381 * Since this is not a self-enumerating bus, and since we always add
382 * children in attach, we have to always delete children here.
383 */
384static int
385gpiobus_detach(device_t dev)
386{
387 struct gpiobus_softc *sc;
388 struct gpiobus_ivar *devi;
389 device_t *devlist;
390 int i, err, ndevs;
391
392 sc = GPIOBUS_SOFTC(dev);
393 KASSERT(mtx_initialized(&sc->sc_mtx),
394 ("gpiobus mutex not initialized"));
395 GPIOBUS_LOCK_DESTROY(sc);
396
397 if ((err = bus_generic_detach(dev)) != 0)
398 return (err);
399
400 if ((err = device_get_children(dev, &devlist, &ndevs)) != 0)
401 return (err);
402 for (i = 0; i < ndevs; i++) {
403 devi = GPIOBUS_IVAR(devlist[i]);
404 gpiobus_free_ivars(devi);
405 resource_list_free(&devi->rl);
406 free(devi, M_DEVBUF);
407 device_delete_child(dev, devlist[i]);
408 }
409 free(devlist, M_TEMP);
410 rman_fini(&sc->sc_intr_rman);
411 if (sc->sc_pins) {
412 for (i = 0; i < sc->sc_npins; i++) {
413 if (sc->sc_pins[i].name != NULL)
414 free(sc->sc_pins[i].name, M_DEVBUF);
415 sc->sc_pins[i].name = NULL;
416 }
417 free(sc->sc_pins, M_DEVBUF);
418 sc->sc_pins = NULL;
419 }
420
421 return (0);
422}
423
424static int
425gpiobus_suspend(device_t dev)
426{
427
428 return (bus_generic_suspend(dev));
429}
430
431static int
432gpiobus_resume(device_t dev)
433{
434
435 return (bus_generic_resume(dev));
436}
437
438static void
439gpiobus_probe_nomatch(device_t dev, device_t child)
440{
441 char pins[128];
442 struct gpiobus_ivar *devi;
443
444 devi = GPIOBUS_IVAR(child);
445 memset(pins, 0, sizeof(pins));
446 gpiobus_print_pins(devi, pins, sizeof(pins));
447 if (devi->npins > 1)
448 device_printf(dev, "<unknown device> at pins %s", pins);
449 else
450 device_printf(dev, "<unknown device> at pin %s", pins);
451 resource_list_print_type(&devi->rl, "irq", SYS_RES_IRQ, "%jd");
452 printf("\n");
453}
454
455static int
456gpiobus_print_child(device_t dev, device_t child)
457{
458 char pins[128];
459 int retval = 0;
460 struct gpiobus_ivar *devi;
461
462 devi = GPIOBUS_IVAR(child);
463 memset(pins, 0, sizeof(pins));
464 retval += bus_print_child_header(dev, child);
465 if (devi->npins > 0) {
466 if (devi->npins > 1)
467 retval += printf(" at pins ");
468 else
469 retval += printf(" at pin ");
470 gpiobus_print_pins(devi, pins, sizeof(pins));
471 retval += printf("%s", pins);
472 }
473 resource_list_print_type(&devi->rl, "irq", SYS_RES_IRQ, "%jd");
474 retval += bus_print_child_footer(dev, child);
475
476 return (retval);
477}
478
479static int
480gpiobus_child_location_str(device_t bus, device_t child, char *buf,
481 size_t buflen)
482{
483 struct gpiobus_ivar *devi;
484
485 devi = GPIOBUS_IVAR(child);
486 if (devi->npins > 1)
487 strlcpy(buf, "pins=", buflen);
488 else
489 strlcpy(buf, "pin=", buflen);
490 gpiobus_print_pins(devi, buf, buflen);
491
492 return (0);
493}
494
495static int
496gpiobus_child_pnpinfo_str(device_t bus, device_t child, char *buf,
497 size_t buflen)
498{
499
500 *buf = '\0';
501 return (0);
502}
503
504static device_t
505gpiobus_add_child(device_t dev, u_int order, const char *name, int unit)
506{
507 device_t child;
508 struct gpiobus_ivar *devi;
509
510 child = device_add_child_ordered(dev, order, name, unit);
511 if (child == NULL)
512 return (child);
513 devi = malloc(sizeof(struct gpiobus_ivar), M_DEVBUF, M_NOWAIT | M_ZERO);
514 if (devi == NULL) {
515 device_delete_child(dev, child);
516 return (NULL);
517 }
518 resource_list_init(&devi->rl);
519 device_set_ivars(child, devi);
520
521 return (child);
522}
523
524static void
525gpiobus_hinted_child(device_t bus, const char *dname, int dunit)
526{
527 struct gpiobus_softc *sc = GPIOBUS_SOFTC(bus);
528 struct gpiobus_ivar *devi;
529 device_t child;
530 int irq, pins;
531
532 child = BUS_ADD_CHILD(bus, 0, dname, dunit);
533 devi = GPIOBUS_IVAR(child);
534 resource_int_value(dname, dunit, "pins", &pins);
535 if (gpiobus_parse_pins(sc, child, pins)) {
536 resource_list_free(&devi->rl);
537 free(devi, M_DEVBUF);
538 device_delete_child(bus, child);
539 }
540 if (resource_int_value(dname, dunit, "irq", &irq) == 0) {
541 if (bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1) != 0)
542 device_printf(bus,
543 "warning: bus_set_resource() failed\n");
544 }
545}
546
547static int
548gpiobus_set_resource(device_t dev, device_t child, int type, int rid,
549 rman_res_t start, rman_res_t count)
550{
551 struct gpiobus_ivar *devi;
552 struct resource_list_entry *rle;
553
554 dprintf("%s: entry (%p, %p, %d, %d, %p, %ld)\n",
555 __func__, dev, child, type, rid, (void *)(intptr_t)start, count);
556 devi = GPIOBUS_IVAR(child);
557 rle = resource_list_add(&devi->rl, type, rid, start,
558 start + count - 1, count);
559 if (rle == NULL)
560 return (ENXIO);
561
562 return (0);
563}
564
565static struct resource *
566gpiobus_alloc_resource(device_t bus, device_t child, int type, int *rid,
567 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
568{
569 struct gpiobus_softc *sc;
570 struct resource *rv;
571 struct resource_list *rl;
572 struct resource_list_entry *rle;
573 int isdefault;
574
575 if (type != SYS_RES_IRQ)
576 return (NULL);
577 isdefault = (RMAN_IS_DEFAULT_RANGE(start, end) && count == 1);
578 rle = NULL;
579 if (isdefault) {
580 rl = BUS_GET_RESOURCE_LIST(bus, child);
581 if (rl == NULL)
582 return (NULL);
583 rle = resource_list_find(rl, type, *rid);
584 if (rle == NULL)
585 return (NULL);
586 if (rle->res != NULL)
587 panic("%s: resource entry is busy", __func__);
588 start = rle->start;
589 count = rle->count;
590 end = rle->end;
591 }
592 sc = device_get_softc(bus);
593 rv = rman_reserve_resource(&sc->sc_intr_rman, start, end, count, flags,
594 child);
595 if (rv == NULL)
596 return (NULL);
597 rman_set_rid(rv, *rid);
598 if ((flags & RF_ACTIVE) != 0 &&
599 bus_activate_resource(child, type, *rid, rv) != 0) {
600 rman_release_resource(rv);
601 return (NULL);
602 }
603
604 return (rv);
605}
606
607static int
608gpiobus_release_resource(device_t bus __unused, device_t child, int type,
609 int rid, struct resource *r)
610{
611 int error;
612
613 if (rman_get_flags(r) & RF_ACTIVE) {
614 error = bus_deactivate_resource(child, type, rid, r);
615 if (error)
616 return (error);
617 }
618
619 return (rman_release_resource(r));
620}
621
622static struct resource_list *
623gpiobus_get_resource_list(device_t bus __unused, device_t child)
624{
625 struct gpiobus_ivar *ivar;
626
627 ivar = GPIOBUS_IVAR(child);
628
629 return (&ivar->rl);
630}
631
632static int
633gpiobus_acquire_bus(device_t busdev, device_t child, int how)
634{
635 struct gpiobus_softc *sc;
636
637 sc = device_get_softc(busdev);
638 GPIOBUS_ASSERT_UNLOCKED(sc);
639 GPIOBUS_LOCK(sc);
640 if (sc->sc_owner != NULL) {
641 if (sc->sc_owner == child)
642 panic("%s: %s still owns the bus.",
643 device_get_nameunit(busdev),
644 device_get_nameunit(child));
645 if (how == GPIOBUS_DONTWAIT) {
646 GPIOBUS_UNLOCK(sc);
647 return (EWOULDBLOCK);
648 }
649 while (sc->sc_owner != NULL)
650 mtx_sleep(sc, &sc->sc_mtx, 0, "gpiobuswait", 0);
651 }
652 sc->sc_owner = child;
653 GPIOBUS_UNLOCK(sc);
654
655 return (0);
656}
657
658static void
659gpiobus_release_bus(device_t busdev, device_t child)
660{
661 struct gpiobus_softc *sc;
662
663 sc = device_get_softc(busdev);
664 GPIOBUS_ASSERT_UNLOCKED(sc);
665 GPIOBUS_LOCK(sc);
666 if (sc->sc_owner == NULL)
667 panic("%s: %s releasing unowned bus.",
668 device_get_nameunit(busdev),
669 device_get_nameunit(child));
670 if (sc->sc_owner != child)
671 panic("%s: %s trying to release bus owned by %s",
672 device_get_nameunit(busdev),
673 device_get_nameunit(child),
674 device_get_nameunit(sc->sc_owner));
675 sc->sc_owner = NULL;
676 wakeup(sc);
677 GPIOBUS_UNLOCK(sc);
678}
679
680static int
681gpiobus_pin_setflags(device_t dev, device_t child, uint32_t pin,
682 uint32_t flags)
683{
684 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
685 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
686 uint32_t caps;
687
688 if (pin >= devi->npins)
689 return (EINVAL);
690 if (GPIO_PIN_GETCAPS(sc->sc_dev, devi->pins[pin], &caps) != 0)
691 return (EINVAL);
692 if (gpio_check_flags(caps, flags) != 0)
693 return (EINVAL);
694
695 return (GPIO_PIN_SETFLAGS(sc->sc_dev, devi->pins[pin], flags));
696}
697
698static int
699gpiobus_pin_getflags(device_t dev, device_t child, uint32_t pin,
700 uint32_t *flags)
701{
702 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
703 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
704
705 if (pin >= devi->npins)
706 return (EINVAL);
707
708 return GPIO_PIN_GETFLAGS(sc->sc_dev, devi->pins[pin], flags);
709}
710
711static int
712gpiobus_pin_getcaps(device_t dev, device_t child, uint32_t pin,
713 uint32_t *caps)
714{
715 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
716 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
717
718 if (pin >= devi->npins)
719 return (EINVAL);
720
721 return GPIO_PIN_GETCAPS(sc->sc_dev, devi->pins[pin], caps);
722}
723
724static int
725gpiobus_pin_set(device_t dev, device_t child, uint32_t pin,
726 unsigned int value)
727{
728 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
729 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
730
731 if (pin >= devi->npins)
732 return (EINVAL);
733
734 return GPIO_PIN_SET(sc->sc_dev, devi->pins[pin], value);
735}
736
737static int
738gpiobus_pin_get(device_t dev, device_t child, uint32_t pin,
739 unsigned int *value)
740{
741 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
742 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
743
744 if (pin >= devi->npins)
745 return (EINVAL);
746
747 return GPIO_PIN_GET(sc->sc_dev, devi->pins[pin], value);
748}
749
750static int
751gpiobus_pin_toggle(device_t dev, device_t child, uint32_t pin)
752{
753 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev);
754 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child);
755
756 if (pin >= devi->npins)
757 return (EINVAL);
758
759 return GPIO_PIN_TOGGLE(sc->sc_dev, devi->pins[pin]);
760}
761
762static int
763gpiobus_pin_getname(device_t dev, uint32_t pin, char *name)
764{
765 struct gpiobus_softc *sc;
766
767 sc = GPIOBUS_SOFTC(dev);
768 if (pin > sc->sc_npins)
769 return (EINVAL);
770 /* Did we have a name for this pin ? */
771 if (sc->sc_pins[pin].name != NULL) {
772 memcpy(name, sc->sc_pins[pin].name, GPIOMAXNAME);
773 return (0);
774 }
775
776 /* Return the default pin name. */
777 return (GPIO_PIN_GETNAME(device_get_parent(dev), pin, name));
778}
779
780static int
781gpiobus_pin_setname(device_t dev, uint32_t pin, const char *name)
782{
783 struct gpiobus_softc *sc;
784
785 sc = GPIOBUS_SOFTC(dev);
786 if (pin > sc->sc_npins)
787 return (EINVAL);
788 if (name == NULL)
789 return (EINVAL);
790 /* Save the pin name. */
791 if (sc->sc_pins[pin].name == NULL)
792 sc->sc_pins[pin].name = malloc(GPIOMAXNAME, M_DEVBUF,
793 M_WAITOK | M_ZERO);
794 strlcpy(sc->sc_pins[pin].name, name, GPIOMAXNAME);
795
796 return (0);
797}
798
799static device_method_t gpiobus_methods[] = {
800 /* Device interface */
801 DEVMETHOD(device_probe, gpiobus_probe),
802 DEVMETHOD(device_attach, gpiobus_attach),
803 DEVMETHOD(device_detach, gpiobus_detach),
804 DEVMETHOD(device_shutdown, bus_generic_shutdown),
805 DEVMETHOD(device_suspend, gpiobus_suspend),
806 DEVMETHOD(device_resume, gpiobus_resume),
807
808 /* Bus interface */
809 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
810 DEVMETHOD(bus_config_intr, bus_generic_config_intr),
811 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
812 DEVMETHOD(bus_set_resource, gpiobus_set_resource),
813 DEVMETHOD(bus_alloc_resource, gpiobus_alloc_resource),
814 DEVMETHOD(bus_release_resource, gpiobus_release_resource),
815 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
816 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
817 DEVMETHOD(bus_get_resource_list, gpiobus_get_resource_list),
818 DEVMETHOD(bus_add_child, gpiobus_add_child),
819 DEVMETHOD(bus_probe_nomatch, gpiobus_probe_nomatch),
820 DEVMETHOD(bus_print_child, gpiobus_print_child),
821 DEVMETHOD(bus_child_pnpinfo_str, gpiobus_child_pnpinfo_str),
822 DEVMETHOD(bus_child_location_str, gpiobus_child_location_str),
823 DEVMETHOD(bus_hinted_child, gpiobus_hinted_child),
824
825 /* GPIO protocol */
826 DEVMETHOD(gpiobus_acquire_bus, gpiobus_acquire_bus),
827 DEVMETHOD(gpiobus_release_bus, gpiobus_release_bus),
828 DEVMETHOD(gpiobus_pin_getflags, gpiobus_pin_getflags),
829 DEVMETHOD(gpiobus_pin_getcaps, gpiobus_pin_getcaps),
830 DEVMETHOD(gpiobus_pin_setflags, gpiobus_pin_setflags),
831 DEVMETHOD(gpiobus_pin_get, gpiobus_pin_get),
832 DEVMETHOD(gpiobus_pin_set, gpiobus_pin_set),
833 DEVMETHOD(gpiobus_pin_toggle, gpiobus_pin_toggle),
834 DEVMETHOD(gpiobus_pin_getname, gpiobus_pin_getname),
835 DEVMETHOD(gpiobus_pin_setname, gpiobus_pin_setname),
836
837 DEVMETHOD_END
838};
839
840driver_t gpiobus_driver = {
841 "gpiobus",
842 gpiobus_methods,
843 sizeof(struct gpiobus_softc)
844};
845
846devclass_t gpiobus_devclass;
847
848DRIVER_MODULE(gpiobus, gpio, gpiobus_driver, gpiobus_devclass, 0, 0);
849MODULE_VERSION(gpiobus, 1);
|