root/dev/isa/nsclpcsio_isa.c

DEFINITIONS

1. nsread
2. nswrite
3. nsclpcsio_isa_match
4. nsclpcsio_isa_attach
5. nsclpcsio_refresh
6. nsclpcsio_tms_init
7. nsclpcsio_tms_update
8. nsclpcsio_vlm_init
9. nsclpcsio_vlm_update
10. nsclpcsio_gpio_pin_select
11. nsclpcsio_gpio_init
12. nsclpcsio_gpio_pin_read
13. nsclpcsio_gpio_pin_write
14. nsclpcsio_gpio_pin_ctl

    1 /* $OpenBSD: nsclpcsio_isa.c,v 1.12 2007/06/01 21:30:31 cnst Exp $ */
    2 /* $NetBSD: nsclpcsio_isa.c,v 1.5 2002/10/22 16:18:26 drochner Exp $ */
    4 /*
    5  * Copyright (c) 2002 Matthias Drochner.  All rights reserved.
    6  * Copyright (c) 2004 Markus Friedl.  All rights reserved.
    7  * Copyright (c) 2004 Alexander Yurchenko.  All rights reserved.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  * 1. Redistributions of source code must retain the above copyright
   13  *    notice, this list of conditions, and the following disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   28  * SUCH DAMAGE.
   29  */
   31 /*
   32  * National Semiconductor PC87366 LPC Super I/O.
   33  * Supported logical devices: GPIO, TMS, VLM.
   34  */
   36 #include <sys/param.h>
   37 #include <sys/systm.h>
   38 #include <sys/device.h>
   39 #include <sys/gpio.h>
   40 #include <sys/kernel.h>
   41 #include <sys/sensors.h>
   42 #include <sys/timeout.h>
   44 #include <machine/bus.h>
   46 #include <dev/isa/isareg.h>
   47 #include <dev/isa/isavar.h>
   49 #include <dev/gpio/gpiovar.h>
   51 #if defined(NSC_LPC_SIO_DEBUG)
   52 #define DPRINTF(x)              do { printf x; } while (0)
   53 #else
   54 #define DPRINTF(x)
   55 #endif
   57 #define SIO_REG_SID     0x20    /* Super I/O ID */
   58 #define SIO_SID_PC87366 0xE9    /* PC87366 is identified by 0xE9.*/
   60 #define SIO_REG_SRID    0x27    /* Super I/O Revision */
   62 #define SIO_REG_LDN     0x07    /* Logical Device Number */
   63 #define SIO_LDN_FDC     0x00    /* Floppy Disk Controller (FDC) */
   64 #define SIO_LDN_PP      0x01    /* Parallel Port (PP) */
   65 #define SIO_LDN_SP2     0x02    /* Serial Port 2 with IR (SP2) */
   66 #define SIO_LDN_SP1     0x03    /* Serial Port 1 (SP1) */
   67 #define SIO_LDN_SWC     0x04    /* System Wake-Up Control (SWC) */
   68 #define SIO_LDN_KBCM    0x05    /* Mouse Controller (KBC) */
   69 #define SIO_LDN_KBCK    0x06    /* Keyboard Controller (KBC) */
   70 #define SIO_LDN_GPIO    0x07    /* General-Purpose I/O (GPIO) Ports */
   71 #define SIO_LDN_ACB     0x08    /* ACCESS.bus Interface (ACB) */
   72 #define SIO_LDN_FSCM    0x09    /* Fan Speed Control and Monitor (FSCM) */
   73 #define SIO_LDN_WDT     0x0A    /* WATCHDOG Timer (WDT) */
   74 #define SIO_LDN_GMP     0x0B    /* Game Port (GMP) */
   75 #define SIO_LDN_MIDI    0x0C    /* Musical Instrument Digital Interface */
   76 #define SIO_LDN_VLM     0x0D    /* Voltage Level Monitor (VLM) */
   77 #define SIO_LDN_TMS     0x0E    /* Temperature Sensor (TMS) */
   79 #define SIO_REG_ACTIVE  0x30    /* Logical Device Activate Register */
   80 #define SIO_ACTIVE_EN           0x01    /* enabled */
   82 #define SIO_REG_IO_MSB  0x60    /* I/O Port Base, bits 15-8 */
   83 #define SIO_REG_IO_LSB  0x61    /* I/O Port Base, bits 7-0 */
   85 #define SIO_LDNUM       15      /* total number of logical devices */
   87 /* Supported logical devices description */
   88 static const struct {
   89         const char *ld_name;
   90         int ld_num;
   91         int ld_iosize;
   92 } sio_ld[] = {
   93         { "GPIO", SIO_LDN_GPIO, 16 },
   94         { "VLM", SIO_LDN_VLM, 16 },
   95         { "TMS", SIO_LDN_TMS, 16 },
   96 };
   98 /* GPIO */
   99 #define SIO_GPIO_PINSEL 0xf0
  100 #define SIO_GPIO_PINCFG 0xf1
  101 #define SIO_GPIO_PINEV  0xf2
  103 #define SIO_GPIO_CONF_OUTPUTEN  (1 << 0)
  104 #define SIO_GPIO_CONF_PUSHPULL  (1 << 1)
  105 #define SIO_GPIO_CONF_PULLUP    (1 << 2)
  107 #define SIO_GPDO0       0x00
  108 #define SIO_GPDI0       0x01
  109 #define SIO_GPEVEN0     0x02
  110 #define SIO_GPEVST0     0x03
  111 #define SIO_GPDO1       0x04
  112 #define SIO_GPDI1       0x05
  113 #define SIO_GPEVEN1     0x06
  114 #define SIO_GPEVST1     0x07
  115 #define SIO_GPDO2       0x08
  116 #define SIO_GPDI2       0x09
  117 #define SIO_GPDO3       0x0a
  118 #define SIO_GPDI3       0x0b
  120 #define SIO_GPIO_NPINS  29
  122 /* TMS */
  123 #define SIO_TEVSTS      0x00    /* Temperature Event Status */
  124 #define SIO_TEVSMI      0x02    /* Temperature Event to SMI */
  125 #define SIO_TEVIRQ      0x04    /* Temperature Event to IRQ */
  126 #define SIO_TMSCFG      0x08    /* TMS Configuration */
  127 #define SIO_TMSBS       0x09    /* TMS Bank Select */
  128 #define SIO_TCHCFST     0x0A    /* Temperature Channel Config and Status */
  129 #define SIO_RDCHT       0x0B    /* Read Channel Temperature */
  130 #define SIO_CHTH        0x0C    /* Channel Temperature High Limit */
  131 #define SIO_CHTL        0x0D    /* Channel Temperature Low Limit */
  132 #define SIO_CHOTL       0x0E    /* Channel Overtemperature Limit */
  134 /* VLM */
  135 #define SIO_VEVSTS0     0x00    /* Voltage Event Status 0 */
  136 #define SIO_VEVSTS1     0x01    /* Voltage Event Status 1 */
  137 #define SIO_VEVSMI0     0x02    /* Voltage Event to SMI 0 */
  138 #define SIO_VEVSMI1     0x03    /* Voltage Event to SMI 1 */
  139 #define SIO_VEVIRQ0     0x04    /* Voltage Event to IRQ 0 */
  140 #define SIO_VEVIRQ1     0x05    /* Voltage Event to IRQ 1 */
  141 #define SIO_VID         0x06    /* Voltage ID */
  142 #define SIO_VCNVR       0x07    /* Voltage Conversion Rate */
  143 #define SIO_VLMCFG      0x08    /* VLM Configuration */
  144 #define SIO_VLMBS       0x09    /* VLM Bank Select */
  145 #define SIO_VCHCFST     0x0A    /* Voltage Channel Config and Status */
  146 #define SIO_RDCHV       0x0B    /* Read Channel Voltage */
  147 #define SIO_CHVH        0x0C    /* Channel Voltage High Limit */
  148 #define SIO_CHVL        0x0D    /* Channel Voltage Low Limit */
  149 #define SIO_OTSL        0x0E    /* Overtemperature Shutdown Limit */
  151 #define SIO_REG_SIOCF1  0x21
  152 #define SIO_REG_SIOCF2  0x22
  153 #define SIO_REG_SIOCF3  0x23
  154 #define SIO_REG_SIOCF4  0x24
  155 #define SIO_REG_SIOCF5  0x25
  156 #define SIO_REG_SIOCF8  0x28
  157 #define SIO_REG_SIOCFA  0x2A
  158 #define SIO_REG_SIOCFB  0x2B
  159 #define SIO_REG_SIOCFC  0x2C
  160 #define SIO_REG_SIOCFD  0x2D
  162 #define SIO_NUM_SENSORS (3+14)
  163 #define SIO_VLM_OFF     3
  164 #define SIO_VREF        1235    /* 1000.0 * VREF */
  166 struct nsclpcsio_softc {
  167         struct device sc_dev;
bus_space_tag_t sc_iot;
bus_space_handle_t sc_ioh;
bus_space_handle_t sc_ld_ioh[SIO_LDNUM];
  172         int sc_ld_en[SIO_LDNUM];
  174         /* GPIO */
  175         struct gpio_chipset_tag sc_gpio_gc;
  176         struct gpio_pin sc_gpio_pins[SIO_GPIO_NPINS];
  178         /* TMS and VLM */
  179         struct ksensor sensors[SIO_NUM_SENSORS];
  180         struct ksensordev sensordev;
  181 };
  183 #define GPIO_READ(sc, reg) \
bus_space_read_1((sc)->sc_iot,                          \
  185             (sc)->sc_ld_ioh[SIO_LDN_GPIO], (reg))
  186 #define GPIO_WRITE(sc, reg, val) \
bus_space_write_1((sc)->sc_iot,                         \
  188             (sc)->sc_ld_ioh[SIO_LDN_GPIO], (reg), (val))
  189 #define TMS_WRITE(sc, reg, val) \
bus_space_write_1((sc)->sc_iot,                         \
  191             (sc)->sc_ld_ioh[SIO_LDN_TMS], (reg), (val))
  192 #define TMS_READ(sc, reg) \
bus_space_read_1((sc)->sc_iot,                          \
  194             (sc)->sc_ld_ioh[SIO_LDN_TMS], (reg))
  195 #define VLM_WRITE(sc, reg, val) \
bus_space_write_1((sc)->sc_iot,                         \
  197             (sc)->sc_ld_ioh[SIO_LDN_VLM], (reg), (val))
  198 #define VLM_READ(sc, reg) \
bus_space_read_1((sc)->sc_iot,                          \
  200             (sc)->sc_ld_ioh[SIO_LDN_VLM], (reg))
  202 int      nsclpcsio_isa_match(struct device *, void *, void *);
  203 void     nsclpcsio_isa_attach(struct device *, struct device *, void *);
  205 struct cfattach nsclpcsio_isa_ca = {
  206         sizeof(struct nsclpcsio_softc),
nsclpcsio_isa_match,
nsclpcsio_isa_attach
  209 };
  211 struct cfdriver nsclpcsio_cd = {
NULL, "nsclpcsio", DV_DULL
  213 };
  215 struct timeout  nsclpcsio_timeout;
  217 static u_int8_t nsread(bus_space_tag_t, bus_space_handle_t, int);
  218 static void     nswrite(bus_space_tag_t, bus_space_handle_t, int, u_int8_t);
  220 void    nsclpcsio_gpio_init(struct nsclpcsio_softc *);
  221 int     nsclpcsio_gpio_pin_read(void *, int);
  222 void    nsclpcsio_gpio_pin_write(void *, int, int);
  223 void    nsclpcsio_gpio_pin_ctl(void *, int, int);
  225 void    nsclpcsio_tms_init(struct nsclpcsio_softc *);
  226 void    nsclpcsio_vlm_init(struct nsclpcsio_softc *);
  227 void    nsclpcsio_tms_update(struct nsclpcsio_softc *);
  228 void    nsclpcsio_vlm_update(struct nsclpcsio_softc *);
  229 void    nsclpcsio_refresh(void *);
  231 static u_int8_t
nsread(bus_space_tag_t iot, bus_space_handle_t ioh, int idx)
  233 {
bus_space_write_1(iot, ioh, 0, idx);
  235         return (bus_space_read_1(iot, ioh, 1));
  236 }
  238 static void
nswrite(bus_space_tag_t iot, bus_space_handle_t ioh, int idx, u_int8_t data)
  240 {
bus_space_write_1(iot, ioh, 0, idx);
bus_space_write_1(iot, ioh, 1, data);
  243 }
  245 int
nsclpcsio_isa_match(struct device *parent, void *match, void *aux)
  247 {
  248         struct isa_attach_args *ia = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
  251         int iobase;
  252         int rv = 0;
iot = ia->ia_iot;
iobase = ia->ipa_io[0].base;
  256         if (bus_space_map(iot, iobase, 2, 0, &ioh))
  257                 return (0);
  259         if (nsread(iot, ioh, SIO_REG_SID) == SIO_SID_PC87366)
rv = 1;
bus_space_unmap(iot, ioh, 2);
  264         if (rv) {
ia->ipa_nio = 1;
ia->ipa_io[0].length = 2;
ia->ipa_nmem = 0;
ia->ipa_nirq = 0;
ia->ipa_ndrq = 0;
  271         }
  273         return (rv);
  274 }
  276 void
nsclpcsio_isa_attach(struct device *parent, struct device *self, void *aux)
  278 {
  279         struct nsclpcsio_softc *sc = (void *)self;
  280         struct isa_attach_args *ia = aux;
  281         struct gpiobus_attach_args gba;
bus_space_tag_t iot;
  283         int iobase;
  284         int i;
iobase = ia->ipa_io[0].base;
sc->sc_iot = iot = ia->ia_iot;
  288         if (bus_space_map(ia->ia_iot, iobase, 2, 0, &sc->sc_ioh)) {
printf(": can't map i/o space\n");
  290                 return;
  291         }
printf(": NSC PC87366 rev %d:",
nsread(sc->sc_iot, sc->sc_ioh, SIO_REG_SRID));
  295         /* Configure all supported logical devices */
  296         for (i = 0; i < sizeof(sio_ld) / sizeof(sio_ld[0]); i++) {
sc->sc_ld_en[sio_ld[i].ld_num] = 0;
  299                 /* Select the device and check if it's activated */
nswrite(sc->sc_iot, sc->sc_ioh, SIO_REG_LDN, sio_ld[i].ld_num);
  301                 if ((nsread(sc->sc_iot, sc->sc_ioh,
SIO_REG_ACTIVE) & SIO_ACTIVE_EN) == 0)
  303                         continue;
  305                 /* Map I/O space if necessary */
  306                 if (sio_ld[i].ld_iosize != 0) {
iobase = (nsread(sc->sc_iot, sc->sc_ioh,
SIO_REG_IO_MSB) << 8);
iobase |= nsread(sc->sc_iot, sc->sc_ioh,
SIO_REG_IO_LSB);
  311                         if (bus_space_map(sc->sc_iot, iobase,
sio_ld[i].ld_iosize, 0,
  313                             &sc->sc_ld_ioh[sio_ld[i].ld_num]))
  314                                 continue;
  315                 }
sc->sc_ld_en[sio_ld[i].ld_num] = 1;
printf(" %s", sio_ld[i].ld_name);
  319         }
printf("\n");
nsclpcsio_gpio_init(sc);
nsclpcsio_tms_init(sc);
nsclpcsio_vlm_init(sc);
  327         /* Hook into hw.sensors sysctl */
strlcpy(sc->sensordev.xname, sc->sc_dev.dv_xname,
  329             sizeof(sc->sensordev.xname));
  330         for (i = 0; i < SIO_NUM_SENSORS; i++) {
  331                 if (i < SIO_VLM_OFF && !sc->sc_ld_en[SIO_LDN_TMS])
  332                         continue;
  333                 if (i >= SIO_VLM_OFF && !sc->sc_ld_en[SIO_LDN_VLM])
  334                         continue;
sensor_attach(&sc->sensordev, &sc->sensors[i]);
  336         }
sensordev_install(&sc->sensordev);
  338         if (sc->sc_ld_en[SIO_LDN_TMS] || sc->sc_ld_en[SIO_LDN_VLM]) {
timeout_set(&nsclpcsio_timeout, nsclpcsio_refresh, sc);
timeout_add(&nsclpcsio_timeout, (20 * hz) / 10);
  341         }
  343         /* Attach GPIO framework */
  344         if (sc->sc_ld_en[SIO_LDN_GPIO]) {
gba.gba_name = "gpio";
gba.gba_gc = &sc->sc_gpio_gc;
gba.gba_pins = sc->sc_gpio_pins;
gba.gba_npins = SIO_GPIO_NPINS;
config_found(&sc->sc_dev, &gba, NULL);
  350         }
  351 }
  353 void
nsclpcsio_refresh(void *arg)
  355 {
  356         struct nsclpcsio_softc *sc = (struct nsclpcsio_softc *)arg;
  358         if (sc->sc_ld_en[SIO_LDN_TMS])
nsclpcsio_tms_update(sc);
  360         if (sc->sc_ld_en[SIO_LDN_VLM])
nsclpcsio_vlm_update(sc);
timeout_add(&nsclpcsio_timeout, (20 * hz) / 10);
  363 }
  365 void
nsclpcsio_tms_init(struct nsclpcsio_softc *sc)
  367 {
  368         int i;
  370         /* Initialisation, PC87366.pdf, page 208 */
TMS_WRITE(sc, 0x08, 0x00);
TMS_WRITE(sc, 0x09, 0x0f);
TMS_WRITE(sc, 0x0a, 0x08);
TMS_WRITE(sc, 0x0b, 0x04);
TMS_WRITE(sc, 0x0c, 0x35);
TMS_WRITE(sc, 0x0d, 0x05);
TMS_WRITE(sc, 0x0e, 0x05);
TMS_WRITE(sc, SIO_TMSCFG, 0x00);
  381         /* Enable the sensors */
  382         for (i = 0; i < 3; i++) {
TMS_WRITE(sc, SIO_TMSBS, i);
TMS_WRITE(sc, SIO_TCHCFST, 0x01);
sc->sensors[i].type = SENSOR_TEMP;
  387         }
strlcpy(sc->sensors[0].desc, "Remote", sizeof(sc->sensors[0].desc));
strlcpy(sc->sensors[1].desc, "Remote", sizeof(sc->sensors[1].desc));
strlcpy(sc->sensors[2].desc, "Local", sizeof(sc->sensors[2].desc));
nsclpcsio_tms_update(sc);
  394 }
  396 void
nsclpcsio_tms_update(struct nsclpcsio_softc *sc)
  398 {
u_int8_t status;
int8_t sdata;
  401         int i;
  403         for (i = 0; i < 3; i++) {
TMS_WRITE(sc, SIO_TMSBS, i);
status = TMS_READ(sc, SIO_TCHCFST);
  406                 if (!(status & 0x01)) {
DPRINTF(("%s: status %d: disabled\n",
sc->sensors[i].desc, status));
sc->sensors[i].value = 0;
  410                         continue;
  411                 }
sdata = TMS_READ(sc, SIO_RDCHT);
DPRINTF(("%s: status %d C %d\n", sc->sensors[i].desc,
status, sdata));
sc->sensors[i].value = sdata * 1000000 + 273150000;
  416         }
  417 }
  419 void
nsclpcsio_vlm_init(struct nsclpcsio_softc *sc)
  421 {
  422         int i;
  423         char *desc = NULL;
VLM_WRITE(sc, SIO_VLMCFG, 0x00);
  427         /* Enable the sensors */
  428         for (i = 0; i < 14; i++) {
VLM_WRITE(sc, SIO_VLMBS, i);
VLM_WRITE(sc, SIO_VCHCFST, 0x01);
desc = NULL;
  433                 switch (i) {
  434                 case 7:
desc = "VSB";
  436                         break;
  437                 case 8:
desc = "VDD";
  439                         break;
  440                 case 9:
desc = "VBAT";
  442                         break;
  443                 case 10:
desc = "AVDD";
  445                         break;
  446                 case 11:
desc = "TS1";
  448                         break;
  449                 case 12:
desc = "TS2";
  451                         break;
  452                 case 13:
desc = "TS3";
  454                         break;
  455                 }
  456                 /* only init .desc if we have something meaningful to say */
  457                 if (desc != NULL)
strlcpy(sc->sensors[SIO_VLM_OFF + i].desc, desc,
  459                             sizeof(sc->sensors[SIO_VLM_OFF + i].desc));
sc->sensors[SIO_VLM_OFF + i].type = SENSOR_VOLTS_DC;
  462         }
nsclpcsio_vlm_update(sc);
  464 }
  466 void
nsclpcsio_vlm_update(struct nsclpcsio_softc *sc)
  468 {
u_int8_t status;
u_int8_t data;
  471         int scale, rfact, i;
  473         for (i = 0; i < 14; i++) {
VLM_WRITE(sc, SIO_VLMBS, i);
status = VLM_READ(sc, SIO_VCHCFST);
  476                 if (!(status & 0x01)) {
DPRINTF(("%s: status %d: disabled\n",
sc->sensors[SIO_VLM_OFF + i].desc, status));
sc->sensors[SIO_VLM_OFF + i].value = 0;
  480                         continue;
  481                 }
data = VLM_READ(sc, SIO_RDCHV);
DPRINTF(("%s: status %d V %d\n",
sc->sensors[SIO_VLM_OFF + i].desc, status, data));
scale = 1;
  487                 switch (i) {
  488                 case 7:
  489                 case 8:
  490                 case 10:
scale = 2;
  492                 }
  494                 /* Vi = (2.45±0.05)*VREF *RDCHVi / 256 */
rfact = 10 * scale * ((245 * SIO_VREF) >> 8);
sc->sensors[SIO_VLM_OFF + i].value = data * rfact;
  497         }
  498 }
  500 static __inline void
nsclpcsio_gpio_pin_select(struct nsclpcsio_softc *sc, int pin)
  502 {
  503         int port, shift;
u_int8_t data;
port = pin / 8;
shift = pin % 8;
data = (port << 4) | shift;
nswrite(sc->sc_iot, sc->sc_ioh, SIO_REG_LDN, SIO_LDN_GPIO);
nswrite(sc->sc_iot, sc->sc_ioh, SIO_GPIO_PINSEL, data);
  512 }
  514 void
nsclpcsio_gpio_init(struct nsclpcsio_softc *sc)
  516 {
  517         int i;
  519         for (i = 0; i < SIO_GPIO_NPINS; i++) {
sc->sc_gpio_pins[i].pin_num = i;
sc->sc_gpio_pins[i].pin_caps = GPIO_PIN_INPUT |
GPIO_PIN_OUTPUT | GPIO_PIN_OPENDRAIN |
GPIO_PIN_PUSHPULL | GPIO_PIN_TRISTATE |
GPIO_PIN_PULLUP;
  526                 /* Read initial state */
sc->sc_gpio_pins[i].pin_state = nsclpcsio_gpio_pin_read(sc,
i) ? GPIO_PIN_HIGH : GPIO_PIN_LOW;
  529         }
  531         /* Create controller tag */
sc->sc_gpio_gc.gp_cookie = sc;
sc->sc_gpio_gc.gp_pin_read = nsclpcsio_gpio_pin_read;
sc->sc_gpio_gc.gp_pin_write = nsclpcsio_gpio_pin_write;
sc->sc_gpio_gc.gp_pin_ctl = nsclpcsio_gpio_pin_ctl;
  536 }
  538 int
nsclpcsio_gpio_pin_read(void *arg, int pin)
  540 {
  541         struct nsclpcsio_softc *sc = arg;
  542         int port, shift, reg;
u_int8_t data;
port = pin / 8;
shift = pin % 8;
  548         switch (port) {
  549         case 0:
reg = SIO_GPDI0;
  551                 break;
  552         case 1:
reg = SIO_GPDI1;
  554                 break;
  555         case 2:
reg = SIO_GPDI2;
  557                 break;
  558         case 3:
reg = SIO_GPDI3;
  560                 break;
  561         }
data = GPIO_READ(sc, reg);
  565         return ((data >> shift) & 0x1);
  566 }
  568 void
nsclpcsio_gpio_pin_write(void *arg, int pin, int value)
  570 {
  571         struct nsclpcsio_softc *sc = arg;
  572         int port, shift, reg;
u_int8_t data;
port = pin / 8;
shift = pin % 8;
  578         switch (port) {
  579         case 0:
reg = SIO_GPDO0;
  581                 break;
  582         case 1:
reg = SIO_GPDO1;
  584                 break;
  585         case 2:
reg = SIO_GPDO2;
  587                 break;
  588         case 3:
reg = SIO_GPDO3;
  590                 break;
  591         }
data = GPIO_READ(sc, reg);
  594         if (value == 0)
data &= ~(1 << shift);
  596         else if (value == 1)
data |= (1 << shift);
GPIO_WRITE(sc, reg, data);
  600 }
  602 void
nsclpcsio_gpio_pin_ctl(void *arg, int pin, int flags)
  604 {
  605         struct nsclpcsio_softc *sc = arg;
u_int8_t conf = 1;
nswrite(sc->sc_iot, sc->sc_ioh, SIO_REG_LDN, SIO_LDN_GPIO);
nsclpcsio_gpio_pin_select(sc, pin);
conf = nsread(sc->sc_iot, sc->sc_ioh, SIO_GPIO_PINCFG);
conf &= ~(SIO_GPIO_CONF_OUTPUTEN | SIO_GPIO_CONF_PUSHPULL |
SIO_GPIO_CONF_PULLUP);
  614         if ((flags & GPIO_PIN_TRISTATE) == 0)
conf |= SIO_GPIO_CONF_OUTPUTEN;
  616         if (flags & GPIO_PIN_PUSHPULL)
conf |= SIO_GPIO_CONF_PUSHPULL;
  618         if (flags & GPIO_PIN_PULLUP)
conf |= SIO_GPIO_CONF_PULLUP;
nswrite(sc->sc_iot, sc->sc_ioh, SIO_GPIO_PINCFG, conf);
  622 }