elan520.c revision 1.18
1 /* $NetBSD: elan520.c,v 1.18 2007/12/16 00:00:08 dyoung Exp $ */ 2 3 /*- 4 * Copyright (c) 2002 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Device driver for the AMD Elan SC520 System Controller. This attaches 41 * where the "pchb" driver might normally attach, and provides support for 42 * extra features on the SC520, such as the watchdog timer and GPIO. 43 * 44 * Information about the GP bus echo bug work-around is from code posted 45 * to the "soekris-tech" mailing list by Jasper Wallace. 46 */ 47 48 #include <sys/cdefs.h> 49 50 __KERNEL_RCSID(0, "$NetBSD: elan520.c,v 1.18 2007/12/16 00:00:08 dyoung Exp $"); 51 52 #include <sys/param.h> 53 #include <sys/systm.h> 54 #include <sys/device.h> 55 #include <sys/wdog.h> 56 #include <sys/gpio.h> 57 58 #include <uvm/uvm_extern.h> 59 60 #include <machine/bus.h> 61 62 #include <dev/pci/pcivar.h> 63 64 #include <dev/pci/pcidevs.h> 65 66 #include "gpio.h" 67 #if NGPIO > 0 68 #include <dev/gpio/gpiovar.h> 69 #endif 70 71 #include <arch/i386/pci/elan520reg.h> 72 73 #include <dev/sysmon/sysmonvar.h> 74 75 struct elansc_softc { 76 struct device sc_dev; 77 bus_space_tag_t sc_memt; 78 bus_space_handle_t sc_memh; 79 int sc_echobug; 80 81 struct sysmon_wdog sc_smw; 82 #if NGPIO > 0 83 /* GPIO interface */ 84 struct gpio_chipset_tag sc_gpio_gc; 85 gpio_pin_t sc_gpio_pins[ELANSC_PIO_NPINS]; 86 #endif 87 }; 88 89 #if NGPIO > 0 90 static int elansc_gpio_pin_read(void *, int); 91 static void elansc_gpio_pin_write(void *, int, int); 92 static void elansc_gpio_pin_ctl(void *, int, int); 93 #endif 94 95 static void 96 elansc_wdogctl_write(struct elansc_softc *sc, uint16_t val) 97 { 98 int s; 99 uint8_t echo_mode = 0; /* XXX: gcc */ 100 101 s = splhigh(); 102 103 /* Switch off GP bus echo mode if we need to. */ 104 if (sc->sc_echobug) { 105 echo_mode = bus_space_read_1(sc->sc_memt, sc->sc_memh, 106 MMCR_GPECHO); 107 bus_space_write_1(sc->sc_memt, sc->sc_memh, 108 MMCR_GPECHO, echo_mode & ~GPECHO_GP_ECHO_ENB); 109 } 110 111 /* Unlock the register. */ 112 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, 113 WDTMRCTL_UNLOCK1); 114 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, 115 WDTMRCTL_UNLOCK2); 116 117 /* Write the value. */ 118 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, val); 119 120 /* Switch GP bus echo mode back. */ 121 if (sc->sc_echobug) 122 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_GPECHO, 123 echo_mode); 124 125 splx(s); 126 } 127 128 static void 129 elansc_wdogctl_reset(struct elansc_softc *sc) 130 { 131 int s; 132 uint8_t echo_mode = 0/* XXX: gcc */; 133 134 s = splhigh(); 135 136 /* Switch off GP bus echo mode if we need to. */ 137 if (sc->sc_echobug) { 138 echo_mode = bus_space_read_1(sc->sc_memt, sc->sc_memh, 139 MMCR_GPECHO); 140 bus_space_write_1(sc->sc_memt, sc->sc_memh, 141 MMCR_GPECHO, echo_mode & ~GPECHO_GP_ECHO_ENB); 142 } 143 144 /* Reset the watchdog. */ 145 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, 146 WDTMRCTL_RESET1); 147 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, 148 WDTMRCTL_RESET2); 149 150 /* Switch GP bus echo mode back. */ 151 if (sc->sc_echobug) 152 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_GPECHO, 153 echo_mode); 154 155 splx(s); 156 } 157 158 static const struct { 159 int period; /* whole seconds */ 160 uint16_t exp; /* exponent select */ 161 } elansc_wdog_periods[] = { 162 { 1, WDTMRCTL_EXP_SEL25 }, 163 { 2, WDTMRCTL_EXP_SEL26 }, 164 { 4, WDTMRCTL_EXP_SEL27 }, 165 { 8, WDTMRCTL_EXP_SEL28 }, 166 { 16, WDTMRCTL_EXP_SEL29 }, 167 { 32, WDTMRCTL_EXP_SEL30 }, 168 { 0, 0 }, 169 }; 170 171 static int 172 elansc_wdog_setmode(struct sysmon_wdog *smw) 173 { 174 struct elansc_softc *sc = smw->smw_cookie; 175 int i; 176 uint16_t exp_sel = 0; /* XXX: gcc */ 177 178 if (!device_has_power(&sc->sc_dev)) 179 return EBUSY; 180 181 if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) { 182 elansc_wdogctl_write(sc, 183 WDTMRCTL_WRST_ENB | WDTMRCTL_EXP_SEL30); 184 } else { 185 if (smw->smw_period == WDOG_PERIOD_DEFAULT) { 186 smw->smw_period = 32; 187 exp_sel = WDTMRCTL_EXP_SEL30; 188 } else { 189 for (i = 0; elansc_wdog_periods[i].period != 0; i++) { 190 if (elansc_wdog_periods[i].period == 191 smw->smw_period) { 192 exp_sel = elansc_wdog_periods[i].exp; 193 break; 194 } 195 } 196 if (elansc_wdog_periods[i].period == 0) 197 return (EINVAL); 198 } 199 elansc_wdogctl_write(sc, WDTMRCTL_ENB | 200 WDTMRCTL_WRST_ENB | exp_sel); 201 elansc_wdogctl_reset(sc); 202 } 203 return (0); 204 } 205 206 static int 207 elansc_wdog_tickle(struct sysmon_wdog *smw) 208 { 209 struct elansc_softc *sc = smw->smw_cookie; 210 211 if (!device_has_power(&sc->sc_dev)) 212 return EBUSY; 213 214 elansc_wdogctl_reset(sc); 215 return (0); 216 } 217 218 static int 219 elansc_match(struct device *parent, struct cfdata *match, 220 void *aux) 221 { 222 struct pci_attach_args *pa = aux; 223 224 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_AMD && 225 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_AMD_SC520_SC) 226 return (10); /* beat pchb */ 227 228 return (0); 229 } 230 231 static const char *elansc_speeds[] = { 232 "(reserved 00)", 233 "100MHz", 234 "133MHz", 235 "(reserved 11)", 236 }; 237 238 static bool 239 elansc_suspend(device_t dev) 240 { 241 struct elansc_softc *sc = device_private(dev); 242 243 if ((sc->sc_smw.smw_mode & WDOG_MODE_MASK) != WDOG_MODE_DISARMED) { 244 aprint_debug_dev(dev, "watchdog enabled, suspend forbidden"); 245 return false; 246 } 247 return true; 248 } 249 250 static bool 251 elansc_resume(device_t dev) 252 { 253 struct elansc_softc *sc = device_private(dev); 254 255 /* Set up the watchdog registers with some defaults. */ 256 elansc_wdogctl_write(sc, WDTMRCTL_WRST_ENB | WDTMRCTL_EXP_SEL30); 257 258 /* ...and clear it. */ 259 elansc_wdogctl_reset(sc); 260 261 return true; 262 } 263 264 static int 265 elansc_detach(device_t self, int flags) 266 { 267 struct elansc_softc *sc = device_private(self); 268 269 pmf_device_deregister(self); 270 271 sysmon_wdog_unregister(&sc->sc_smw); 272 273 /* Set up the watchdog registers with some defaults. */ 274 elansc_wdogctl_write(sc, WDTMRCTL_WRST_ENB | WDTMRCTL_EXP_SEL30); 275 276 /* ...and clear it. */ 277 elansc_wdogctl_reset(sc); 278 279 bus_space_unmap(sc->sc_memt, sc->sc_memh, PAGE_SIZE); 280 return 0; 281 } 282 283 static void 284 elansc_attach(struct device *parent, struct device *self, void *aux) 285 { 286 struct elansc_softc *sc = device_private(self); 287 struct pci_attach_args *pa = aux; 288 uint16_t rev; 289 uint8_t ressta, cpuctl; 290 #if NGPIO > 0 291 struct gpiobus_attach_args gba; 292 int pin; 293 int reg, shift; 294 uint16_t data; 295 #endif 296 297 aprint_naive(": System Controller\n"); 298 aprint_normal(": AMD Elan SC520 System Controller\n"); 299 300 sc->sc_memt = pa->pa_memt; 301 if (bus_space_map(sc->sc_memt, MMCR_BASE_ADDR, PAGE_SIZE, 0, 302 &sc->sc_memh) != 0) { 303 aprint_error("%s: unable to map registers\n", 304 sc->sc_dev.dv_xname); 305 return; 306 } 307 308 rev = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_REVID); 309 cpuctl = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_CPUCTL); 310 311 aprint_normal("%s: product %d stepping %d.%d, CPU clock %s\n", 312 sc->sc_dev.dv_xname, 313 (rev & REVID_PRODID) >> REVID_PRODID_SHIFT, 314 (rev & REVID_MAJSTEP) >> REVID_MAJSTEP_SHIFT, 315 (rev & REVID_MINSTEP), 316 elansc_speeds[cpuctl & CPUCTL_CPU_CLK_SPD_MASK]); 317 318 /* 319 * SC520 rev A1 has a bug that affects the watchdog timer. If 320 * the GP bus echo mode is enabled, writing to the watchdog control 321 * register is blocked. 322 * 323 * The BIOS in some systems (e.g. the Soekris net4501) enables 324 * GP bus echo for various reasons, so we need to switch it off 325 * when we talk to the watchdog timer. 326 * 327 * XXX The step 1.1 (B1?) in my Soekris net4501 also has this 328 * XXX problem, so we'll just enable it for all Elan SC520s 329 * XXX for now. --thorpej (at) NetBSD.org 330 */ 331 if (1 || rev == ((PRODID_ELAN_SC520 << REVID_PRODID_SHIFT) | 332 (0 << REVID_MAJSTEP_SHIFT) | (1))) 333 sc->sc_echobug = 1; 334 335 /* 336 * Determine cause of the last reset, and issue a warning if it 337 * was due to watchdog expiry. 338 */ 339 ressta = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_RESSTA); 340 if (ressta & RESSTA_WDT_RST_DET) 341 aprint_error( 342 "%s: WARNING: LAST RESET DUE TO WATCHDOG EXPIRATION!\n", 343 sc->sc_dev.dv_xname); 344 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_RESSTA, ressta); 345 346 /* 347 * Hook up the watchdog timer. 348 */ 349 sc->sc_smw.smw_name = sc->sc_dev.dv_xname; 350 sc->sc_smw.smw_cookie = sc; 351 sc->sc_smw.smw_setmode = elansc_wdog_setmode; 352 sc->sc_smw.smw_tickle = elansc_wdog_tickle; 353 sc->sc_smw.smw_period = 32; /* actually 32.54 */ 354 if (sysmon_wdog_register(&sc->sc_smw) != 0) 355 aprint_error("%s: unable to register watchdog with sysmon\n", 356 sc->sc_dev.dv_xname); 357 358 /* Set up the watchdog registers with some defaults. */ 359 elansc_wdogctl_write(sc, WDTMRCTL_WRST_ENB | WDTMRCTL_EXP_SEL30); 360 361 /* ...and clear it. */ 362 elansc_wdogctl_reset(sc); 363 364 pmf_device_register(self, elansc_suspend, elansc_resume); 365 366 #if NGPIO > 0 367 /* Initialize GPIO pins array */ 368 for (pin = 0; pin < ELANSC_PIO_NPINS; pin++) { 369 sc->sc_gpio_pins[pin].pin_num = pin; 370 sc->sc_gpio_pins[pin].pin_caps = GPIO_PIN_INPUT | 371 GPIO_PIN_OUTPUT; 372 373 /* Read initial state */ 374 reg = (pin < 16 ? MMCR_PIODIR15_0 : MMCR_PIODIR31_16); 375 shift = pin % 16; 376 data = bus_space_read_2(sc->sc_memt, sc->sc_memh, reg); 377 if ((data & (1 << shift)) == 0) 378 sc->sc_gpio_pins[pin].pin_flags = GPIO_PIN_INPUT; 379 else 380 sc->sc_gpio_pins[pin].pin_flags = GPIO_PIN_OUTPUT; 381 if (elansc_gpio_pin_read(sc, pin) == 0) 382 sc->sc_gpio_pins[pin].pin_state = GPIO_PIN_LOW; 383 else 384 sc->sc_gpio_pins[pin].pin_state = GPIO_PIN_HIGH; 385 } 386 387 /* Create controller tag */ 388 sc->sc_gpio_gc.gp_cookie = sc; 389 sc->sc_gpio_gc.gp_pin_read = elansc_gpio_pin_read; 390 sc->sc_gpio_gc.gp_pin_write = elansc_gpio_pin_write; 391 sc->sc_gpio_gc.gp_pin_ctl = elansc_gpio_pin_ctl; 392 393 gba.gba_gc = &sc->sc_gpio_gc; 394 gba.gba_pins = sc->sc_gpio_pins; 395 gba.gba_npins = ELANSC_PIO_NPINS; 396 397 /* Attach GPIO framework */ 398 config_found_ia(&sc->sc_dev, "gpiobus", &gba, gpiobus_print); 399 #endif /* NGPIO */ 400 } 401 402 CFATTACH_DECL(elansc, sizeof(struct elansc_softc), 403 elansc_match, elansc_attach, elansc_detach, NULL); 404 405 #if NGPIO > 0 406 static int 407 elansc_gpio_pin_read(void *arg, int pin) 408 { 409 struct elansc_softc *sc = arg; 410 int reg, shift; 411 uint16_t data; 412 413 reg = (pin < 16 ? MMCR_PIODATA15_0 : MMCR_PIODATA31_16); 414 shift = pin % 16; 415 data = bus_space_read_2(sc->sc_memt, sc->sc_memh, reg); 416 417 return ((data >> shift) & 0x1); 418 } 419 420 static void 421 elansc_gpio_pin_write(void *arg, int pin, int value) 422 { 423 struct elansc_softc *sc = arg; 424 int reg, shift; 425 uint16_t data; 426 427 reg = (pin < 16 ? MMCR_PIODATA15_0 : MMCR_PIODATA31_16); 428 shift = pin % 16; 429 data = bus_space_read_2(sc->sc_memt, sc->sc_memh, reg); 430 if (value == 0) 431 data &= ~(1 << shift); 432 else if (value == 1) 433 data |= (1 << shift); 434 435 bus_space_write_2(sc->sc_memt, sc->sc_memh, reg, data); 436 } 437 438 static void 439 elansc_gpio_pin_ctl(void *arg, int pin, int flags) 440 { 441 struct elansc_softc *sc = arg; 442 int reg, shift; 443 uint16_t data; 444 445 reg = (pin < 16 ? MMCR_PIODIR15_0 : MMCR_PIODIR31_16); 446 shift = pin % 16; 447 data = bus_space_read_2(sc->sc_memt, sc->sc_memh, reg); 448 if (flags & GPIO_PIN_INPUT) 449 data &= ~(1 << shift); 450 if (flags & GPIO_PIN_OUTPUT) 451 data |= (1 << shift); 452 453 bus_space_write_2(sc->sc_memt, sc->sc_memh, reg, data); 454 } 455 #endif /* NGPIO */ 456
Indexes created Mon Sep 29 21:09:56 GMT 2025