sys/dev/superio/superio.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2019 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
  19  * FOR 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  * $FreeBSD$
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/bus.h>
  36 #include <sys/conf.h>
  37 #include <sys/kernel.h>
  38 #include <sys/lock.h>
  39 #include <sys/mutex.h>
  40 #include <sys/malloc.h>
  41 #include <sys/module.h>
  42 #include <sys/proc.h>
  43 #include <sys/rman.h>
  44 #include <sys/time.h>
  45
  46 #include <machine/bus.h>
  47 #include <machine/resource.h>
  48 #include <machine/stdarg.h>
  49
  50 #include <isa/isavar.h>
  51
  52 #include <dev/superio/superio.h>
  53 #include <dev/superio/superio_io.h>
  54
  55 #include "isa_if.h"
  56
  57
  58 typedef void (*sio_conf_enter_f)(struct resource*, uint16_t);
  59 typedef void (*sio_conf_exit_f)(struct resource*, uint16_t);
  60
  61 struct sio_conf_methods {
  62         sio_conf_enter_f        enter;
  63         sio_conf_exit_f         exit;
  64         superio_vendor_t        vendor;
  65 };
  66
  67 struct sio_device {
  68         uint8_t                 ldn;
  69         superio_dev_type_t      type;
  70 };
  71
  72 struct superio_devinfo {
  73         STAILQ_ENTRY(superio_devinfo) link;
  74         struct resource_list    resources;
  75         device_t                dev;
  76         uint8_t                 ldn;
  77         superio_dev_type_t      type;
  78         uint16_t                iobase;
  79         uint16_t                iobase2;
  80         uint8_t                 irq;
  81         uint8_t                 dma;
  82 };
  83
  84 struct siosc {
  85         struct mtx                      conf_lock;
  86         STAILQ_HEAD(, superio_devinfo)  devlist;
  87         struct resource*                io_res;
  88         struct cdev                     *chardev;
  89         int                             io_rid;
  90         uint16_t                        io_port;
  91         const struct sio_conf_methods   *methods;
  92         const struct sio_device         *known_devices;
  93         superio_vendor_t                vendor;
  94         uint16_t                        devid;
  95         uint8_t                         revid;
  96         uint8_t                         current_ldn;
  97         uint8_t                         ldn_reg;
  98         uint8_t                         enable_reg;
  99 };
 100
 101 static  d_ioctl_t       superio_ioctl;
 102
 103 static struct cdevsw superio_cdevsw = {
 104         .d_version =    D_VERSION,
 105         .d_ioctl =      superio_ioctl,
 106         .d_name =       "superio",
 107 };
 108
 109 #define NUMPORTS        2
 110
 111 static uint8_t
 112 sio_read(struct resource* res, uint8_t reg)
 113 {
 114         bus_write_1(res, 0, reg);
 115         return (bus_read_1(res, 1));
 116 }
 117
 118 /* Read a word from two one-byte registers, big endian. */
 119 static uint16_t
 120 sio_readw(struct resource* res, uint8_t reg)
 121 {
 122         uint16_t v;
 123
 124         v = sio_read(res, reg);
 125         v <<= 8;
 126         v |= sio_read(res, reg + 1);
 127         return (v);
 128 }
 129
 130 static void
 131 sio_write(struct resource* res, uint8_t reg, uint8_t val)
 132 {
 133         bus_write_1(res, 0, reg);
 134         bus_write_1(res, 1, val);
 135 }
 136
 137 static void
 138 sio_ldn_select(struct siosc *sc, uint8_t ldn)
 139 {
 140         mtx_assert(&sc->conf_lock, MA_OWNED);
 141         if (ldn == sc->current_ldn)
 142                 return;
 143         sio_write(sc->io_res, sc->ldn_reg, ldn);
 144         sc->current_ldn = ldn;
 145 }
 146
 147 static uint8_t
 148 sio_ldn_read(struct siosc *sc, uint8_t ldn, uint8_t reg)
 149 {
 150         mtx_assert(&sc->conf_lock, MA_OWNED);
 151         if (reg >= sc->enable_reg) {
 152                 sio_ldn_select(sc, ldn);
 153                 KASSERT(sc->current_ldn == ldn, ("sio_ldn_select failed"));
 154         }
 155         return (sio_read(sc->io_res, reg));
 156 }
 157
 158 static uint16_t
 159 sio_ldn_readw(struct siosc *sc, uint8_t ldn, uint8_t reg)
 160 {
 161         mtx_assert(&sc->conf_lock, MA_OWNED);
 162         if (reg >= sc->enable_reg) {
 163                 sio_ldn_select(sc, ldn);
 164                 KASSERT(sc->current_ldn == ldn, ("sio_ldn_select failed"));
 165         }
 166         return (sio_readw(sc->io_res, reg));
 167 }
 168
 169 static void
 170 sio_ldn_write(struct siosc *sc, uint8_t ldn, uint8_t reg, uint8_t val)
 171 {
 172         mtx_assert(&sc->conf_lock, MA_OWNED);
 173         if (reg <= sc->ldn_reg) {
 174                 printf("ignored attempt to write special register 0x%x\n", reg);
 175                 return;
 176         }
 177         sio_ldn_select(sc, ldn);
 178         KASSERT(sc->current_ldn == ldn, ("sio_ldn_select failed"));
 179         sio_write(sc->io_res, reg, val);
 180 }
 181
 182 static void
 183 sio_conf_enter(struct siosc *sc)
 184 {
 185         mtx_lock(&sc->conf_lock);
 186         sc->methods->enter(sc->io_res, sc->io_port);
 187 }
 188
 189 static void
 190 sio_conf_exit(struct siosc *sc)
 191 {
 192         sc->methods->exit(sc->io_res, sc->io_port);
 193         sc->current_ldn = 0xff;
 194         mtx_unlock(&sc->conf_lock);
 195 }
 196
 197 static void
 198 ite_conf_enter(struct resource* res, uint16_t port)
 199 {
 200         bus_write_1(res, 0, 0x87);
 201         bus_write_1(res, 0, 0x01);
 202         bus_write_1(res, 0, 0x55);
 203         bus_write_1(res, 0, port == 0x2e ? 0x55 : 0xaa);
 204 }
 205
 206 static void
 207 ite_conf_exit(struct resource* res, uint16_t port)
 208 {
 209         sio_write(res, 0x02, 0x02);
 210 }
 211
 212 static const struct sio_conf_methods ite_conf_methods = {
 213         .enter = ite_conf_enter,
 214         .exit = ite_conf_exit,
 215         .vendor = SUPERIO_VENDOR_ITE
 216 };
 217
 218 static void
 219 nvt_conf_enter(struct resource* res, uint16_t port)
 220 {
 221         bus_write_1(res, 0, 0x87);
 222         bus_write_1(res, 0, 0x87);
 223 }
 224
 225 static void
 226 nvt_conf_exit(struct resource* res, uint16_t port)
 227 {
 228         bus_write_1(res, 0, 0xaa);
 229 }
 230
 231 static const struct sio_conf_methods nvt_conf_methods = {
 232         .enter = nvt_conf_enter,
 233         .exit = nvt_conf_exit,
 234         .vendor = SUPERIO_VENDOR_NUVOTON
 235 };
 236
 237 static const struct sio_conf_methods * const methods_table[] = {
 238         &ite_conf_methods,
 239         &nvt_conf_methods,
 240         NULL
 241 };
 242
 243 static const uint16_t ports_table[] = {
 244         0x2e, 0x4e, 0
 245 };
 246
 247 const struct sio_device ite_devices[] = {
 248         { .ldn = 4, .type = SUPERIO_DEV_HWM },
 249         { .ldn = 7, .type = SUPERIO_DEV_WDT },
 250         { .type = SUPERIO_DEV_NONE },
 251 };
 252
 253 const struct sio_device nvt_devices[] = {
 254         { .ldn = 8, .type = SUPERIO_DEV_WDT },
 255         { .type = SUPERIO_DEV_NONE },
 256 };
 257
 258 const struct sio_device nct5104_devices[] = {
 259         { .ldn = 7, .type = SUPERIO_DEV_GPIO },
 260         { .ldn = 8, .type = SUPERIO_DEV_WDT },
 261         { .ldn = 15, .type = SUPERIO_DEV_GPIO },
 262         { .type = SUPERIO_DEV_NONE },
 263 };
 264
 265 static const struct {
 266         superio_vendor_t        vendor;
 267         uint16_t                devid;
 268         uint16_t                mask;
 269         const char              *descr;
 270         const struct sio_device *devices;
 271 } superio_table[] = {
 272         {
 273                 .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8712,
 274                 .devices = ite_devices,
 275         },
 276         {
 277                 .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8716,
 278                 .devices = ite_devices,
 279         },
 280         {
 281                 .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8718,
 282                 .devices = ite_devices,
 283         },
 284         {
 285                 .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8720,
 286                 .devices = ite_devices,
 287         },
 288         {
 289                 .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8721,
 290                 .devices = ite_devices,
 291         },
 292         {
 293                 .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8726,
 294                 .devices = ite_devices,
 295         },
 296         {
 297                 .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8728,
 298                 .devices = ite_devices,
 299         },
 300         {
 301                 .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8771,
 302                 .devices = ite_devices,
 303         },
 304         {
 305                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x1061, .mask = 0x00,
 306                 .descr  = "Nuvoton NCT5104D/NCT6102D/NCT6106D (rev. A)",
 307                 .devices = nct5104_devices,
 308         },
 309         {
 310                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x5200, .mask = 0xff,
 311                 .descr = "Winbond 83627HF/F/HG/G",
 312                 .devices = nvt_devices,
 313         },
 314         {
 315                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x5900, .mask = 0xff,
 316                 .descr = "Winbond 83627S",
 317                 .devices = nvt_devices,
 318         },
 319         {
 320                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x6000, .mask = 0xff,
 321                 .descr = "Winbond 83697HF",
 322                 .devices = nvt_devices,
 323         },
 324         {
 325                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x6800, .mask = 0xff,
 326                 .descr = "Winbond 83697UG",
 327                 .devices = nvt_devices,
 328         },
 329         {
 330                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x7000, .mask = 0xff,
 331                 .descr = "Winbond 83637HF",
 332                 .devices = nvt_devices,
 333         },
 334         {
 335                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x8200, .mask = 0xff,
 336                 .descr = "Winbond 83627THF",
 337                 .devices = nvt_devices,
 338         },
 339         {
 340                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x8500, .mask = 0xff,
 341                 .descr = "Winbond 83687THF",
 342                 .devices = nvt_devices,
 343         },
 344         {
 345                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0x8800, .mask = 0xff,
 346                 .descr = "Winbond 83627EHF",
 347                 .devices = nvt_devices,
 348         },
 349         {
 350                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xa000, .mask = 0xff,
 351                 .descr = "Winbond 83627DHG",
 352                 .devices = nvt_devices,
 353         },
 354         {
 355                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xa200, .mask = 0xff,
 356                 .descr = "Winbond 83627UHG",
 357                 .devices = nvt_devices,
 358         },
 359         {
 360                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xa500, .mask = 0xff,
 361                 .descr = "Winbond 83667HG",
 362                 .devices = nvt_devices,
 363         },
 364         {
 365                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xb000, .mask = 0xff,
 366                 .descr = "Winbond 83627DHG-P",
 367                 .devices = nvt_devices,
 368         },
 369         {
 370                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xb300, .mask = 0xff,
 371                 .descr = "Winbond 83667HG-B",
 372                 .devices = nvt_devices,
 373         },
 374         {
 375                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xb400, .mask = 0xff,
 376                 .descr = "Nuvoton NCT6775",
 377                 .devices = nvt_devices,
 378         },
 379         {
 380                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xc300, .mask = 0xff,
 381                 .descr = "Nuvoton NCT6776",
 382                 .devices = nvt_devices,
 383         },
 384         {
 385                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xc400, .mask = 0xff,
 386                 .descr = "Nuvoton NCT5104D/NCT6102D/NCT6106D (rev. B+)",
 387                 .devices = nct5104_devices,
 388         },
 389         {
 390                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xc500, .mask = 0xff,
 391                 .descr = "Nuvoton NCT6779",
 392                 .devices = nvt_devices,
 393         },
 394         {
 395                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xc800, .mask = 0xff,
 396                 .descr = "Nuvoton NCT6791",
 397                 .devices = nvt_devices,
 398         },
 399         {
 400                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xc900, .mask = 0xff,
 401                 .descr = "Nuvoton NCT6792",
 402                 .devices = nvt_devices,
 403         },
 404         {
 405                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xd100, .mask = 0xff,
 406                 .descr = "Nuvoton NCT6793",
 407                 .devices = nvt_devices,
 408         },
 409         {
 410                 .vendor = SUPERIO_VENDOR_NUVOTON, .devid = 0xd300, .mask = 0xff,
 411                 .descr = "Nuvoton NCT6795",
 412                 .devices = nvt_devices,
 413         },
 414         { 0, 0 }
 415 };
 416
 417 static const char *
 418 devtype_to_str(superio_dev_type_t type)
 419 {
 420         switch (type) {
 421         case SUPERIO_DEV_NONE:
 422                 return ("none");
 423         case SUPERIO_DEV_HWM:
 424                 return ("HWM");
 425         case SUPERIO_DEV_WDT:
 426                 return ("WDT");
 427         case SUPERIO_DEV_GPIO:
 428                 return ("GPIO");
 429         case SUPERIO_DEV_MAX:
 430                 return ("invalid");
 431         }
 432         return ("invalid");
 433 }
 434
 435 static int
 436 superio_detect(device_t dev, bool claim, struct siosc *sc)
 437 {
 438         struct resource *res;
 439         rman_res_t port;
 440         rman_res_t count;
 441         uint16_t devid;
 442         uint8_t revid;
 443         int error;
 444         int rid;
 445         int i, m;
 446
 447         error = bus_get_resource(dev, SYS_RES_IOPORT, 0, &port, &count);
 448         if (error != 0)
 449                 return (error);
 450         if (port > UINT16_MAX || count < NUMPORTS) {
 451                 device_printf(dev, "unexpected I/O range size\n");
 452                 return (ENXIO);
 453         }
 454
 455         /*
 456          * Make a temporary resource reservation for hardware probing.
 457          * If we can't get the resources we need then
 458          * we need to abort.  Possibly this indicates
 459          * the resources were used by another device
 460          * in which case the probe would have failed anyhow.
 461          */
 462         rid = 0;
 463         res = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
 464         if (res == NULL) {
 465                 if (claim)
 466                         device_printf(dev, "failed to allocate I/O resource\n");
 467                 return (ENXIO);
 468         }
 469
 470         for (m = 0; methods_table[m] != NULL; m++) {
 471                 methods_table[m]->enter(res, port);
 472                 if (methods_table[m]->vendor == SUPERIO_VENDOR_ITE) {
 473                         devid = sio_readw(res, 0x20);
 474                         revid = sio_read(res, 0x22);
 475                 } else if (methods_table[m]->vendor == SUPERIO_VENDOR_NUVOTON) {
 476                         devid = sio_read(res, 0x20);
 477                         revid = sio_read(res, 0x21);
 478                         devid = (devid << 8) | revid;
 479                 } else {
 480                         continue;
 481                 }
 482                 methods_table[m]->exit(res, port);
 483                 for (i = 0; superio_table[i].vendor != 0; i++) {
 484                         uint16_t mask;
 485
 486                         mask = superio_table[i].mask;
 487                         if (superio_table[i].vendor !=
 488                             methods_table[m]->vendor)
 489                                 continue;
 490                         if ((superio_table[i].devid & ~mask) != (devid & ~mask))
 491                                 continue;
 492                         break;
 493                 }
 494
 495                 /* Found a matching SuperIO entry. */
 496                 if (superio_table[i].vendor != 0)
 497                         break;
 498         }
 499
 500         if (methods_table[m] == NULL)
 501                 error = ENXIO;
 502         else
 503                 error = 0;
 504         if (!claim || error != 0) {
 505                 bus_release_resource(dev, SYS_RES_IOPORT, rid, res);
 506                 return (error);
 507         }
 508
 509         sc->methods = methods_table[m];
 510         sc->vendor = sc->methods->vendor;
 511         sc->known_devices = superio_table[i].devices;
 512         sc->io_res = res;
 513         sc->io_rid = rid;
 514         sc->io_port = port;
 515         sc->devid = devid;
 516         sc->revid = revid;
 517
 518         KASSERT(sc->vendor == SUPERIO_VENDOR_ITE ||
 519             sc->vendor == SUPERIO_VENDOR_NUVOTON,
 520             ("Only ITE and Nuvoton SuperIO-s are supported"));
 521         sc->ldn_reg = 0x07;
 522         sc->enable_reg = 0x30;
 523         sc->current_ldn = 0xff; /* no device should have this */
 524
 525         if (superio_table[i].descr != NULL) {
 526                 device_set_desc(dev, superio_table[i].descr);
 527         } else if (sc->vendor == SUPERIO_VENDOR_ITE) {
 528                 char descr[64];
 529
 530                 snprintf(descr, sizeof(descr),
 531                     "ITE IT%4x SuperIO (revision 0x%02x)",
 532                     sc->devid, sc->revid);
 533                 device_set_desc_copy(dev, descr);
 534         }
 535         return (0);
 536 }
 537
 538 static void
 539 superio_identify(driver_t *driver, device_t parent)
 540 {
 541         device_t        child;
 542         int i;
 543
 544         /*
 545          * Don't create child devices if any already exist.
 546          * Those could be created via isa hints or if this
 547          * driver is loaded, unloaded and then loaded again.
 548          */
 549         if (device_find_child(parent, "superio", -1)) {
 550                 if (bootverbose)
 551                         printf("superio: device(s) already created\n");
 552                 return;
 553         }
 554
 555         /*
 556          * Create a child for each candidate port.
 557          * It would be nice if we could somehow clean up those
 558          * that this driver fails to probe.
 559          */
 560         for (i = 0; ports_table[i] != 0; i++) {
 561                 child = BUS_ADD_CHILD(parent, ISA_ORDER_SPECULATIVE,
 562                     "superio", -1);
 563                 if (child == NULL) {
 564                         device_printf(parent, "failed to add superio child\n");
 565                         continue;
 566                 }
 567                 bus_set_resource(child, SYS_RES_IOPORT, 0, ports_table[i], 2);
 568                 if (superio_detect(child, false, NULL) != 0)
 569                         device_delete_child(parent, child);
 570         }
 571 }
 572
 573 static int
 574 superio_probe(device_t dev)
 575 {
 576         struct siosc *sc;
 577         int error;
 578
 579         /* Make sure we do not claim some ISA PNP device. */
 580         if (isa_get_logicalid(dev) != 0)
 581                 return (ENXIO);
 582
 583         /*
 584          * XXX We can populate the softc now only because we return
 585          * BUS_PROBE_SPECIFIC
 586          */
 587         sc = device_get_softc(dev);
 588         error = superio_detect(dev, true, sc);
 589         if (error != 0)
 590                 return (error);
 591         return (BUS_PROBE_SPECIFIC);
 592 }
 593
 594 static void
 595 superio_add_known_child(device_t dev, superio_dev_type_t type, uint8_t ldn)
 596 {
 597         struct siosc *sc = device_get_softc(dev);
 598         struct superio_devinfo *dinfo;
 599         device_t child;
 600
 601         child = BUS_ADD_CHILD(dev, 0, NULL, -1);
 602         if (child == NULL) {
 603                 device_printf(dev, "failed to add child for ldn %d, type %s\n",
 604                     ldn, devtype_to_str(type));
 605                 return;
 606         }
 607         dinfo = device_get_ivars(child);
 608         dinfo->ldn = ldn;
 609         dinfo->type = type;
 610         sio_conf_enter(sc);
 611         dinfo->iobase = sio_ldn_readw(sc, ldn, 0x60);
 612         dinfo->iobase2 = sio_ldn_readw(sc, ldn, 0x62);
 613         dinfo->irq = sio_ldn_readw(sc, ldn, 0x70);
 614         dinfo->dma = sio_ldn_readw(sc, ldn, 0x74);
 615         sio_conf_exit(sc);
 616         STAILQ_INSERT_TAIL(&sc->devlist, dinfo, link);
 617 }
 618
 619 static int
 620 superio_attach(device_t dev)
 621 {
 622         struct siosc *sc = device_get_softc(dev);
 623         int i;
 624
 625         mtx_init(&sc->conf_lock, device_get_nameunit(dev), "superio", MTX_DEF);
 626         STAILQ_INIT(&sc->devlist);
 627
 628         for (i = 0; sc->known_devices[i].type != SUPERIO_DEV_NONE; i++) {
 629                 superio_add_known_child(dev, sc->known_devices[i].type,
 630                     sc->known_devices[i].ldn);
 631         }
 632
 633         bus_generic_probe(dev);
 634         bus_generic_attach(dev);
 635
 636         sc->chardev = make_dev(&superio_cdevsw, device_get_unit(dev),
 637             UID_ROOT, GID_WHEEL, 0600, "superio%d", device_get_unit(dev));
 638         if (sc->chardev == NULL)
 639                 device_printf(dev, "failed to create character device\n");
 640         else
 641                 sc->chardev->si_drv1 = sc;
 642         return (0);
 643 }
 644
 645 static int
 646 superio_detach(device_t dev)
 647 {
 648         struct siosc *sc = device_get_softc(dev);
 649         int error;
 650
 651         error = bus_generic_detach(dev);
 652         if (error != 0)
 653                 return (error);
 654         if (sc->chardev != NULL)
 655                 destroy_dev(sc->chardev);
 656         device_delete_children(dev);
 657         bus_release_resource(dev, SYS_RES_IOPORT, sc->io_rid, sc->io_res);
 658         mtx_destroy(&sc->conf_lock);
 659         return (0);
 660 }
 661
 662 static device_t
 663 superio_add_child(device_t dev, u_int order, const char *name, int unit)
 664 {
 665         struct superio_devinfo *dinfo;
 666         device_t child;
 667
 668         child = device_add_child_ordered(dev, order, name, unit);
 669         if (child == NULL)
 670                 return (NULL);
 671         dinfo = malloc(sizeof(*dinfo), M_DEVBUF, M_NOWAIT | M_ZERO);
 672         if (dinfo == NULL) {
 673                 device_delete_child(dev, child);
 674                 return (NULL);
 675         }
 676         dinfo->ldn = 0xff;
 677         dinfo->type = SUPERIO_DEV_NONE;
 678         dinfo->dev = child;
 679         resource_list_init(&dinfo->resources);
 680         device_set_ivars(child, dinfo);
 681         return (child);
 682 }
 683
 684 static int
 685 superio_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
 686 {
 687         struct superio_devinfo *dinfo;
 688
 689         dinfo = device_get_ivars(child);
 690         switch (which) {
 691         case SUPERIO_IVAR_LDN:
 692                 *result = dinfo->ldn;
 693                 break;
 694         case SUPERIO_IVAR_TYPE:
 695                 *result = dinfo->type;
 696                 break;
 697         case SUPERIO_IVAR_IOBASE:
 698                 *result = dinfo->iobase;
 699                 break;
 700         case SUPERIO_IVAR_IOBASE2:
 701                 *result = dinfo->iobase2;
 702                 break;
 703         case SUPERIO_IVAR_IRQ:
 704                 *result = dinfo->irq;
 705                 break;
 706         case SUPERIO_IVAR_DMA:
 707                 *result = dinfo->dma;
 708                 break;
 709         default:
 710                 return (ENOENT);
 711         }
 712         return (0);
 713 }
 714
 715 static int
 716 superio_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
 717 {
 718
 719         switch (which) {
 720         case SUPERIO_IVAR_LDN:
 721         case SUPERIO_IVAR_TYPE:
 722         case SUPERIO_IVAR_IOBASE:
 723         case SUPERIO_IVAR_IOBASE2:
 724         case SUPERIO_IVAR_IRQ:
 725         case SUPERIO_IVAR_DMA:
 726                 return (EINVAL);
 727         default:
 728                 return (ENOENT);
 729         }
 730 }
 731
 732 static struct resource_list *
 733 superio_get_resource_list(device_t dev, device_t child)
 734 {
 735         struct superio_devinfo *dinfo = device_get_ivars(child);
 736
 737         return (&dinfo->resources);
 738 }
 739
 740 static int
 741 superio_printf(struct superio_devinfo *dinfo, const char *fmt, ...)
 742 {
 743         va_list ap;
 744         int retval;
 745
 746         retval = printf("superio:%s@ldn%0x2x: ",
 747             devtype_to_str(dinfo->type), dinfo->ldn);
 748         va_start(ap, fmt);
 749         retval += vprintf(fmt, ap);
 750         va_end(ap);
 751         return (retval);
 752 }
 753
 754 static void
 755 superio_child_detached(device_t dev, device_t child)
 756 {
 757         struct superio_devinfo *dinfo;
 758         struct resource_list *rl;
 759
 760         dinfo = device_get_ivars(child);
 761         rl = &dinfo->resources;
 762
 763         if (resource_list_release_active(rl, dev, child, SYS_RES_IRQ) != 0)
 764                 superio_printf(dinfo, "Device leaked IRQ resources\n");
 765         if (resource_list_release_active(rl, dev, child, SYS_RES_MEMORY) != 0)
 766                 superio_printf(dinfo, "Device leaked memory resources\n");
 767         if (resource_list_release_active(rl, dev, child, SYS_RES_IOPORT) != 0)
 768                 superio_printf(dinfo, "Device leaked I/O resources\n");
 769 }
 770
 771 static int
 772 superio_child_location_str(device_t parent, device_t child, char *buf,
 773     size_t buflen)
 774 {
 775         uint8_t ldn;
 776
 777         ldn = superio_get_ldn(child);
 778         snprintf(buf, buflen, "ldn=0x%02x", ldn);
 779         return (0);
 780 }
 781
 782 static int
 783 superio_child_pnp_str(device_t parent, device_t child, char *buf,
 784     size_t buflen)
 785 {
 786         superio_dev_type_t type;
 787
 788         type = superio_get_type(child);
 789         snprintf(buf, buflen, "type=%s", devtype_to_str(type));
 790         return (0);
 791 }
 792
 793 static int
 794 superio_print_child(device_t parent, device_t child)
 795 {
 796         superio_dev_type_t type;
 797         uint8_t ldn;
 798         int retval;
 799
 800         ldn = superio_get_ldn(child);
 801         type = superio_get_type(child);
 802
 803         retval = bus_print_child_header(parent, child);
 804         retval += printf(" at %s ldn 0x%02x", devtype_to_str(type), ldn);
 805         retval += bus_print_child_footer(parent, child);
 806
 807         return (retval);
 808 }
 809
 810 superio_vendor_t
 811 superio_vendor(device_t dev)
 812 {
 813         device_t sio_dev = device_get_parent(dev);
 814         struct siosc *sc = device_get_softc(sio_dev);
 815
 816         return (sc->vendor);
 817 }
 818
 819 uint16_t
 820 superio_devid(device_t dev)
 821 {
 822         device_t sio_dev = device_get_parent(dev);
 823         struct siosc *sc = device_get_softc(sio_dev);
 824
 825         return (sc->devid);
 826 }
 827
 828 uint8_t
 829 superio_revid(device_t dev)
 830 {
 831         device_t sio_dev = device_get_parent(dev);
 832         struct siosc *sc = device_get_softc(sio_dev);
 833
 834         return (sc->revid);
 835 }
 836
 837 uint8_t
 838 superio_read(device_t dev, uint8_t reg)
 839 {
 840         device_t sio_dev = device_get_parent(dev);
 841         struct siosc *sc = device_get_softc(sio_dev);
 842         struct superio_devinfo *dinfo = device_get_ivars(dev);
 843         uint8_t v;
 844
 845         sio_conf_enter(sc);
 846         v = sio_ldn_read(sc, dinfo->ldn, reg);
 847         sio_conf_exit(sc);
 848         return (v);
 849 }
 850
 851 void
 852 superio_write(device_t dev, uint8_t reg, uint8_t val)
 853 {
 854         device_t sio_dev = device_get_parent(dev);
 855         struct siosc *sc = device_get_softc(sio_dev);
 856         struct superio_devinfo *dinfo = device_get_ivars(dev);
 857
 858         sio_conf_enter(sc);
 859         sio_ldn_write(sc, dinfo->ldn, reg, val);
 860         sio_conf_exit(sc);
 861 }
 862
 863 bool
 864 superio_dev_enabled(device_t dev, uint8_t mask)
 865 {
 866         device_t sio_dev = device_get_parent(dev);
 867         struct siosc *sc = device_get_softc(sio_dev);
 868         struct superio_devinfo *dinfo = device_get_ivars(dev);
 869         uint8_t v;
 870
 871         /* GPIO device is always active in ITE chips. */
 872         if (sc->vendor == SUPERIO_VENDOR_ITE && dinfo->ldn == 7)
 873                 return (true);
 874
 875         v = superio_read(dev, sc->enable_reg);
 876         return ((v & mask) != 0);
 877 }
 878
 879 void
 880 superio_dev_enable(device_t dev, uint8_t mask)
 881 {
 882         device_t sio_dev = device_get_parent(dev);
 883         struct siosc *sc = device_get_softc(sio_dev);
 884         struct superio_devinfo *dinfo = device_get_ivars(dev);
 885         uint8_t v;
 886
 887         /* GPIO device is always active in ITE chips. */
 888         if (sc->vendor == SUPERIO_VENDOR_ITE && dinfo->ldn == 7)
 889                 return;
 890
 891         sio_conf_enter(sc);
 892         v = sio_ldn_read(sc, dinfo->ldn, sc->enable_reg);
 893         v |= mask;
 894         sio_ldn_write(sc, dinfo->ldn, sc->enable_reg, v);
 895         sio_conf_exit(sc);
 896 }
 897
 898 void
 899 superio_dev_disable(device_t dev, uint8_t mask)
 900 {
 901         device_t sio_dev = device_get_parent(dev);
 902         struct siosc *sc = device_get_softc(sio_dev);
 903         struct superio_devinfo *dinfo = device_get_ivars(dev);
 904         uint8_t v;
 905
 906         /* GPIO device is always active in ITE chips. */
 907         if (sc->vendor == SUPERIO_VENDOR_ITE && dinfo->ldn == 7)
 908                 return;
 909
 910         sio_conf_enter(sc);
 911         v = sio_ldn_read(sc, dinfo->ldn, sc->enable_reg);
 912         v &= ~mask;
 913         sio_ldn_write(sc, dinfo->ldn, sc->enable_reg, v);
 914         sio_conf_exit(sc);
 915 }
 916
 917 device_t
 918 superio_find_dev(device_t superio, superio_dev_type_t type, int ldn)
 919 {
 920         struct siosc *sc = device_get_softc(superio);
 921         struct superio_devinfo *dinfo;
 922
 923         if (ldn < -1 || ldn > UINT8_MAX)
 924                 return (NULL);          /* ERANGE */
 925         if (type == SUPERIO_DEV_NONE && ldn == -1)
 926                 return (NULL);          /* EINVAL */
 927
 928         STAILQ_FOREACH(dinfo, &sc->devlist, link) {
 929                 if (ldn != -1 && dinfo->ldn != ldn)
 930                         continue;
 931                 if (type != SUPERIO_DEV_NONE && dinfo->type != type)
 932                         continue;
 933                 return (dinfo->dev);
 934         }
 935         return (NULL);
 936 }
 937
 938 static int
 939 superio_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags,
 940     struct thread *td)
 941 {
 942         struct siosc *sc;
 943         struct superiocmd *s;
 944
 945         sc = dev->si_drv1;
 946         s = (struct superiocmd *)data;
 947         switch (cmd) {
 948         case SUPERIO_CR_READ:
 949                 sio_conf_enter(sc);
 950                 s->val = sio_ldn_read(sc, s->ldn, s->cr);
 951                 sio_conf_exit(sc);
 952                 return (0);
 953         case SUPERIO_CR_WRITE:
 954                 sio_conf_enter(sc);
 955                 sio_ldn_write(sc, s->ldn, s->cr, s->val);
 956                 sio_conf_exit(sc);
 957                 return (0);
 958         default:
 959                 return (ENOTTY);
 960         }
 961 }
 962
 963 static devclass_t superio_devclass;
 964
 965 static device_method_t superio_methods[] = {
 966         DEVMETHOD(device_identify,      superio_identify),
 967         DEVMETHOD(device_probe,         superio_probe),
 968         DEVMETHOD(device_attach,        superio_attach),
 969         DEVMETHOD(device_detach,        superio_detach),
 970         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 971         DEVMETHOD(device_suspend,       bus_generic_suspend),
 972         DEVMETHOD(device_resume,        bus_generic_resume),
 973
 974         DEVMETHOD(bus_add_child,        superio_add_child),
 975         DEVMETHOD(bus_child_detached,   superio_child_detached),
 976         DEVMETHOD(bus_child_location_str, superio_child_location_str),
 977         DEVMETHOD(bus_child_pnpinfo_str, superio_child_pnp_str),
 978         DEVMETHOD(bus_print_child,      superio_print_child),
 979         DEVMETHOD(bus_read_ivar,        superio_read_ivar),
 980         DEVMETHOD(bus_write_ivar,       superio_write_ivar),
 981         DEVMETHOD(bus_get_resource_list, superio_get_resource_list),
 982         DEVMETHOD(bus_alloc_resource,   bus_generic_rl_alloc_resource),
 983         DEVMETHOD(bus_release_resource, bus_generic_rl_release_resource),
 984         DEVMETHOD(bus_set_resource,     bus_generic_rl_set_resource),
 985         DEVMETHOD(bus_get_resource,     bus_generic_rl_get_resource),
 986         DEVMETHOD(bus_delete_resource,  bus_generic_rl_delete_resource),
 987         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
 988         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
 989         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
 990         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
 991
 992         DEVMETHOD_END
 993 };
 994
 995 static driver_t superio_driver = {
 996         "superio",
 997         superio_methods,
 998         sizeof(struct siosc)
 999 };
1000
1001 DRIVER_MODULE(superio, isa, superio_driver, superio_devclass, 0, 0);
1002 MODULE_VERSION(superio, 1);