Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/mips/rt305x/rt305x_gpio.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2010-2011, Aleksandr Rybalko <ray@ddteam.net> 3 * Copyright (c) 2009, Oleksandr Tymoshenko <gonzo@FreeBSD.org> 4 * Copyright (c) 2009, Luiz Otavio O Souza. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice unmodified, this list of conditions, and the following 12 * disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /* 31 * GPIO driver for RT305X SoC. 32 */ 33 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD: releng/10.3/sys/mips/rt305x/rt305x_gpio.c 278786 2015-02-14 21:16:19Z loos $"); 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/bus.h> 40 41 #include <sys/kernel.h> 42 #include <sys/module.h> 43 #include <sys/rman.h> 44 #include <sys/lock.h> 45 #include <sys/mutex.h> 46 #include <sys/gpio.h> 47 48 #include <machine/bus.h> 49 #include <machine/resource.h> 50 #include <mips/rt305x/rt305xreg.h> 51 #include <mips/rt305x/rt305x_gpio.h> 52 #include <mips/rt305x/rt305x_gpiovar.h> 53 #include <mips/rt305x/rt305x_sysctlvar.h> 54 55 #include "gpio_if.h" 56 57 #ifdef notyet 58 #define DEFAULT_CAPS (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_INVIN | \ 59 GPIO_PIN_INVOUT | GPIO_PIN_REPORT ) 60 #else 61 #define DEFAULT_CAPS (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_INVIN | \ 62 GPIO_PIN_INVOUT ) 63 #endif 64 65 /* 66 * Helpers 67 */ 68 static void rt305x_gpio_pin_configure(struct rt305x_gpio_softc *sc, 69 struct gpio_pin *pin, uint32_t flags); 70 71 /* 72 * Driver stuff 73 */ 74 static int rt305x_gpio_probe(device_t dev); 75 static int rt305x_gpio_attach(device_t dev); 76 static int rt305x_gpio_detach(device_t dev); 77 static int rt305x_gpio_intr(void *arg); 78 79 int rt305x_get_int_mask (device_t); 80 void rt305x_set_int_mask (device_t, uint32_t); 81 int rt305x_get_int_status(device_t); 82 void rt305x_set_int_status(device_t, uint32_t); 83 84 /* 85 * GPIO interface 86 */ 87 static int rt305x_gpio_pin_max(device_t dev, int *maxpin); 88 static int rt305x_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps); 89 static int rt305x_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t 90 *flags); 91 static int rt305x_gpio_pin_getname(device_t dev, uint32_t pin, char *name); 92 static int rt305x_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags); 93 static int rt305x_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value); 94 static int rt305x_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val); 95 static int rt305x_gpio_pin_toggle(device_t dev, uint32_t pin); 96 97 static void 98 rt305x_gpio_pin_configure(struct rt305x_gpio_softc *sc, struct gpio_pin *pin, 99 unsigned int flags) 100 { 101 GPIO_LOCK(sc); 102 103 /* 104 * Manage input/output 105 */ 106 if (flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) { 107 pin->gp_flags &= ~(GPIO_PIN_INPUT|GPIO_PIN_OUTPUT); 108 if (flags & GPIO_PIN_OUTPUT) { 109 pin->gp_flags |= GPIO_PIN_OUTPUT; 110 GPIO_BIT_SET(sc, pin->gp_pin, DIR); 111 } 112 else { 113 pin->gp_flags |= GPIO_PIN_INPUT; 114 GPIO_BIT_CLR(sc, pin->gp_pin, DIR); 115 } 116 } 117 118 if (flags & GPIO_PIN_INVOUT) { 119 pin->gp_flags |= GPIO_PIN_INVOUT; 120 GPIO_BIT_SET(sc, pin->gp_pin, POL); 121 } 122 else { 123 pin->gp_flags &= ~GPIO_PIN_INVOUT; 124 GPIO_BIT_CLR(sc, pin->gp_pin, POL); 125 } 126 127 if (flags & GPIO_PIN_INVIN) { 128 pin->gp_flags |= GPIO_PIN_INVIN; 129 GPIO_BIT_SET(sc, pin->gp_pin, POL); 130 } 131 else { 132 pin->gp_flags &= ~GPIO_PIN_INVIN; 133 GPIO_BIT_CLR(sc, pin->gp_pin, POL); 134 } 135 136 #ifdef notyet 137 /* Enable interrupt bits for rising/falling transitions */ 138 if (flags & GPIO_PIN_REPORT) { 139 pin->gp_flags |= GPIO_PIN_REPORT; 140 GPIO_BIT_SET(sc, pin->gp_pin, RENA); 141 GPIO_BIT_SET(sc, pin->gp_pin, FENA); 142 device_printf(sc->dev, "Will report interrupt on pin %d\n", 143 pin->gp_pin); 144 145 } 146 else { 147 pin->gp_flags &= ~GPIO_PIN_REPORT; 148 GPIO_BIT_CLR(sc, pin->gp_pin, RENA); 149 GPIO_BIT_CLR(sc, pin->gp_pin, FENA); 150 } 151 #else 152 /* Disable generating interrupts for now */ 153 GPIO_BIT_CLR(sc, pin->gp_pin, RENA); 154 GPIO_BIT_CLR(sc, pin->gp_pin, FENA); 155 #endif 156 157 GPIO_UNLOCK(sc); 158 } 159 160 static int 161 rt305x_gpio_pin_max(device_t dev, int *maxpin) 162 { 163 164 *maxpin = NGPIO - 1; 165 return (0); 166 } 167 168 static int 169 rt305x_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps) 170 { 171 struct rt305x_gpio_softc *sc = device_get_softc(dev); 172 int i; 173 174 for (i = 0; i < sc->gpio_npins; i++) { 175 if (sc->gpio_pins[i].gp_pin == pin) 176 break; 177 } 178 179 if (i >= sc->gpio_npins) 180 return (EINVAL); 181 182 GPIO_LOCK(sc); 183 *caps = sc->gpio_pins[i].gp_caps; 184 GPIO_UNLOCK(sc); 185 186 return (0); 187 } 188 189 static int 190 rt305x_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags) 191 { 192 struct rt305x_gpio_softc *sc = device_get_softc(dev); 193 int i; 194 195 for (i = 0; i < sc->gpio_npins; i++) { 196 if (sc->gpio_pins[i].gp_pin == pin) 197 break; 198 } 199 200 if (i >= sc->gpio_npins) 201 return (EINVAL); 202 203 GPIO_LOCK(sc); 204 *flags = sc->gpio_pins[i].gp_flags; 205 GPIO_UNLOCK(sc); 206 207 return (0); 208 } 209 210 static int 211 rt305x_gpio_pin_getname(device_t dev, uint32_t pin, char *name) 212 { 213 struct rt305x_gpio_softc *sc = device_get_softc(dev); 214 int i; 215 216 for (i = 0; i < sc->gpio_npins; i++) { 217 if (sc->gpio_pins[i].gp_pin == pin) 218 break; 219 } 220 221 if (i >= sc->gpio_npins) 222 return (EINVAL); 223 224 GPIO_LOCK(sc); 225 memcpy(name, sc->gpio_pins[i].gp_name, GPIOMAXNAME); 226 GPIO_UNLOCK(sc); 227 228 return (0); 229 } 230 231 static int 232 rt305x_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags) 233 { 234 int i; 235 struct rt305x_gpio_softc *sc = device_get_softc(dev); 236 237 for (i = 0; i < sc->gpio_npins; i++) { 238 if (sc->gpio_pins[i].gp_pin == pin) 239 break; 240 } 241 242 if (i >= sc->gpio_npins) 243 return (EINVAL); 244 245 rt305x_gpio_pin_configure(sc, &sc->gpio_pins[i], flags); 246 247 return (0); 248 } 249 250 static int 251 rt305x_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value) 252 { 253 struct rt305x_gpio_softc *sc = device_get_softc(dev); 254 int i; 255 256 for (i = 0; i < sc->gpio_npins; i++) { 257 if (sc->gpio_pins[i].gp_pin == pin) 258 break; 259 } 260 261 if (i >= sc->gpio_npins) 262 return (EINVAL); 263 264 265 GPIO_LOCK(sc); 266 if (value) GPIO_BIT_SET(sc, i, DATA); 267 else GPIO_BIT_CLR(sc, i, DATA); 268 GPIO_UNLOCK(sc); 269 270 return (0); 271 } 272 273 static int 274 rt305x_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val) 275 { 276 struct rt305x_gpio_softc *sc = device_get_softc(dev); 277 int i; 278 279 for (i = 0; i < sc->gpio_npins; i++) { 280 if (sc->gpio_pins[i].gp_pin == pin) 281 break; 282 } 283 284 if (i >= sc->gpio_npins) 285 return (EINVAL); 286 287 GPIO_LOCK(sc); 288 *val = GPIO_BIT_GET(sc, i, DATA); 289 GPIO_UNLOCK(sc); 290 291 return (0); 292 } 293 294 static int 295 rt305x_gpio_pin_toggle(device_t dev, uint32_t pin) 296 { 297 int i; 298 struct rt305x_gpio_softc *sc = device_get_softc(dev); 299 300 for (i = 0; i < sc->gpio_npins; i++) { 301 if (sc->gpio_pins[i].gp_pin == pin) 302 break; 303 } 304 305 if (i >= sc->gpio_npins) 306 return (EINVAL); 307 308 GPIO_LOCK(sc); 309 GPIO_BIT_SET(sc, i, TOG); 310 GPIO_UNLOCK(sc); 311 312 return (0); 313 } 314 315 static int 316 rt305x_gpio_intr(void *arg) 317 { 318 struct rt305x_gpio_softc *sc = arg; 319 #ifdef notyet 320 uint32_t i; 321 #endif 322 uint64_t input, value; 323 #ifdef notyet 324 uint64_t reset_pin; 325 char notify[16]; 326 char pinname[6]; 327 #endif 328 329 /* Read all reported pins */ 330 input = GPIO_READ_ALL(sc, INT); 331 /* Clear int status */ 332 GPIO_WRITE_ALL(sc, INT, input); 333 /* Clear report for OUTs */ 334 input &= ~GPIO_READ_ALL(sc, DIR); 335 value = input & GPIO_READ_ALL(sc, DATA); 336 337 if (!input) goto intr_done; 338 339 #ifdef notyet 340 /* if reset_gpio and this pin is input */ 341 if (sc->reset_gpio >= 0 && (input & (1 << sc->reset_gpio))) { 342 /* get reset_gpio pin value */ 343 reset_pin = (value & (1 << sc->reset_gpio))?1:0; 344 if ( sc->reset_gpio_last != reset_pin ) { 345 /* 346 * if now reset is high, check how long 347 * and do reset if less than 2 seconds 348 */ 349 if ( reset_pin && 350 (time_uptime - sc->reset_gpio_ontime) < 2 ) 351 shutdown_nice(0); 352 353 sc->reset_gpio_last = reset_pin; 354 sc->reset_gpio_ontime = time_uptime; 355 } 356 } 357 358 for ( i = 0; i < NGPIO; i ++ ) 359 { 360 /* Next if output pin */ 361 if ( !(( input >> i) & 1) ) continue; 362 363 if ( (((value & input) >> i) & 1) != sc->gpio_pins[i].gp_last ) 364 { 365 /* !system=GPIO subsystem=pin7 type=PIN_HIGH period=3 */ 366 snprintf(notify , sizeof(notify ), "period=%d", 367 (uint32_t)time_uptime - sc->gpio_pins[i].gp_time); 368 snprintf(pinname, sizeof(pinname), "pin%02d", i); 369 devctl_notify("GPIO", pinname, 370 (((value & input) >> i) & 1)?"PIN_HIGH":"PIN_LOW", 371 notify); 372 printf("GPIO[%s] %s %s\n", pinname, 373 (((value & input) >> i) & 1)?"PIN_HIGH":"PIN_LOW", 374 notify); 375 sc->gpio_pins[i].gp_last = ((value & input) >> i) & 1; 376 sc->gpio_pins[i].gp_time = time_uptime; 377 } 378 379 } 380 #endif 381 382 intr_done: 383 return (FILTER_HANDLED); 384 } 385 386 static int 387 rt305x_gpio_probe(device_t dev) 388 { 389 device_set_desc(dev, "RT305X GPIO driver"); 390 return (0); 391 } 392 393 static uint64_t 394 rt305x_gpio_init(device_t dev) 395 { 396 uint64_t avl = ~0ULL; 397 uint32_t gmode = rt305x_sysctl_get(SYSCTL_GPIOMODE); 398 if (!(gmode & SYSCTL_GPIOMODE_RGMII_GPIO_MODE)) 399 avl &= ~RGMII_GPIO_MODE_MASK; 400 if (!(gmode & SYSCTL_GPIOMODE_SDRAM_GPIO_MODE)) 401 avl &= ~SDRAM_GPIO_MODE_MASK; 402 if (!(gmode & SYSCTL_GPIOMODE_MDIO_GPIO_MODE)) 403 avl &= ~MDIO_GPIO_MODE_MASK; 404 if (!(gmode & SYSCTL_GPIOMODE_JTAG_GPIO_MODE)) 405 avl &= ~JTAG_GPIO_MODE_MASK; 406 if (!(gmode & SYSCTL_GPIOMODE_UARTL_GPIO_MODE)) 407 avl &= ~UARTL_GPIO_MODE_MASK; 408 if (!(gmode & SYSCTL_GPIOMODE_SPI_GPIO_MODE)) 409 avl &= ~SPI_GPIO_MODE_MASK; 410 if (!(gmode & SYSCTL_GPIOMODE_I2C_GPIO_MODE)) 411 avl &= ~I2C_GPIO_MODE_MASK; 412 if ((gmode & SYSCTL_GPIOMODE_UARTF_SHARE_MODE_GPIO) != 413 SYSCTL_GPIOMODE_UARTF_SHARE_MODE_GPIO) 414 avl &= ~I2C_GPIO_MODE_MASK; 415 /* D-Link DAP-1350 Board have 416 * MDIO_GPIO_MODE 417 * UARTF_GPIO_MODE 418 * SPI_GPIO_MODE 419 * I2C_GPIO_MODE 420 * So we have 421 * 00000001 10000000 01111111 11111110 422 */ 423 return (avl); 424 425 } 426 427 #define DAP1350_RESET_GPIO 10 428 429 static int 430 rt305x_gpio_attach(device_t dev) 431 { 432 struct rt305x_gpio_softc *sc = device_get_softc(dev); 433 int error = 0, i; 434 uint64_t avlpins = 0; 435 sc->reset_gpio = DAP1350_RESET_GPIO; 436 437 KASSERT((device_get_unit(dev) == 0), 438 ("rt305x_gpio_gpio: Only one gpio module supported")); 439 440 mtx_init(&sc->gpio_mtx, device_get_nameunit(dev), NULL, MTX_DEF); 441 442 /* Map control/status registers. */ 443 sc->gpio_mem_rid = 0; 444 sc->gpio_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 445 &sc->gpio_mem_rid, RF_ACTIVE); 446 447 if (sc->gpio_mem_res == NULL) { 448 device_printf(dev, "couldn't map memory\n"); 449 error = ENXIO; 450 rt305x_gpio_detach(dev); 451 return(error); 452 } 453 454 if ((sc->gpio_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, 455 &sc->gpio_irq_rid, RF_SHAREABLE | RF_ACTIVE)) == NULL) { 456 device_printf(dev, "unable to allocate IRQ resource\n"); 457 return (ENXIO); 458 } 459 460 if ((bus_setup_intr(dev, sc->gpio_irq_res, INTR_TYPE_MISC, 461 /* rt305x_gpio_filter, */ 462 rt305x_gpio_intr, NULL, sc, &sc->gpio_ih))) { 463 device_printf(dev, 464 "WARNING: unable to register interrupt handler\n"); 465 return (ENXIO); 466 } 467 468 sc->dev = dev; 469 avlpins = rt305x_gpio_init(dev); 470 471 /* Configure all pins as input */ 472 /* disable interrupts for all pins */ 473 /* TODO */ 474 475 sc->gpio_npins = NGPIO; 476 resource_int_value(device_get_name(dev), device_get_unit(dev), 477 "pins", &sc->gpio_npins); 478 479 for (i = 0; i < sc->gpio_npins; i++) { 480 sc->gpio_pins[i].gp_pin = i; 481 sc->gpio_pins[i].gp_caps = DEFAULT_CAPS; 482 sc->gpio_pins[i].gp_flags = 0; 483 } 484 485 /* Setup reset pin interrupt */ 486 if (TUNABLE_INT_FETCH("reset_gpio", &sc->reset_gpio)) { 487 device_printf(dev, "\tHinted reset_gpio %d\n", sc->reset_gpio); 488 } 489 #ifdef notyet 490 if (sc->reset_gpio != -1) { 491 rt305x_gpio_pin_setflags(dev, sc->reset_gpio, 492 GPIO_PIN_INPUT|GPIO_PIN_INVOUT| 493 GPIO_PIN_INVOUT|GPIO_PIN_REPORT); 494 device_printf(dev, "\tUse reset_gpio %d\n", sc->reset_gpio); 495 } 496 #else 497 if (sc->reset_gpio != -1) { 498 rt305x_gpio_pin_setflags(dev, sc->reset_gpio, 499 GPIO_PIN_INPUT|GPIO_PIN_INVOUT); 500 device_printf(dev, "\tUse reset_gpio %d\n", sc->reset_gpio); 501 } 502 #endif 503 504 device_add_child(dev, "gpioc", -1); 505 device_add_child(dev, "gpiobus", -1); 506 507 return (bus_generic_attach(dev)); 508 } 509 510 static int 511 rt305x_gpio_detach(device_t dev) 512 { 513 struct rt305x_gpio_softc *sc = device_get_softc(dev); 514 515 KASSERT(mtx_initialized(&sc->gpio_mtx), ("gpio mutex not initialized")); 516 517 bus_generic_detach(dev); 518 519 if (sc->gpio_mem_res) 520 bus_release_resource(dev, SYS_RES_MEMORY, sc->gpio_mem_rid, 521 sc->gpio_mem_res); 522 523 mtx_destroy(&sc->gpio_mtx); 524 525 return(0); 526 } 527 528 #ifdef notyet 529 static struct resource * 530 rt305x_gpio_alloc_resource(device_t bus, device_t child, int type, int *rid, 531 u_long start, u_long end, u_long count, u_int flags) 532 { 533 struct obio_softc *sc = device_get_softc(bus); 534 struct resource *rv; 535 struct rman *rm; 536 537 switch (type) { 538 case SYS_RES_GPIO: 539 rm = &sc->gpio_rman; 540 break; 541 default: 542 printf("%s: unknown resource type %d\n", __func__, type); 543 return (0); 544 } 545 546 rv = rman_reserve_resource(rm, start, end, count, flags, child); 547 if (rv == 0) { 548 printf("%s: could not reserve resource\n", __func__); 549 return (0); 550 } 551 552 rman_set_rid(rv, *rid); 553 554 return (rv); 555 } 556 557 static int 558 rt305x_gpio_activate_resource(device_t bus, device_t child, int type, int rid, 559 struct resource *r) 560 { 561 562 return (rman_activate_resource(r)); 563 } 564 565 static int 566 rt305x_gpio_deactivate_resource(device_t bus, device_t child, int type, int rid, 567 struct resource *r) 568 { 569 570 return (rman_deactivate_resource(r)); 571 } 572 573 static int 574 rt305x_gpio_release_resource(device_t dev, device_t child, int type, 575 int rid, struct resource *r) 576 { 577 rman_release_resource(r); 578 return (0); 579 } 580 #endif 581 582 static device_method_t rt305x_gpio_methods[] = { 583 DEVMETHOD(device_probe, rt305x_gpio_probe), 584 DEVMETHOD(device_attach, rt305x_gpio_attach), 585 DEVMETHOD(device_detach, rt305x_gpio_detach), 586 587 /* GPIO protocol */ 588 DEVMETHOD(gpio_pin_max, rt305x_gpio_pin_max), 589 DEVMETHOD(gpio_pin_getname, rt305x_gpio_pin_getname), 590 DEVMETHOD(gpio_pin_getflags, rt305x_gpio_pin_getflags), 591 DEVMETHOD(gpio_pin_getcaps, rt305x_gpio_pin_getcaps), 592 DEVMETHOD(gpio_pin_setflags, rt305x_gpio_pin_setflags), 593 DEVMETHOD(gpio_pin_get, rt305x_gpio_pin_get), 594 DEVMETHOD(gpio_pin_set, rt305x_gpio_pin_set), 595 DEVMETHOD(gpio_pin_toggle, rt305x_gpio_pin_toggle), 596 {0, 0}, 597 }; 598 599 static driver_t rt305x_gpio_driver = { 600 "gpio", 601 rt305x_gpio_methods, 602 sizeof(struct rt305x_gpio_softc), 603 }; 604 static devclass_t rt305x_gpio_devclass; 605 606 DRIVER_MODULE(rt305x_gpio, obio, rt305x_gpio_driver, 607 rt305x_gpio_devclass, 0, 0);
Cache object: 8bae90a35ead53dec36274d302c5ee97
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]