1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /*************************************************************************** 3 * Copyright (C) 2010-2012 Hans de Goede <hdegoede@redhat.com> * 4 * * 5 ***************************************************************************/ 6 7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9 #include <linux/module.h> 10 #include <linux/mod_devicetable.h> 11 #include <linux/init.h> 12 #include <linux/platform_device.h> 13 #include <linux/dmi.h> 14 #include <linux/err.h> 15 #include <linux/io.h> 16 #include <linux/acpi.h> 17 #include <linux/delay.h> 18 #include <linux/fs.h> 19 #include <linux/watchdog.h> 20 #include <linux/uaccess.h> 21 #include <linux/slab.h> 22 #include "sch56xx-common.h" 23 24 static bool ignore_dmi; 25 module_param(ignore_dmi, bool, 0); 26 MODULE_PARM_DESC(ignore_dmi, "Omit DMI check for supported devices (default=0)"); 27 28 static bool nowayout = WATCHDOG_NOWAYOUT; 29 module_param(nowayout, bool, 0); 30 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" 31 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 32 33 #define SIO_SCH56XX_LD_EM 0x0C /* Embedded uController Logical Dev */ 34 #define SIO_UNLOCK_KEY 0x55 /* Key to enable Super-I/O */ 35 #define SIO_LOCK_KEY 0xAA /* Key to disable Super-I/O */ 36 37 #define SIO_REG_LDSEL 0x07 /* Logical device select */ 38 #define SIO_REG_DEVID 0x20 /* Device ID */ 39 #define SIO_REG_ENABLE 0x30 /* Logical device enable */ 40 #define SIO_REG_ADDR 0x66 /* Logical device address (2 bytes) */ 41 42 #define SIO_SCH5627_ID 0xC6 /* Chipset ID */ 43 #define SIO_SCH5636_ID 0xC7 /* Chipset ID */ 44 45 #define REGION_LENGTH 10 46 47 #define SCH56XX_CMD_READ 0x02 48 #define SCH56XX_CMD_WRITE 0x03 49 50 /* Watchdog registers */ 51 #define SCH56XX_REG_WDOG_PRESET 0x58B 52 #define SCH56XX_REG_WDOG_CONTROL 0x58C 53 #define SCH56XX_WDOG_TIME_BASE_SEC 0x01 54 #define SCH56XX_REG_WDOG_OUTPUT_ENABLE 0x58E 55 #define SCH56XX_WDOG_OUTPUT_ENABLE 0x02 56 57 struct sch56xx_watchdog_data { 58 u16 addr; 59 struct mutex *io_lock; 60 struct watchdog_info wdinfo; 61 struct watchdog_device wddev; 62 u8 watchdog_preset; 63 u8 watchdog_control; 64 u8 watchdog_output_enable; 65 }; 66 67 static struct platform_device *sch56xx_pdev; 68 69 /* Super I/O functions */ 70 static inline int superio_inb(int base, int reg) 71 { 72 outb(reg, base); 73 return inb(base + 1); 74 } 75 76 static inline int superio_enter(int base) 77 { 78 /* Don't step on other drivers' I/O space by accident */ 79 if (!request_muxed_region(base, 2, "sch56xx")) { 80 pr_err("I/O address 0x%04x already in use\n", base); 81 return -EBUSY; 82 } 83 84 outb(SIO_UNLOCK_KEY, base); 85 86 return 0; 87 } 88 89 static inline void superio_select(int base, int ld) 90 { 91 outb(SIO_REG_LDSEL, base); 92 outb(ld, base + 1); 93 } 94 95 static inline void superio_exit(int base) 96 { 97 outb(SIO_LOCK_KEY, base); 98 release_region(base, 2); 99 } 100 101 static int sch56xx_send_cmd(u16 addr, u8 cmd, u16 reg, u8 v) 102 { 103 u8 val; 104 int i; 105 /* 106 * According to SMSC for the commands we use the maximum time for 107 * the EM to respond is 15 ms, but testing shows in practice it 108 * responds within 15-32 reads, so we first busy poll, and if 109 * that fails sleep a bit and try again until we are way past 110 * the 15 ms maximum response time. 111 */ 112 const int max_busy_polls = 64; 113 const int max_lazy_polls = 32; 114 115 /* (Optional) Write-Clear the EC to Host Mailbox Register */ 116 val = inb(addr + 1); 117 outb(val, addr + 1); 118 119 /* Set Mailbox Address Pointer to first location in Region 1 */ 120 outb(0x00, addr + 2); 121 outb(0x80, addr + 3); 122 123 /* Write Request Packet Header */ 124 outb(cmd, addr + 4); /* VREG Access Type read:0x02 write:0x03 */ 125 outb(0x01, addr + 5); /* # of Entries: 1 Byte (8-bit) */ 126 outb(0x04, addr + 2); /* Mailbox AP to first data entry loc. */ 127 128 /* Write Value field */ 129 if (cmd == SCH56XX_CMD_WRITE) 130 outb(v, addr + 4); 131 132 /* Write Address field */ 133 outb(reg & 0xff, addr + 6); 134 outb(reg >> 8, addr + 7); 135 136 /* Execute the Random Access Command */ 137 outb(0x01, addr); /* Write 01h to the Host-to-EC register */ 138 139 /* EM Interface Polling "Algorithm" */ 140 for (i = 0; i < max_busy_polls + max_lazy_polls; i++) { 141 if (i >= max_busy_polls) 142 usleep_range(1000, 2000); 143 /* Read Interrupt source Register */ 144 val = inb(addr + 8); 145 /* Write Clear the interrupt source bits */ 146 if (val) 147 outb(val, addr + 8); 148 /* Command Completed ? */ 149 if (val & 0x01) 150 break; 151 } 152 if (i == max_busy_polls + max_lazy_polls) { 153 pr_err("Max retries exceeded reading virtual register 0x%04hx (%d)\n", 154 reg, 1); 155 return -EIO; 156 } 157 158 /* 159 * According to SMSC we may need to retry this, but sofar I've always 160 * seen this succeed in 1 try. 161 */ 162 for (i = 0; i < max_busy_polls; i++) { 163 /* Read EC-to-Host Register */ 164 val = inb(addr + 1); 165 /* Command Completed ? */ 166 if (val == 0x01) 167 break; 168 169 if (i == 0) 170 pr_warn("EC reports: 0x%02x reading virtual register 0x%04hx\n", 171 (unsigned int)val, reg); 172 } 173 if (i == max_busy_polls) { 174 pr_err("Max retries exceeded reading virtual register 0x%04hx (%d)\n", 175 reg, 2); 176 return -EIO; 177 } 178 179 /* 180 * According to the SMSC app note we should now do: 181 * 182 * Set Mailbox Address Pointer to first location in Region 1 * 183 * outb(0x00, addr + 2); 184 * outb(0x80, addr + 3); 185 * 186 * But if we do that things don't work, so let's not. 187 */ 188 189 /* Read Value field */ 190 if (cmd == SCH56XX_CMD_READ) 191 return inb(addr + 4); 192 193 return 0; 194 } 195 196 int sch56xx_read_virtual_reg(u16 addr, u16 reg) 197 { 198 return sch56xx_send_cmd(addr, SCH56XX_CMD_READ, reg, 0); 199 } 200 EXPORT_SYMBOL(sch56xx_read_virtual_reg); 201 202 int sch56xx_write_virtual_reg(u16 addr, u16 reg, u8 val) 203 { 204 return sch56xx_send_cmd(addr, SCH56XX_CMD_WRITE, reg, val); 205 } 206 EXPORT_SYMBOL(sch56xx_write_virtual_reg); 207 208 int sch56xx_read_virtual_reg16(u16 addr, u16 reg) 209 { 210 int lsb, msb; 211 212 /* Read LSB first, this will cause the matching MSB to be latched */ 213 lsb = sch56xx_read_virtual_reg(addr, reg); 214 if (lsb < 0) 215 return lsb; 216 217 msb = sch56xx_read_virtual_reg(addr, reg + 1); 218 if (msb < 0) 219 return msb; 220 221 return lsb | (msb << 8); 222 } 223 EXPORT_SYMBOL(sch56xx_read_virtual_reg16); 224 225 int sch56xx_read_virtual_reg12(u16 addr, u16 msb_reg, u16 lsn_reg, 226 int high_nibble) 227 { 228 int msb, lsn; 229 230 /* Read MSB first, this will cause the matching LSN to be latched */ 231 msb = sch56xx_read_virtual_reg(addr, msb_reg); 232 if (msb < 0) 233 return msb; 234 235 lsn = sch56xx_read_virtual_reg(addr, lsn_reg); 236 if (lsn < 0) 237 return lsn; 238 239 if (high_nibble) 240 return (msb << 4) | (lsn >> 4); 241 else 242 return (msb << 4) | (lsn & 0x0f); 243 } 244 EXPORT_SYMBOL(sch56xx_read_virtual_reg12); 245 246 /* 247 * Watchdog routines 248 */ 249 250 static int watchdog_set_timeout(struct watchdog_device *wddev, 251 unsigned int timeout) 252 { 253 struct sch56xx_watchdog_data *data = watchdog_get_drvdata(wddev); 254 unsigned int resolution; 255 u8 control; 256 int ret; 257 258 /* 1 second or 60 second resolution? */ 259 if (timeout <= 255) 260 resolution = 1; 261 else 262 resolution = 60; 263 264 if (timeout < resolution || timeout > (resolution * 255)) 265 return -EINVAL; 266 267 if (resolution == 1) 268 control = data->watchdog_control | SCH56XX_WDOG_TIME_BASE_SEC; 269 else 270 control = data->watchdog_control & ~SCH56XX_WDOG_TIME_BASE_SEC; 271 272 if (data->watchdog_control != control) { 273 mutex_lock(data->io_lock); 274 ret = sch56xx_write_virtual_reg(data->addr, 275 SCH56XX_REG_WDOG_CONTROL, 276 control); 277 mutex_unlock(data->io_lock); 278 if (ret) 279 return ret; 280 281 data->watchdog_control = control; 282 } 283 284 /* 285 * Remember new timeout value, but do not write as that (re)starts 286 * the watchdog countdown. 287 */ 288 data->watchdog_preset = DIV_ROUND_UP(timeout, resolution); 289 wddev->timeout = data->watchdog_preset * resolution; 290 291 return 0; 292 } 293 294 static int watchdog_start(struct watchdog_device *wddev) 295 { 296 struct sch56xx_watchdog_data *data = watchdog_get_drvdata(wddev); 297 int ret; 298 u8 val; 299 300 /* 301 * The sch56xx's watchdog cannot really be started / stopped 302 * it is always running, but we can avoid the timer expiring 303 * from causing a system reset by clearing the output enable bit. 304 * 305 * The sch56xx's watchdog will set the watchdog event bit, bit 0 306 * of the second interrupt source register (at base-address + 9), 307 * when the timer expires. 308 * 309 * This will only cause a system reset if the 0-1 flank happens when 310 * output enable is true. Setting output enable after the flank will 311 * not cause a reset, nor will the timer expiring a second time. 312 * This means we must clear the watchdog event bit in case it is set. 313 * 314 * The timer may still be running (after a recent watchdog_stop) and 315 * mere milliseconds away from expiring, so the timer must be reset 316 * first! 317 */ 318 319 mutex_lock(data->io_lock); 320 321 /* 1. Reset the watchdog countdown counter */ 322 ret = sch56xx_write_virtual_reg(data->addr, SCH56XX_REG_WDOG_PRESET, 323 data->watchdog_preset); 324 if (ret) 325 goto leave; 326 327 /* 2. Enable output */ 328 val = data->watchdog_output_enable | SCH56XX_WDOG_OUTPUT_ENABLE; 329 ret = sch56xx_write_virtual_reg(data->addr, 330 SCH56XX_REG_WDOG_OUTPUT_ENABLE, val); 331 if (ret) 332 goto leave; 333 334 data->watchdog_output_enable = val; 335 336 /* 3. Clear the watchdog event bit if set */ 337 val = inb(data->addr + 9); 338 if (val & 0x01) 339 outb(0x01, data->addr + 9); 340 341 leave: 342 mutex_unlock(data->io_lock); 343 return ret; 344 } 345 346 static int watchdog_trigger(struct watchdog_device *wddev) 347 { 348 struct sch56xx_watchdog_data *data = watchdog_get_drvdata(wddev); 349 int ret; 350 351 /* Reset the watchdog countdown counter */ 352 mutex_lock(data->io_lock); 353 ret = sch56xx_write_virtual_reg(data->addr, SCH56XX_REG_WDOG_PRESET, 354 data->watchdog_preset); 355 mutex_unlock(data->io_lock); 356 357 return ret; 358 } 359 360 static int watchdog_stop(struct watchdog_device *wddev) 361 { 362 struct sch56xx_watchdog_data *data = watchdog_get_drvdata(wddev); 363 int ret = 0; 364 u8 val; 365 366 val = data->watchdog_output_enable & ~SCH56XX_WDOG_OUTPUT_ENABLE; 367 mutex_lock(data->io_lock); 368 ret = sch56xx_write_virtual_reg(data->addr, 369 SCH56XX_REG_WDOG_OUTPUT_ENABLE, val); 370 mutex_unlock(data->io_lock); 371 if (ret) 372 return ret; 373 374 data->watchdog_output_enable = val; 375 return 0; 376 } 377 378 static const struct watchdog_ops watchdog_ops = { 379 .owner = THIS_MODULE, 380 .start = watchdog_start, 381 .stop = watchdog_stop, 382 .ping = watchdog_trigger, 383 .set_timeout = watchdog_set_timeout, 384 }; 385 386 void sch56xx_watchdog_register(struct device *parent, u16 addr, u32 revision, 387 struct mutex *io_lock, int check_enabled) 388 { 389 struct sch56xx_watchdog_data *data; 390 int err, control, output_enable; 391 392 /* Cache the watchdog registers */ 393 mutex_lock(io_lock); 394 control = 395 sch56xx_read_virtual_reg(addr, SCH56XX_REG_WDOG_CONTROL); 396 output_enable = 397 sch56xx_read_virtual_reg(addr, SCH56XX_REG_WDOG_OUTPUT_ENABLE); 398 mutex_unlock(io_lock); 399 400 if (control < 0) 401 return; 402 if (output_enable < 0) 403 return; 404 if (check_enabled && !(output_enable & SCH56XX_WDOG_OUTPUT_ENABLE)) { 405 pr_warn("Watchdog not enabled by BIOS, not registering\n"); 406 return; 407 } 408 409 data = devm_kzalloc(parent, sizeof(struct sch56xx_watchdog_data), GFP_KERNEL); 410 if (!data) 411 return; 412 413 data->addr = addr; 414 data->io_lock = io_lock; 415 416 strscpy(data->wdinfo.identity, "sch56xx watchdog", sizeof(data->wdinfo.identity)); 417 data->wdinfo.firmware_version = revision; 418 data->wdinfo.options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT; 419 if (!nowayout) 420 data->wdinfo.options |= WDIOF_MAGICCLOSE; 421 422 data->wddev.info = &data->wdinfo; 423 data->wddev.ops = &watchdog_ops; 424 data->wddev.parent = parent; 425 data->wddev.timeout = 60; 426 data->wddev.min_timeout = 1; 427 data->wddev.max_timeout = 255 * 60; 428 watchdog_set_nowayout(&data->wddev, nowayout); 429 if (output_enable & SCH56XX_WDOG_OUTPUT_ENABLE) 430 set_bit(WDOG_HW_RUNNING, &data->wddev.status); 431 432 /* Since the watchdog uses a downcounter there is no register to read 433 the BIOS set timeout from (if any was set at all) -> 434 Choose a preset which will give us a 1 minute timeout */ 435 if (control & SCH56XX_WDOG_TIME_BASE_SEC) 436 data->watchdog_preset = 60; /* seconds */ 437 else 438 data->watchdog_preset = 1; /* minute */ 439 440 data->watchdog_control = control; 441 data->watchdog_output_enable = output_enable; 442 443 watchdog_set_drvdata(&data->wddev, data); 444 err = devm_watchdog_register_device(parent, &data->wddev); 445 if (err) { 446 pr_err("Registering watchdog chardev: %d\n", err); 447 devm_kfree(parent, data); 448 } 449 } 450 EXPORT_SYMBOL(sch56xx_watchdog_register); 451 452 /* 453 * platform dev find, add and remove functions 454 */ 455 456 static int __init sch56xx_find(int sioaddr, const char **name) 457 { 458 u8 devid; 459 unsigned short address; 460 int err; 461 462 err = superio_enter(sioaddr); 463 if (err) 464 return err; 465 466 devid = superio_inb(sioaddr, SIO_REG_DEVID); 467 switch (devid) { 468 case SIO_SCH5627_ID: 469 *name = "sch5627"; 470 break; 471 case SIO_SCH5636_ID: 472 *name = "sch5636"; 473 break; 474 default: 475 pr_debug("Unsupported device id: 0x%02x\n", 476 (unsigned int)devid); 477 err = -ENODEV; 478 goto exit; 479 } 480 481 superio_select(sioaddr, SIO_SCH56XX_LD_EM); 482 483 if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) { 484 pr_warn("Device not activated\n"); 485 err = -ENODEV; 486 goto exit; 487 } 488 489 /* 490 * Warning the order of the low / high byte is the other way around 491 * as on most other superio devices!! 492 */ 493 address = superio_inb(sioaddr, SIO_REG_ADDR) | 494 superio_inb(sioaddr, SIO_REG_ADDR + 1) << 8; 495 if (address == 0) { 496 pr_warn("Base address not set\n"); 497 err = -ENODEV; 498 goto exit; 499 } 500 err = address; 501 502 exit: 503 superio_exit(sioaddr); 504 return err; 505 } 506 507 static int __init sch56xx_device_add(int address, const char *name) 508 { 509 struct resource res = { 510 .start = address, 511 .end = address + REGION_LENGTH - 1, 512 .name = name, 513 .flags = IORESOURCE_IO, 514 }; 515 int err; 516 517 err = acpi_check_resource_conflict(&res); 518 if (err) 519 return err; 520 521 sch56xx_pdev = platform_device_register_simple(name, -1, &res, 1); 522 523 return PTR_ERR_OR_ZERO(sch56xx_pdev); 524 } 525 526 static const struct dmi_system_id sch56xx_dmi_override_table[] __initconst = { 527 { 528 .matches = { 529 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 530 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS W380"), 531 }, 532 }, 533 { 534 .matches = { 535 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 536 DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO P710"), 537 }, 538 }, 539 { 540 .matches = { 541 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 542 DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO E9900"), 543 }, 544 }, 545 { } 546 }; 547 548 /* For autoloading only */ 549 static const struct dmi_system_id sch56xx_dmi_table[] __initconst = { 550 { 551 .matches = { 552 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 553 }, 554 }, 555 { } 556 }; 557 MODULE_DEVICE_TABLE(dmi, sch56xx_dmi_table); 558 559 static int __init sch56xx_init(void) 560 { 561 const char *name = NULL; 562 int address; 563 564 if (!ignore_dmi) { 565 if (!dmi_check_system(sch56xx_dmi_table)) 566 return -ENODEV; 567 568 if (!dmi_check_system(sch56xx_dmi_override_table)) { 569 /* 570 * Some machines like the Esprimo P720 and Esprimo C700 have 571 * onboard devices named " Antiope"/" Theseus" instead of 572 * "Antiope"/"Theseus", so we need to check for both. 573 */ 574 if (!dmi_find_device(DMI_DEV_TYPE_OTHER, "Antiope", NULL) && 575 !dmi_find_device(DMI_DEV_TYPE_OTHER, " Antiope", NULL) && 576 !dmi_find_device(DMI_DEV_TYPE_OTHER, "Theseus", NULL) && 577 !dmi_find_device(DMI_DEV_TYPE_OTHER, " Theseus", NULL)) 578 return -ENODEV; 579 } 580 } 581 582 /* 583 * Some devices like the Esprimo C700 have both onboard devices, 584 * so we still have to check manually 585 */ 586 address = sch56xx_find(0x4e, &name); 587 if (address < 0) 588 address = sch56xx_find(0x2e, &name); 589 if (address < 0) 590 return address; 591 592 return sch56xx_device_add(address, name); 593 } 594 595 static void __exit sch56xx_exit(void) 596 { 597 platform_device_unregister(sch56xx_pdev); 598 } 599 600 MODULE_DESCRIPTION("SMSC SCH56xx Hardware Monitoring Common Code"); 601 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 602 MODULE_LICENSE("GPL"); 603 604 module_init(sch56xx_init); 605 module_exit(sch56xx_exit); 606