elan520.c revision 1.27
1 /* $NetBSD: elan520.c,v 1.27 2008/03/26 15:49:03 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.27 2008/03/26 15:49:03 dyoung Exp $"); 51 52 #include <sys/param.h> 53 #include <sys/systm.h> 54 #include <sys/time.h> 55 #include <sys/device.h> 56 #include <sys/gpio.h> 57 #include <sys/mutex.h> 58 #include <sys/wdog.h> 59 60 #include <uvm/uvm_extern.h> 61 62 #include <machine/bus.h> 63 64 #include <dev/pci/pcivar.h> 65 66 #include <dev/pci/pcidevs.h> 67 68 #include "gpio.h" 69 #if NGPIO > 0 70 #include <dev/gpio/gpiovar.h> 71 #endif 72 73 #include <arch/i386/pci/elan520reg.h> 74 75 #include <dev/sysmon/sysmonvar.h> 76 77 #define ELAN_IRQ 1 78 #define PG0_PROT_SIZE PAGE_SIZE 79 80 struct elansc_softc { 81 struct device sc_dev; 82 device_t sc_par; 83 device_t sc_pex; 84 85 pci_chipset_tag_t sc_pc; 86 pcitag_t sc_tag; 87 bus_space_tag_t sc_memt; 88 bus_space_handle_t sc_memh; 89 int sc_echobug; 90 91 kmutex_t sc_mtx; 92 93 struct sysmon_wdog sc_smw; 94 void *sc_eih; 95 void *sc_pih; 96 void *sc_sh; 97 uint8_t sc_mpicmode; 98 uint8_t sc_picicr; 99 int sc_pg0par; 100 int sc_textpar[3]; 101 #if NGPIO > 0 102 /* GPIO interface */ 103 struct gpio_chipset_tag sc_gpio_gc; 104 gpio_pin_t sc_gpio_pins[ELANSC_PIO_NPINS]; 105 #endif 106 }; 107 108 int elansc_wpvnmi = 1; 109 int elansc_pcinmi = 1; 110 int elansc_do_protect_pg0 = 1; 111 112 #if NGPIO > 0 113 static int elansc_gpio_pin_read(void *, int); 114 static void elansc_gpio_pin_write(void *, int, int); 115 static void elansc_gpio_pin_ctl(void *, int, int); 116 #endif 117 118 static void elansc_print_par(device_t, int, uint32_t); 119 static void elanpex_intr_establish(device_t, struct elansc_softc *); 120 static void elanpar_intr_establish(device_t, struct elansc_softc *); 121 static void elanpex_intr_disestablish(struct elansc_softc *); 122 static void elanpar_intr_disestablish(struct elansc_softc *); 123 static bool elanpar_shutdown(device_t, int); 124 static bool elanpex_shutdown(device_t, int); 125 126 static void elansc_protect(struct elansc_softc *, int, paddr_t, uint32_t); 127 128 static void 129 elansc_childdetached(device_t self, device_t child) 130 { 131 struct elansc_softc *sc = device_private(self); 132 133 if (child == sc->sc_par) 134 sc->sc_par = NULL; 135 if (child == sc->sc_pex) 136 sc->sc_pex = NULL; 137 /* elansc does not presently keep a pointer to 138 * the gpio, so there is nothing to do if it is detached. 139 */ 140 } 141 142 static void 143 elansc_wdogctl_write(struct elansc_softc *sc, uint16_t val) 144 { 145 uint8_t echo_mode = 0; /* XXX: gcc */ 146 147 KASSERT(mutex_owned(&sc->sc_mtx)); 148 149 /* Switch off GP bus echo mode if we need to. */ 150 if (sc->sc_echobug) { 151 echo_mode = bus_space_read_1(sc->sc_memt, sc->sc_memh, 152 MMCR_GPECHO); 153 bus_space_write_1(sc->sc_memt, sc->sc_memh, 154 MMCR_GPECHO, echo_mode & ~GPECHO_GP_ECHO_ENB); 155 } 156 157 /* Unlock the register. */ 158 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, 159 WDTMRCTL_UNLOCK1); 160 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, 161 WDTMRCTL_UNLOCK2); 162 163 /* Write the value. */ 164 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, val); 165 166 /* Switch GP bus echo mode back. */ 167 if (sc->sc_echobug) 168 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_GPECHO, 169 echo_mode); 170 } 171 172 static void 173 elansc_wdogctl_reset(struct elansc_softc *sc) 174 { 175 uint8_t echo_mode = 0/* XXX: gcc */; 176 177 KASSERT(mutex_owned(&sc->sc_mtx)); 178 179 /* Switch off GP bus echo mode if we need to. */ 180 if (sc->sc_echobug) { 181 echo_mode = bus_space_read_1(sc->sc_memt, sc->sc_memh, 182 MMCR_GPECHO); 183 bus_space_write_1(sc->sc_memt, sc->sc_memh, 184 MMCR_GPECHO, echo_mode & ~GPECHO_GP_ECHO_ENB); 185 } 186 187 /* Reset the watchdog. */ 188 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, 189 WDTMRCTL_RESET1); 190 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WDTMRCTL, 191 WDTMRCTL_RESET2); 192 193 /* Switch GP bus echo mode back. */ 194 if (sc->sc_echobug) 195 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_GPECHO, 196 echo_mode); 197 } 198 199 static const struct { 200 int period; /* whole seconds */ 201 uint16_t exp; /* exponent select */ 202 } elansc_wdog_periods[] = { 203 { 1, WDTMRCTL_EXP_SEL25 }, 204 { 2, WDTMRCTL_EXP_SEL26 }, 205 { 4, WDTMRCTL_EXP_SEL27 }, 206 { 8, WDTMRCTL_EXP_SEL28 }, 207 { 16, WDTMRCTL_EXP_SEL29 }, 208 { 32, WDTMRCTL_EXP_SEL30 }, 209 { 0, 0 }, 210 }; 211 212 static int 213 elansc_wdog_arm(struct elansc_softc *sc) 214 { 215 struct sysmon_wdog *smw = &sc->sc_smw; 216 int i; 217 uint16_t exp_sel = 0; /* XXX: gcc */ 218 219 KASSERT(mutex_owned(&sc->sc_mtx)); 220 221 if (smw->smw_period == WDOG_PERIOD_DEFAULT) { 222 smw->smw_period = 32; 223 exp_sel = WDTMRCTL_EXP_SEL30; 224 } else { 225 for (i = 0; elansc_wdog_periods[i].period != 0; i++) { 226 if (elansc_wdog_periods[i].period == 227 smw->smw_period) { 228 exp_sel = elansc_wdog_periods[i].exp; 229 break; 230 } 231 } 232 if (elansc_wdog_periods[i].period == 0) 233 return EINVAL; 234 } 235 elansc_wdogctl_write(sc, WDTMRCTL_ENB | 236 WDTMRCTL_WRST_ENB | exp_sel); 237 elansc_wdogctl_reset(sc); 238 return 0; 239 } 240 241 static int 242 elansc_wdog_setmode(struct sysmon_wdog *smw) 243 { 244 struct elansc_softc *sc = smw->smw_cookie; 245 int rc = 0; 246 247 mutex_enter(&sc->sc_mtx); 248 249 if (!device_is_active(&sc->sc_dev)) 250 rc = EBUSY; 251 else if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) { 252 elansc_wdogctl_write(sc, 253 WDTMRCTL_WRST_ENB | WDTMRCTL_EXP_SEL30); 254 } else 255 rc = elansc_wdog_arm(sc); 256 257 mutex_exit(&sc->sc_mtx); 258 return rc; 259 } 260 261 static int 262 elansc_wdog_tickle(struct sysmon_wdog *smw) 263 { 264 struct elansc_softc *sc = smw->smw_cookie; 265 266 mutex_enter(&sc->sc_mtx); 267 elansc_wdogctl_reset(sc); 268 mutex_exit(&sc->sc_mtx); 269 return 0; 270 } 271 272 static int 273 elansc_match(device_t parent, struct cfdata *match, void *aux) 274 { 275 struct pci_attach_args *pa = aux; 276 277 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_AMD && 278 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_AMD_SC520_SC) 279 return (10); /* beat pchb */ 280 281 return (0); 282 } 283 284 static const char *elansc_speeds[] = { 285 "(reserved 00)", 286 "100MHz", 287 "133MHz", 288 "(reserved 11)", 289 }; 290 291 static int 292 elanpar_intr(void *arg) 293 { 294 struct elansc_softc *sc = arg; 295 uint16_t wpvsta; 296 unsigned win; 297 uint32_t par; 298 const char *wpvstr; 299 300 wpvsta = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_WPVSTA); 301 302 if ((wpvsta & MMCR_WPVSTA_WPV_STA) == 0) 303 return 0; 304 305 win = __SHIFTOUT(wpvsta, MMCR_WPVSTA_WPV_WINDOW); 306 307 par = bus_space_read_4(sc->sc_memt, sc->sc_memh, MMCR_PAR(win)); 308 309 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WPVSTA, 310 MMCR_WPVSTA_WPV_STA); 311 312 switch (wpvsta & MMCR_WPVSTA_WPV_MSTR) { 313 case MMCR_WPVSTA_WPV_MSTR_CPU: 314 wpvstr = "cpu"; 315 break; 316 case MMCR_WPVSTA_WPV_MSTR_PCI: 317 wpvstr = "pci"; 318 break; 319 case MMCR_WPVSTA_WPV_MSTR_GP: 320 wpvstr = "gp"; 321 break; 322 default: 323 wpvstr = "unknown"; 324 break; 325 } 326 aprint_error_dev(sc->sc_par, 327 "%s violated write-protect window %u\n", wpvstr, win); 328 elansc_print_par(sc->sc_par, win, par); 329 return 0; 330 } 331 332 static int 333 elanpex_intr(void *arg) 334 { 335 static struct { 336 const char *string; 337 bool nonfatal; 338 } cmd[16] = { 339 [0] = {.string = "not latched"} 340 , [1] = {.string = "special cycle"} 341 , [2] = {.string = "i/o read"} 342 , [3] = {.string = "i/o write"} 343 , [4] = {.string = "4"} 344 , [5] = {.string = "5"} 345 , [6] = {.string = "memory rd"} 346 , [7] = {.string = "memory wr"} 347 , [8] = {.string = "8"} 348 , [9] = {.string = "9"} 349 , [10] = {.string = "cfg rd", .nonfatal = true} 350 , [11] = {.string = "cfg wr"} 351 , [12] = {.string = "memory rd mul"} 352 , [13] = {.string = "dual-address cycle"} 353 , [14] = {.string = "memory rd line"} 354 , [15] = {.string = "memory wr & inv"} 355 }; 356 357 static const struct { 358 uint16_t bit; 359 const char *msg; 360 } mmsg[] = { 361 {MMCR_HBMSTIRQSTA_M_RTRTO_IRQ_STA, "retry timeout"} 362 , {MMCR_HBMSTIRQSTA_M_TABRT_IRQ_STA, "target abort"} 363 , {MMCR_HBMSTIRQSTA_M_MABRT_IRQ_STA, "abort"} 364 , {MMCR_HBMSTIRQSTA_M_SERR_IRQ_STA, "system error"} 365 , {MMCR_HBMSTIRQSTA_M_RPER_IRQ_STA, "received parity error"} 366 , {MMCR_HBMSTIRQSTA_M_DPER_IRQ_STA, "detected parity error"} 367 }, tmsg[] = { 368 {MMCR_HBTGTIRQSTA_T_DLYTO_IRQ_STA, "delayed txn timeout"} 369 , {MMCR_HBTGTIRQSTA_T_APER_IRQ_STA, "address parity"} 370 , {MMCR_HBTGTIRQSTA_T_DPER_IRQ_STA, "data parity"} 371 }; 372 uint8_t pciarbsta; 373 uint16_t mstcmd, mstirq, tgtid, tgtirq; 374 uint32_t mstaddr; 375 uint16_t mstack = 0, tgtack = 0; 376 int fatal = 0, i, handled = 0; 377 struct elansc_softc *sc = arg; 378 379 pciarbsta = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_PCIARBSTA); 380 mstirq = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_HBMSTIRQSTA); 381 mstaddr = bus_space_read_4(sc->sc_memt, sc->sc_memh, MMCR_MSTINTADD); 382 tgtirq = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_HBTGTIRQSTA); 383 384 if ((pciarbsta & MMCR_PCIARBSTA_GNT_TO_STA) != 0) { 385 aprint_error_dev(sc->sc_pex, 386 "grant time-out, GNT%" __PRIuBITS "# asserted\n", 387 __SHIFTOUT(pciarbsta, MMCR_PCIARBSTA_GNT_TO_ID)); 388 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_PCIARBSTA, 389 MMCR_PCIARBSTA_GNT_TO_STA); 390 handled = true; 391 } 392 393 mstcmd = __SHIFTOUT(mstirq, MMCR_HBMSTIRQSTA_M_CMD_IRQ_ID); 394 395 for (i = 0; i < __arraycount(mmsg); i++) { 396 if ((mstirq & mmsg[i].bit) == 0) 397 continue; 398 aprint_error_dev(sc->sc_pex, 399 "%s %08" PRIx32 " master %s\n", 400 cmd[mstcmd].string, mstaddr, mmsg[i].msg); 401 402 mstack |= mmsg[i].bit; 403 if (!cmd[mstcmd].nonfatal) 404 fatal = true; 405 } 406 407 tgtid = __SHIFTOUT(tgtirq, MMCR_HBTGTIRQSTA_T_IRQ_ID); 408 409 for (i = 0; i < __arraycount(tmsg); i++) { 410 if ((tgtirq & tmsg[i].bit) == 0) 411 continue; 412 aprint_error_dev(sc->sc_pex, "%1x target %s\n", tgtid, 413 tmsg[i].msg); 414 tgtack |= tmsg[i].bit; 415 } 416 417 /* acknowledge interrupts */ 418 if (tgtack != 0) { 419 handled = true; 420 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_HBTGTIRQSTA, 421 tgtack); 422 } 423 if (mstack != 0) { 424 handled = true; 425 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_HBMSTIRQSTA, 426 mstack); 427 } 428 return fatal ? 0 : (handled ? 1 : 0); 429 } 430 431 #define elansc_print_1(__dev, __sc, __reg) \ 432 do { \ 433 aprint_debug_dev(__dev, \ 434 "%s: %s %02" PRIx8 "\n", __func__, #__reg, \ 435 bus_space_read_1((__sc)->sc_memt, (__sc)->sc_memh, __reg)); \ 436 } while (/*CONSTCOND*/0) 437 438 static void 439 elansc_print_par(device_t dev, int i, uint32_t par) 440 { 441 uint32_t addr, sz, unit; 442 const char *tgtstr; 443 444 switch (par & MMCR_PAR_TARGET) { 445 default: 446 case MMCR_PAR_TARGET_OFF: 447 tgtstr = "off"; 448 break; 449 case MMCR_PAR_TARGET_GPIO: 450 tgtstr = "gpio"; 451 break; 452 case MMCR_PAR_TARGET_GPMEM: 453 tgtstr = "gpmem"; 454 break; 455 case MMCR_PAR_TARGET_PCI: 456 tgtstr = "pci"; 457 break; 458 case MMCR_PAR_TARGET_BOOTCS: 459 tgtstr = "bootcs"; 460 break; 461 case MMCR_PAR_TARGET_ROMCS1: 462 tgtstr = "romcs1"; 463 break; 464 case MMCR_PAR_TARGET_ROMCS2: 465 tgtstr = "romcs2"; 466 break; 467 case MMCR_PAR_TARGET_SDRAM: 468 tgtstr = "sdram"; 469 break; 470 } 471 if ((par & MMCR_PAR_TARGET) == MMCR_PAR_TARGET_GPIO) { 472 unit = 1; 473 sz = __SHIFTOUT(par, MMCR_PAR_IO_SZ); 474 addr = __SHIFTOUT(par, MMCR_PAR_IO_ST_ADR); 475 } else if ((par & MMCR_PAR_PG_SZ) != 0) { 476 unit = 64 * 1024; 477 sz = __SHIFTOUT(par, MMCR_PAR_64KB_SZ); 478 addr = __SHIFTOUT(par, MMCR_PAR_64KB_ST_ADR); 479 } else { 480 unit = 4 * 1024; 481 sz = __SHIFTOUT(par, MMCR_PAR_4KB_SZ); 482 addr = __SHIFTOUT(par, MMCR_PAR_4KB_ST_ADR); 483 } 484 485 aprint_debug_dev(dev, 486 "PAR[%d] %08" PRIx32 " tgt %s attr %1" __PRIxBITS 487 " start %08" PRIx32 " size %" PRIu32 "\n", 488 i, par, tgtstr, __SHIFTOUT(par, MMCR_PAR_ATTR), 489 addr * unit, (sz + 1) * unit); 490 } 491 492 static void 493 elansc_print_all_par(device_t dev, 494 bus_space_tag_t memt, bus_space_handle_t memh) 495 { 496 int i; 497 uint32_t par; 498 499 for (i = 0; i < 16; i++) { 500 par = bus_space_read_4(memt, memh, MMCR_PAR(i)); 501 elansc_print_par(dev, i, par); 502 } 503 } 504 505 static int 506 elansc_alloc_par(bus_space_tag_t memt, bus_space_handle_t memh) 507 { 508 int i; 509 uint32_t par; 510 511 for (i = 0; i < 16; i++) { 512 513 par = bus_space_read_4(memt, memh, MMCR_PAR(i)); 514 515 if ((par & MMCR_PAR_TARGET) == MMCR_PAR_TARGET_OFF) 516 break; 517 } 518 if (i == 16) 519 return -1; 520 return i; 521 } 522 523 static void 524 elansc_disable_par(bus_space_tag_t memt, bus_space_handle_t memh, int idx) 525 { 526 uint32_t par; 527 par = bus_space_read_4(memt, memh, MMCR_PAR(idx)); 528 par &= ~MMCR_PAR_TARGET; 529 par |= MMCR_PAR_TARGET_OFF; 530 bus_space_write_4(memt, memh, MMCR_PAR(idx), par); 531 } 532 533 struct pareg { 534 paddr_t start; 535 paddr_t end; 536 }; 537 538 static int 539 region_paddr_to_par(struct pareg *region0, struct pareg *regions, uint32_t unit) 540 { 541 struct pareg *residue = regions; 542 paddr_t start, end; 543 paddr_t start0, end0; 544 545 start0 = region0->start; 546 end0 = region0->end; 547 548 if (start0 % unit != 0) 549 start = start0 + unit - start0 % unit; 550 else 551 start = start0; 552 553 end = end0 - end0 % unit; 554 555 if (start >= end) 556 return 0; 557 558 residue->start = start; 559 residue->end = end; 560 residue++; 561 562 if (start0 < start) { 563 residue->start = start0; 564 residue->end = start; 565 residue++; 566 } 567 if (end < end0) { 568 residue->start = end; 569 residue->end = end0; 570 residue++; 571 } 572 return residue - regions; 573 } 574 575 static void 576 elansc_protect_text(device_t self, struct elansc_softc *sc) 577 { 578 int i, j, nregion, pidx, tidx = 0, xnregion; 579 uint32_t par; 580 uint32_t protsize, unprotsize; 581 const uint32_t sfkb = 64 * 1024, fkb = 4 * 1024; 582 paddr_t start_pa, end_pa; 583 extern char kernel_text, etext; 584 bus_space_tag_t memt; 585 bus_space_handle_t memh; 586 struct pareg region0, regions[3], xregions[3]; 587 588 sc->sc_textpar[0] = sc->sc_textpar[1] = sc->sc_textpar[2] = -1; 589 590 memt = sc->sc_memt; 591 memh = sc->sc_memh; 592 593 if (!pmap_extract(pmap_kernel(), (vaddr_t)&kernel_text, 594 ®ion0.start) || 595 !pmap_extract(pmap_kernel(), (vaddr_t)&etext, 596 ®ion0.end)) 597 return; 598 599 if (&etext - &kernel_text != region0.end - region0.start) { 600 aprint_error_dev(self, "kernel text may not be contiguous\n"); 601 return; 602 } 603 604 if ((pidx = elansc_alloc_par(memt, memh)) == -1) { 605 aprint_error_dev(self, "cannot allocate PAR\n"); 606 return; 607 } 608 609 par = bus_space_read_4(memt, memh, MMCR_PAR(pidx)); 610 611 aprint_debug_dev(self, 612 "protect kernel text at physical addresses %p - %p\n", 613 (void *)region0.start, (void *)region0.end); 614 615 nregion = region_paddr_to_par(®ion0, regions, sfkb); 616 if (nregion == 0) { 617 aprint_error_dev(self, "kernel text is unprotected\n"); 618 return; 619 } 620 621 unprotsize = 0; 622 for (i = 1; i < nregion; i++) 623 unprotsize += regions[i].end - regions[i].start; 624 625 start_pa = regions[0].start; 626 end_pa = regions[0].end; 627 628 aprint_debug_dev(self, 629 "actually protect kernel text at physical addresses %p - %p\n", 630 (void *)start_pa, (void *)end_pa); 631 632 aprint_verbose_dev(self, 633 "%" PRIu32 " bytes of kernel text are unprotected\n", unprotsize); 634 635 protsize = end_pa - start_pa; 636 637 #if 0 638 /* set PG_SZ, attribute, target, size, address. */ 639 par = MMCR_PAR_TARGET_SDRAM | MMCR_PAR_ATTR_NOWRITE | MMCR_PAR_PG_SZ; 640 par |= __SHIFTIN(protsize / sfkb - 1, MMCR_PAR_64KB_SZ); 641 par |= __SHIFTIN(start_pa / sfkb, MMCR_PAR_64KB_ST_ADR); 642 bus_space_write_4(memt, memh, MMCR_PAR(pidx), par); 643 #else 644 elansc_protect(sc, pidx, start_pa, protsize); 645 #endif 646 647 sc->sc_textpar[tidx++] = pidx; 648 649 unprotsize = 0; 650 for (i = 1; i < nregion; i++) { 651 xnregion = region_paddr_to_par(®ions[i], xregions, fkb); 652 if (xnregion == 0) { 653 aprint_verbose_dev(self, "skip region %p - %p\n", 654 (void *)regions[i].start, (void *)regions[i].end); 655 continue; 656 } 657 if ((pidx = elansc_alloc_par(memt, memh)) == -1) { 658 unprotsize += regions[i].end - regions[i].start; 659 continue; 660 } 661 elansc_protect(sc, pidx, xregions[0].start, 662 xregions[0].end - xregions[0].start); 663 sc->sc_textpar[tidx++] = pidx; 664 665 aprint_debug_dev(self, 666 "protect add'l kernel text at physical addresses %p - %p\n", 667 (void *)xregions[0].start, (void *)xregions[0].end); 668 669 for (j = 1; j < xnregion; j++) 670 unprotsize += xregions[j].end - xregions[j].start; 671 } 672 aprint_verbose_dev(self, 673 "%" PRIu32 " bytes of kernel text still unprotected\n", unprotsize); 674 675 } 676 677 static void 678 elansc_protect(struct elansc_softc *sc, int pidx, paddr_t addr, uint32_t sz) 679 { 680 const uint32_t sfkb = 64 * 1024, fkb = 4 * 1024; 681 uint32_t addr_field, blksz, par, size_field; 682 683 /* set attribute, target. */ 684 par = MMCR_PAR_TARGET_SDRAM | MMCR_PAR_ATTR_NOWRITE; 685 686 KASSERT(addr % fkb == 0 && sz % fkb == 0); 687 688 if (addr % sfkb == 0 && sz % sfkb == 0) { 689 par |= MMCR_PAR_PG_SZ; 690 691 size_field = MMCR_PAR_64KB_SZ; 692 addr_field = MMCR_PAR_64KB_ST_ADR; 693 blksz = 64 * 1024; 694 } else { 695 size_field = MMCR_PAR_4KB_SZ; 696 addr_field = MMCR_PAR_4KB_ST_ADR; 697 blksz = 4 * 1024; 698 } 699 700 KASSERT(sz / blksz - 1 <= __SHIFTOUT_MASK(size_field)); 701 KASSERT(addr / blksz <= __SHIFTOUT_MASK(addr_field)); 702 703 /* set size and address. */ 704 par |= __SHIFTIN(sz / blksz - 1, size_field); 705 par |= __SHIFTIN(addr / blksz, addr_field); 706 707 bus_space_write_4(sc->sc_memt, sc->sc_memh, MMCR_PAR(pidx), par); 708 } 709 710 static int 711 elansc_protect_pg0(device_t self, struct elansc_softc *sc) 712 { 713 int pidx; 714 const paddr_t pg0_paddr = 0; 715 bus_space_tag_t memt; 716 bus_space_handle_t memh; 717 718 memt = sc->sc_memt; 719 memh = sc->sc_memh; 720 721 if (elansc_do_protect_pg0 == 0) 722 return -1; 723 724 if ((pidx = elansc_alloc_par(memt, memh)) == -1) 725 return -1; 726 727 aprint_debug_dev(self, "protect page 0\n"); 728 729 #if 0 730 /* set PG_SZ, attribute, target, size, address. */ 731 par = MMCR_PAR_TARGET_SDRAM | MMCR_PAR_ATTR_NOWRITE; 732 par |= __SHIFTIN(PG0_PROT_SIZE / PAGE_SIZE - 1, MMCR_PAR_4KB_SZ); 733 par |= __SHIFTIN(pg0_paddr / PAGE_SIZE, MMCR_PAR_4KB_ST_ADR); 734 bus_space_write_4(memt, memh, MMCR_PAR(pidx), par); 735 #else 736 elansc_protect(sc, pidx, pg0_paddr, PG0_PROT_SIZE); 737 #endif 738 return pidx; 739 } 740 741 static void 742 elanpex_intr_ack(bus_space_tag_t memt, bus_space_handle_t memh) 743 { 744 bus_space_write_1(memt, memh, MMCR_PCIARBSTA, 745 MMCR_PCIARBSTA_GNT_TO_STA); 746 bus_space_write_2(memt, memh, MMCR_HBTGTIRQSTA, MMCR_TGTIRQ_ACT); 747 bus_space_write_2(memt, memh, MMCR_HBMSTIRQSTA, MMCR_MSTIRQ_ACT); 748 } 749 750 static bool 751 elansc_suspend(device_t dev PMF_FN_ARGS) 752 { 753 bool rc; 754 struct elansc_softc *sc = device_private(dev); 755 756 mutex_enter(&sc->sc_mtx); 757 rc = ((sc->sc_smw.smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED); 758 mutex_exit(&sc->sc_mtx); 759 if (!rc) 760 aprint_debug_dev(dev, "watchdog enabled, suspend forbidden"); 761 return rc; 762 } 763 764 static bool 765 elansc_resume(device_t dev PMF_FN_ARGS) 766 { 767 struct elansc_softc *sc = device_private(dev); 768 769 mutex_enter(&sc->sc_mtx); 770 /* Set up the watchdog registers with some defaults. */ 771 elansc_wdogctl_write(sc, WDTMRCTL_WRST_ENB | WDTMRCTL_EXP_SEL30); 772 773 /* ...and clear it. */ 774 elansc_wdogctl_reset(sc); 775 mutex_exit(&sc->sc_mtx); 776 777 return true; 778 } 779 780 static int 781 elansc_detach(device_t self, int flags) 782 { 783 int rc; 784 struct elansc_softc *sc = device_private(self); 785 786 if ((rc = config_detach_children(self, flags)) != 0) 787 return rc; 788 789 pmf_device_deregister(self); 790 791 if ((rc = sysmon_wdog_unregister(&sc->sc_smw)) != 0) { 792 if (rc == ERESTART) 793 rc = EINTR; 794 return rc; 795 } 796 797 mutex_enter(&sc->sc_mtx); 798 799 /* Set up the watchdog registers with some defaults. */ 800 elansc_wdogctl_write(sc, WDTMRCTL_WRST_ENB | WDTMRCTL_EXP_SEL30); 801 802 /* ...and clear it. */ 803 elansc_wdogctl_reset(sc); 804 805 bus_space_unmap(sc->sc_memt, sc->sc_memh, PAGE_SIZE); 806 807 mutex_exit(&sc->sc_mtx); 808 mutex_destroy(&sc->sc_mtx); 809 return 0; 810 } 811 812 static void * 813 elansc_intr_establish(device_t dev, int (*handler)(void *), void *arg) 814 { 815 struct pic *pic; 816 void *ih; 817 818 if ((pic = intr_findpic(ELAN_IRQ)) == NULL) { 819 aprint_error_dev(dev, "PIC for irq %d not found\n", 820 ELAN_IRQ); 821 return NULL; 822 } else if ((ih = intr_establish(ELAN_IRQ, pic, ELAN_IRQ, 823 IST_LEVEL, IPL_HIGH, handler, arg)) == NULL) { 824 aprint_error_dev(dev, 825 "could not establish interrupt\n"); 826 return NULL; 827 } 828 aprint_verbose_dev(dev, "interrupting at irq %d\n", ELAN_IRQ); 829 return ih; 830 } 831 832 static bool 833 elanpex_resume(device_t self PMF_FN_ARGS) 834 { 835 struct elansc_softc *sc = device_private(device_parent(self)); 836 837 elanpex_intr_establish(self, sc); 838 return sc->sc_eih != NULL; 839 } 840 841 static bool 842 elanpex_suspend(device_t self PMF_FN_ARGS) 843 { 844 struct elansc_softc *sc = device_private(device_parent(self)); 845 846 elanpex_intr_disestablish(sc); 847 848 return true; 849 } 850 851 static bool 852 elanpar_resume(device_t self PMF_FN_ARGS) 853 { 854 struct elansc_softc *sc = device_private(device_parent(self)); 855 856 elanpar_intr_establish(self, sc); 857 return sc->sc_pih != NULL; 858 } 859 860 static bool 861 elanpar_suspend(device_t self PMF_FN_ARGS) 862 { 863 struct elansc_softc *sc = device_private(device_parent(self)); 864 865 elanpar_intr_disestablish(sc); 866 867 return true; 868 } 869 870 static void 871 elanpex_intr_establish(device_t self, struct elansc_softc *sc) 872 { 873 uint8_t sysarbctl; 874 uint16_t pcihostmap, mstirq, tgtirq; 875 876 pcihostmap = bus_space_read_2(sc->sc_memt, sc->sc_memh, 877 MMCR_PCIHOSTMAP); 878 /* Priority P2 (Master PIC IR1) */ 879 pcihostmap &= ~MMCR_PCIHOSTMAP_PCI_IRQ_MAP; 880 pcihostmap |= __SHIFTIN(__BIT(ELAN_IRQ), MMCR_PCIHOSTMAP_PCI_IRQ_MAP); 881 if (elansc_pcinmi) 882 pcihostmap |= MMCR_PCIHOSTMAP_PCI_NMI_ENB; 883 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_PCIHOSTMAP, 884 pcihostmap); 885 886 elanpex_intr_ack(sc->sc_memt, sc->sc_memh); 887 888 sysarbctl = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_SYSARBCTL); 889 mstirq = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_HBMSTIRQCTL); 890 tgtirq = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_HBTGTIRQCTL); 891 892 sysarbctl |= MMCR_SYSARBCTL_GNT_TO_INT_ENB; 893 894 mstirq |= MMCR_HBMSTIRQCTL_M_RTRTO_IRQ_ENB; 895 mstirq |= MMCR_HBMSTIRQCTL_M_TABRT_IRQ_ENB; 896 mstirq |= MMCR_HBMSTIRQCTL_M_MABRT_IRQ_ENB; 897 mstirq |= MMCR_HBMSTIRQCTL_M_SERR_IRQ_ENB; 898 mstirq |= MMCR_HBMSTIRQCTL_M_RPER_IRQ_ENB; 899 mstirq |= MMCR_HBMSTIRQCTL_M_DPER_IRQ_ENB; 900 901 tgtirq |= MMCR_HBTGTIRQCTL_T_DLYTO_IRQ_ENB; 902 tgtirq |= MMCR_HBTGTIRQCTL_T_APER_IRQ_ENB; 903 tgtirq |= MMCR_HBTGTIRQCTL_T_DPER_IRQ_ENB; 904 905 if (elansc_pcinmi) { 906 sc->sc_eih = nmi_establish(elanpex_intr, sc); 907 908 mstirq |= MMCR_HBMSTIRQCTL_M_RTRTO_IRQ_SEL; 909 mstirq |= MMCR_HBMSTIRQCTL_M_TABRT_IRQ_SEL; 910 mstirq |= MMCR_HBMSTIRQCTL_M_MABRT_IRQ_SEL; 911 mstirq |= MMCR_HBMSTIRQCTL_M_SERR_IRQ_SEL; 912 mstirq |= MMCR_HBMSTIRQCTL_M_RPER_IRQ_SEL; 913 mstirq |= MMCR_HBMSTIRQCTL_M_DPER_IRQ_SEL; 914 915 tgtirq |= MMCR_HBTGTIRQCTL_T_DLYTO_IRQ_SEL; 916 tgtirq |= MMCR_HBTGTIRQCTL_T_APER_IRQ_SEL; 917 tgtirq |= MMCR_HBTGTIRQCTL_T_DPER_IRQ_SEL; 918 } else 919 sc->sc_eih = elansc_intr_establish(self, elanpex_intr, sc); 920 921 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_SYSARBCTL, sysarbctl); 922 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_HBMSTIRQCTL, mstirq); 923 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_HBTGTIRQCTL, tgtirq); 924 } 925 926 static void 927 elanpex_attach(device_t parent, device_t self, void *aux) 928 { 929 struct elansc_softc *sc = device_private(parent); 930 931 aprint_naive(": PCI Exceptions\n"); 932 aprint_normal(": AMD Elan SC520 PCI Exceptions\n"); 933 934 elanpex_intr_establish(self, sc); 935 936 aprint_debug_dev(self, "HBMSTIRQCTL %04x\n", 937 bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_HBMSTIRQCTL)); 938 939 aprint_debug_dev(self, "HBTGTIRQCTL %04x\n", 940 bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_HBTGTIRQCTL)); 941 942 aprint_debug_dev(self, "PCIHOSTMAP %04x\n", 943 bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_PCIHOSTMAP)); 944 945 pci_conf_write(sc->sc_pc, sc->sc_tag, PCI_COMMAND_STATUS_REG, 946 pci_conf_read(sc->sc_pc, sc->sc_tag, PCI_COMMAND_STATUS_REG) | 947 PCI_COMMAND_PARITY_ENABLE|PCI_COMMAND_SERR_ENABLE); 948 949 if (!pmf_device_register1(self, elanpex_suspend, elanpex_resume, 950 elanpex_shutdown)) 951 aprint_error_dev(self, "could not establish power hooks\n"); 952 } 953 954 static bool 955 elanpex_shutdown(device_t self, int flags) 956 { 957 struct elansc_softc *sc = device_private(device_parent(self)); 958 uint8_t sysarbctl; 959 uint16_t pcihostmap, mstirq, tgtirq; 960 961 sysarbctl = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_SYSARBCTL); 962 sysarbctl &= ~MMCR_SYSARBCTL_GNT_TO_INT_ENB; 963 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_SYSARBCTL, sysarbctl); 964 965 mstirq = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_HBMSTIRQCTL); 966 mstirq &= ~MMCR_HBMSTIRQCTL_M_RTRTO_IRQ_ENB; 967 mstirq &= ~MMCR_HBMSTIRQCTL_M_TABRT_IRQ_ENB; 968 mstirq &= ~MMCR_HBMSTIRQCTL_M_MABRT_IRQ_ENB; 969 mstirq &= ~MMCR_HBMSTIRQCTL_M_SERR_IRQ_ENB; 970 mstirq &= ~MMCR_HBMSTIRQCTL_M_RPER_IRQ_ENB; 971 mstirq &= ~MMCR_HBMSTIRQCTL_M_DPER_IRQ_ENB; 972 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_HBMSTIRQCTL, mstirq); 973 974 tgtirq = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_HBTGTIRQCTL); 975 tgtirq &= ~MMCR_HBTGTIRQCTL_T_DLYTO_IRQ_ENB; 976 tgtirq &= ~MMCR_HBTGTIRQCTL_T_APER_IRQ_ENB; 977 tgtirq &= ~MMCR_HBTGTIRQCTL_T_DPER_IRQ_ENB; 978 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_HBTGTIRQCTL, tgtirq); 979 980 pcihostmap = bus_space_read_2(sc->sc_memt, sc->sc_memh, 981 MMCR_PCIHOSTMAP); 982 /* Priority P2 (Master PIC IR1) */ 983 pcihostmap &= ~MMCR_PCIHOSTMAP_PCI_IRQ_MAP; 984 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_PCIHOSTMAP, 985 pcihostmap); 986 987 return true; 988 } 989 990 static void 991 elanpex_intr_disestablish(struct elansc_softc *sc) 992 { 993 elanpex_shutdown(sc->sc_pex, 0); 994 995 if (elansc_pcinmi) 996 nmi_disestablish(sc->sc_eih); 997 else 998 intr_disestablish(sc->sc_eih); 999 sc->sc_eih = NULL; 1000 1001 } 1002 1003 static int 1004 elanpex_detach(device_t self, int flags) 1005 { 1006 struct elansc_softc *sc = device_private(device_parent(self)); 1007 1008 pmf_device_deregister(self); 1009 elanpex_intr_disestablish(sc); 1010 1011 return 0; 1012 } 1013 1014 static void 1015 elanpar_intr_establish(device_t self, struct elansc_softc *sc) 1016 { 1017 uint8_t adddecctl, wpvmap; 1018 1019 wpvmap = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_WPVMAP); 1020 wpvmap &= ~MMCR_WPVMAP_INT_MAP; 1021 if (elansc_wpvnmi) 1022 wpvmap |= MMCR_WPVMAP_INT_NMI; 1023 else 1024 wpvmap |= __SHIFTIN(__BIT(ELAN_IRQ), MMCR_WPVMAP_INT_MAP); 1025 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_WPVMAP, wpvmap); 1026 1027 /* clear interrupt status */ 1028 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WPVSTA, 1029 MMCR_WPVSTA_WPV_STA); 1030 1031 /* establish interrupt */ 1032 if (elansc_wpvnmi) 1033 sc->sc_pih = nmi_establish(elanpar_intr, sc); 1034 else 1035 sc->sc_pih = elansc_intr_establish(self, elanpar_intr, sc); 1036 1037 adddecctl = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_ADDDECCTL); 1038 adddecctl |= MMCR_ADDDECCTL_WPV_INT_ENB; 1039 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_ADDDECCTL, adddecctl); 1040 } 1041 1042 static bool 1043 elanpar_shutdown(device_t self, int flags) 1044 { 1045 int i; 1046 struct elansc_softc *sc = device_private(device_parent(self)); 1047 1048 for (i = 0; i < __arraycount(sc->sc_textpar); i++) { 1049 if (sc->sc_textpar[i] == -1) 1050 continue; 1051 elansc_disable_par(sc->sc_memt, sc->sc_memh, sc->sc_textpar[i]); 1052 sc->sc_textpar[i] = -1; 1053 } 1054 if (sc->sc_pg0par != -1) { 1055 elansc_disable_par(sc->sc_memt, sc->sc_memh, sc->sc_pg0par); 1056 sc->sc_pg0par = -1; 1057 } 1058 return true; 1059 } 1060 1061 static void 1062 elanpar_attach(device_t parent, device_t self, void *aux) 1063 { 1064 struct elansc_softc *sc = device_private(parent); 1065 1066 aprint_naive(": Programmable Address Regions\n"); 1067 aprint_normal(": AMD Elan SC520 Programmable Address Regions\n"); 1068 1069 elansc_print_1(self, sc, MMCR_WPVMAP); 1070 elansc_print_all_par(self, sc->sc_memt, sc->sc_memh); 1071 1072 sc->sc_pg0par = elansc_protect_pg0(self, sc); 1073 elansc_protect_text(self, sc); 1074 1075 elansc_print_all_par(self, sc->sc_memt, sc->sc_memh); 1076 1077 elanpar_intr_establish(self, sc); 1078 1079 elansc_print_1(self, sc, MMCR_ADDDECCTL); 1080 1081 if (!pmf_device_register1(self, elanpar_suspend, elanpar_resume, 1082 elanpar_shutdown)) 1083 aprint_error_dev(self, "could not establish power hooks\n"); 1084 } 1085 1086 static void 1087 elanpar_intr_disestablish(struct elansc_softc *sc) 1088 { 1089 uint8_t adddecctl, wpvmap; 1090 1091 /* disable interrupt, acknowledge it, disestablish our 1092 * handler, unmap it 1093 */ 1094 adddecctl = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_ADDDECCTL); 1095 adddecctl &= ~MMCR_ADDDECCTL_WPV_INT_ENB; 1096 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_ADDDECCTL, adddecctl); 1097 1098 bus_space_write_2(sc->sc_memt, sc->sc_memh, MMCR_WPVSTA, 1099 MMCR_WPVSTA_WPV_STA); 1100 1101 if (elansc_wpvnmi) 1102 nmi_disestablish(sc->sc_pih); 1103 else 1104 intr_disestablish(sc->sc_pih); 1105 sc->sc_pih = NULL; 1106 1107 wpvmap = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_WPVMAP); 1108 wpvmap &= ~MMCR_WPVMAP_INT_MAP; 1109 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_WPVMAP, wpvmap); 1110 } 1111 1112 static int 1113 elanpar_detach(device_t self, int flags) 1114 { 1115 struct elansc_softc *sc = device_private(device_parent(self)); 1116 1117 pmf_device_deregister(self); 1118 1119 elanpar_shutdown(self, 0); 1120 1121 elanpar_intr_disestablish(sc); 1122 1123 return 0; 1124 } 1125 1126 static void 1127 elansc_attach(device_t parent, device_t self, void *aux) 1128 { 1129 struct elansc_softc *sc = device_private(self); 1130 struct pci_attach_args *pa = aux; 1131 uint16_t rev; 1132 uint8_t cpuctl, picicr, ressta; 1133 #if NGPIO > 0 1134 struct gpiobus_attach_args gba; 1135 int pin, reg, shift; 1136 uint16_t data; 1137 #endif 1138 sc->sc_pc = pa->pa_pc; 1139 sc->sc_tag = pa->pa_tag; 1140 1141 aprint_naive(": System Controller\n"); 1142 aprint_normal(": AMD Elan SC520 System Controller\n"); 1143 1144 sc->sc_memt = pa->pa_memt; 1145 if (bus_space_map(sc->sc_memt, MMCR_BASE_ADDR, PAGE_SIZE, 0, 1146 &sc->sc_memh) != 0) { 1147 aprint_error_dev(&sc->sc_dev, "unable to map registers\n"); 1148 return; 1149 } 1150 1151 mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_HIGH); 1152 1153 rev = bus_space_read_2(sc->sc_memt, sc->sc_memh, MMCR_REVID); 1154 cpuctl = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_CPUCTL); 1155 1156 aprint_normal_dev(&sc->sc_dev, 1157 "product %d stepping %d.%d, CPU clock %s\n", 1158 (rev & REVID_PRODID) >> REVID_PRODID_SHIFT, 1159 (rev & REVID_MAJSTEP) >> REVID_MAJSTEP_SHIFT, 1160 (rev & REVID_MINSTEP), 1161 elansc_speeds[cpuctl & CPUCTL_CPU_CLK_SPD_MASK]); 1162 1163 /* 1164 * SC520 rev A1 has a bug that affects the watchdog timer. If 1165 * the GP bus echo mode is enabled, writing to the watchdog control 1166 * register is blocked. 1167 * 1168 * The BIOS in some systems (e.g. the Soekris net4501) enables 1169 * GP bus echo for various reasons, so we need to switch it off 1170 * when we talk to the watchdog timer. 1171 * 1172 * XXX The step 1.1 (B1?) in my Soekris net4501 also has this 1173 * XXX problem, so we'll just enable it for all Elan SC520s 1174 * XXX for now. --thorpej (at) NetBSD.org 1175 */ 1176 if (1 || rev == ((PRODID_ELAN_SC520 << REVID_PRODID_SHIFT) | 1177 (0 << REVID_MAJSTEP_SHIFT) | (1))) 1178 sc->sc_echobug = 1; 1179 1180 /* 1181 * Determine cause of the last reset, and issue a warning if it 1182 * was due to watchdog expiry. 1183 */ 1184 ressta = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_RESSTA); 1185 if (ressta & RESSTA_WDT_RST_DET) 1186 aprint_error_dev(&sc->sc_dev, 1187 "WARNING: LAST RESET DUE TO WATCHDOG EXPIRATION!\n"); 1188 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_RESSTA, ressta); 1189 1190 elansc_print_1(self, sc, MMCR_MPICMODE); 1191 elansc_print_1(self, sc, MMCR_SL1PICMODE); 1192 elansc_print_1(self, sc, MMCR_SL2PICMODE); 1193 elansc_print_1(self, sc, MMCR_PICICR); 1194 1195 sc->sc_mpicmode = bus_space_read_1(sc->sc_memt, sc->sc_memh, 1196 MMCR_MPICMODE); 1197 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_MPICMODE, 1198 sc->sc_mpicmode | __BIT(ELAN_IRQ)); 1199 1200 sc->sc_picicr = bus_space_read_1(sc->sc_memt, sc->sc_memh, MMCR_PICICR); 1201 picicr = sc->sc_picicr; 1202 if (elansc_pcinmi || elansc_wpvnmi) 1203 picicr |= MMCR_PICICR_NMI_ENB; 1204 #if 0 1205 /* PC/AT compatibility */ 1206 picicr |= MMCR_PICICR_S1_GINT_MODE|MMCR_PICICR_M_GINT_MODE; 1207 #endif 1208 bus_space_write_1(sc->sc_memt, sc->sc_memh, MMCR_PICICR, picicr); 1209 1210 elansc_print_1(self, sc, MMCR_PICICR); 1211 elansc_print_1(self, sc, MMCR_MPICMODE); 1212 1213 mutex_enter(&sc->sc_mtx); 1214 /* Set up the watchdog registers with some defaults. */ 1215 elansc_wdogctl_write(sc, WDTMRCTL_WRST_ENB | WDTMRCTL_EXP_SEL30); 1216 1217 /* ...and clear it. */ 1218 elansc_wdogctl_reset(sc); 1219 mutex_exit(&sc->sc_mtx); 1220 1221 if (!pmf_device_register(self, elansc_suspend, elansc_resume)) 1222 aprint_error_dev(self, "could not establish power hooks\n"); 1223 1224 #if NGPIO > 0 1225 /* Initialize GPIO pins array */ 1226 for (pin = 0; pin < ELANSC_PIO_NPINS; pin++) { 1227 sc->sc_gpio_pins[pin].pin_num = pin; 1228 sc->sc_gpio_pins[pin].pin_caps = GPIO_PIN_INPUT | 1229 GPIO_PIN_OUTPUT; 1230 1231 /* Read initial state */ 1232 reg = (pin < 16 ? MMCR_PIODIR15_0 : MMCR_PIODIR31_16); 1233 shift = pin % 16; 1234 data = bus_space_read_2(sc->sc_memt, sc->sc_memh, reg); 1235 if ((data & (1 << shift)) == 0) 1236 sc->sc_gpio_pins[pin].pin_flags = GPIO_PIN_INPUT; 1237 else 1238 sc->sc_gpio_pins[pin].pin_flags = GPIO_PIN_OUTPUT; 1239 if (elansc_gpio_pin_read(sc, pin) == 0) 1240 sc->sc_gpio_pins[pin].pin_state = GPIO_PIN_LOW; 1241 else 1242 sc->sc_gpio_pins[pin].pin_state = GPIO_PIN_HIGH; 1243 } 1244 1245 /* Create controller tag */ 1246 sc->sc_gpio_gc.gp_cookie = sc; 1247 sc->sc_gpio_gc.gp_pin_read = elansc_gpio_pin_read; 1248 sc->sc_gpio_gc.gp_pin_write = elansc_gpio_pin_write; 1249 sc->sc_gpio_gc.gp_pin_ctl = elansc_gpio_pin_ctl; 1250 1251 gba.gba_gc = &sc->sc_gpio_gc; 1252 gba.gba_pins = sc->sc_gpio_pins; 1253 gba.gba_npins = ELANSC_PIO_NPINS; 1254 1255 sc->sc_par = config_found_ia(&sc->sc_dev, "elanparbus", NULL, NULL); 1256 sc->sc_pex = config_found_ia(&sc->sc_dev, "elanpexbus", NULL, NULL); 1257 /* Attach GPIO framework */ 1258 config_found_ia(&sc->sc_dev, "gpiobus", &gba, gpiobus_print); 1259 #endif /* NGPIO */ 1260 1261 /* 1262 * Hook up the watchdog timer. 1263 */ 1264 sc->sc_smw.smw_name = device_xname(&sc->sc_dev); 1265 sc->sc_smw.smw_cookie = sc; 1266 sc->sc_smw.smw_setmode = elansc_wdog_setmode; 1267 sc->sc_smw.smw_tickle = elansc_wdog_tickle; 1268 sc->sc_smw.smw_period = 32; /* actually 32.54 */ 1269 if (sysmon_wdog_register(&sc->sc_smw) != 0) { 1270 aprint_error_dev(&sc->sc_dev, 1271 "unable to register watchdog with sysmon\n"); 1272 } 1273 } 1274 1275 static int 1276 elanpex_match(device_t parent, struct cfdata *match, void *aux) 1277 { 1278 struct elansc_softc *sc = device_private(parent); 1279 1280 return sc->sc_pex == NULL; 1281 } 1282 1283 static int 1284 elanpar_match(device_t parent, struct cfdata *match, void *aux) 1285 { 1286 struct elansc_softc *sc = device_private(parent); 1287 1288 return sc->sc_par == NULL; 1289 } 1290 1291 CFATTACH_DECL_NEW(elanpar, sizeof(struct device), 1292 elanpar_match, elanpar_attach, elanpar_detach, NULL); 1293 1294 CFATTACH_DECL_NEW(elanpex, sizeof(struct device), 1295 elanpex_match, elanpex_attach, elanpex_detach, NULL); 1296 1297 CFATTACH_DECL2(elansc, sizeof(struct elansc_softc), 1298 elansc_match, elansc_attach, elansc_detach, NULL, NULL, 1299 elansc_childdetached); 1300 1301 #if NGPIO > 0 1302 static int 1303 elansc_gpio_pin_read(void *arg, int pin) 1304 { 1305 struct elansc_softc *sc = arg; 1306 int reg, shift; 1307 uint16_t data; 1308 1309 reg = (pin < 16 ? MMCR_PIODATA15_0 : MMCR_PIODATA31_16); 1310 shift = pin % 16; 1311 1312 mutex_enter(&sc->sc_mtx); 1313 data = bus_space_read_2(sc->sc_memt, sc->sc_memh, reg); 1314 mutex_exit(&sc->sc_mtx); 1315 1316 return ((data >> shift) & 0x1); 1317 } 1318 1319 static void 1320 elansc_gpio_pin_write(void *arg, int pin, int value) 1321 { 1322 struct elansc_softc *sc = arg; 1323 int reg, shift; 1324 uint16_t data; 1325 1326 reg = (pin < 16 ? MMCR_PIODATA15_0 : MMCR_PIODATA31_16); 1327 shift = pin % 16; 1328 1329 mutex_enter(&sc->sc_mtx); 1330 data = bus_space_read_2(sc->sc_memt, sc->sc_memh, reg); 1331 if (value == 0) 1332 data &= ~(1 << shift); 1333 else if (value == 1) 1334 data |= (1 << shift); 1335 1336 bus_space_write_2(sc->sc_memt, sc->sc_memh, reg, data); 1337 mutex_exit(&sc->sc_mtx); 1338 } 1339 1340 static void 1341 elansc_gpio_pin_ctl(void *arg, int pin, int flags) 1342 { 1343 struct elansc_softc *sc = arg; 1344 int reg, shift; 1345 uint16_t data; 1346 1347 reg = (pin < 16 ? MMCR_PIODIR15_0 : MMCR_PIODIR31_16); 1348 shift = pin % 16; 1349 mutex_enter(&sc->sc_mtx); 1350 data = bus_space_read_2(sc->sc_memt, sc->sc_memh, reg); 1351 if (flags & GPIO_PIN_INPUT) 1352 data &= ~(1 << shift); 1353 if (flags & GPIO_PIN_OUTPUT) 1354 data |= (1 << shift); 1355 1356 bus_space_write_2(sc->sc_memt, sc->sc_memh, reg, data); 1357 mutex_exit(&sc->sc_mtx); 1358 } 1359 #endif /* NGPIO */ 1360
Indexes created Tue Sep 30 10:09:55 GMT 2025