drivers/watchdog/lenovo_se10_wdt.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * WDT driver for Lenovo SE10.
   4  */
   5
   6 #include <linux/delay.h>
   7 #include <linux/dmi.h>
   8 #include <linux/io.h>
   9 #include <linux/module.h>
  10 #include <linux/moduleparam.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/string.h>
  13 #include <linux/types.h>
  14 #include <linux/watchdog.h>
  15
  16 #define STATUS_PORT     0x6C
  17 #define CMD_PORT        0x6C
  18 #define DATA_PORT       0x68
  19 #define OUTBUF_FULL     0x01
  20 #define INBUF_EMPTY     0x02
  21 #define CFG_LDN         0x07
  22 #define CFG_BRAM_LDN    0x10 /* for BRAM Base */
  23 #define CFG_PORT        0x2E
  24 #define CFG_SIZE           2
  25 #define CMD_SIZE           4
  26 #define BRAM_SIZE          2
  27
  28 #define UNLOCK_KEY      0x87
  29 #define LOCK_KEY        0xAA
  30
  31 #define CUS_WDT_SWI     0x1A
  32 #define CUS_WDT_CFG     0x1B
  33 #define CUS_WDT_FEED    0xB0
  34 #define CUS_WDT_CNT     0xB1
  35
  36 #define DRVNAME "lenovo-se10-wdt"
  37
  38 /*The timeout range is 1-255 seconds*/
  39 #define MIN_TIMEOUT 1
  40 #define MAX_TIMEOUT 255
  41 #define MAX_WAIT    10
  42
  43 #define WATCHDOG_TIMEOUT 60 /* 60 sec default timeout */
  44 static unsigned short bram_base;
  45 static struct platform_device *se10_pdev;
  46
  47 static int timeout; /* in seconds */
  48 module_param(timeout, int, 0);
  49 MODULE_PARM_DESC(timeout,
  50                  "Watchdog timeout in seconds. 1 <= timeout <= 255, default="
  51                  __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
  52
  53 static bool nowayout = WATCHDOG_NOWAYOUT;
  54 module_param(nowayout, bool, 0);
  55 MODULE_PARM_DESC(nowayout,
  56                  "Watchdog cannot be stopped once started (default="
  57                  __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  58
  59 struct se10_wdt {
  60         struct watchdog_device wdd;
  61 };
  62
  63 static int set_bram(unsigned char offset, unsigned char val)
  64 {
  65         if (!request_muxed_region(bram_base, BRAM_SIZE, DRVNAME))
  66                 return -EBUSY;
  67         outb(offset, bram_base);
  68         outb(val, bram_base + 1);
  69         release_region(bram_base, BRAM_SIZE);
  70         return 0;
  71 }
  72
  73 static void wait_for_buffer(int condition)
  74 {
  75         int loop = 0;
  76
  77         while (1) {
  78                 if (inb(STATUS_PORT) & condition || loop > MAX_WAIT)
  79                         break;
  80                 loop++;
  81                 usleep_range(10, 125);
  82         }
  83 }
  84
  85 static void send_cmd(unsigned char cmd)
  86 {
  87         wait_for_buffer(INBUF_EMPTY);
  88         outb(cmd, CMD_PORT);
  89         wait_for_buffer(INBUF_EMPTY);
  90 }
  91
  92 static void lpc_write(unsigned char index, unsigned char data)
  93 {
  94         outb(index, CFG_PORT);
  95         outb(data, CFG_PORT + 1);
  96 }
  97
  98 static unsigned char lpc_read(unsigned char index)
  99 {
 100         outb(index, CFG_PORT);
 101         return inb(CFG_PORT + 1);
 102 }
 103
 104 static int wdt_start(struct watchdog_device *wdog)
 105 {
 106         return set_bram(CUS_WDT_SWI, 0x80);
 107 }
 108
 109 static int wdt_set_timeout(struct watchdog_device *wdog, unsigned int timeout)
 110 {
 111         wdog->timeout = timeout;
 112         return set_bram(CUS_WDT_CFG, wdog->timeout);
 113 }
 114
 115 static int wdt_stop(struct watchdog_device *wdog)
 116 {
 117         return set_bram(CUS_WDT_SWI, 0);
 118 }
 119
 120 static unsigned int wdt_get_time(struct watchdog_device *wdog)
 121 {
 122         unsigned char time;
 123
 124         if (!request_muxed_region(CMD_PORT, CMD_SIZE, DRVNAME))
 125                 return -EBUSY;
 126         send_cmd(CUS_WDT_CNT);
 127         wait_for_buffer(OUTBUF_FULL);
 128         time = inb(DATA_PORT);
 129         release_region(CMD_PORT, CMD_SIZE);
 130         return time;
 131 }
 132
 133 static int wdt_ping(struct watchdog_device *wdog)
 134 {
 135         if (!request_muxed_region(CMD_PORT, CMD_SIZE, DRVNAME))
 136                 return -EBUSY;
 137         send_cmd(CUS_WDT_FEED);
 138         release_region(CMD_PORT, CMD_SIZE);
 139         return 0;
 140 }
 141
 142 static const struct watchdog_info wdt_info = {
 143         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
 144         .identity = "Lenovo SE10 Watchdog",
 145 };
 146
 147 static const struct watchdog_ops se10_wdt_ops = {
 148         .owner = THIS_MODULE,
 149         .start = wdt_start,
 150         .stop = wdt_stop,
 151         .ping = wdt_ping,
 152         .set_timeout = wdt_set_timeout,
 153         .get_timeleft = wdt_get_time,
 154 };
 155
 156 static unsigned int get_chipID(void)
 157 {
 158         unsigned char msb, lsb;
 159
 160         outb(UNLOCK_KEY, CFG_PORT);
 161         outb(0x01, CFG_PORT);
 162         outb(0x55, CFG_PORT);
 163         outb(0x55, CFG_PORT);
 164         msb = lpc_read(0x20);
 165         lsb = lpc_read(0x21);
 166         outb(LOCK_KEY, CFG_PORT);
 167         return (msb * 256 + lsb);
 168 }
 169
 170 static int se10_wdt_probe(struct platform_device *pdev)
 171 {
 172         struct device *dev = &pdev->dev;
 173         struct se10_wdt *priv;
 174         unsigned int chip_id;
 175         int ret;
 176
 177         if (!request_muxed_region(CFG_PORT, CFG_SIZE, DRVNAME))
 178                 return -EBUSY;
 179
 180         chip_id = get_chipID();
 181         if (chip_id != 0x5632) {
 182                 release_region(CFG_PORT, CFG_SIZE);
 183                 return -ENODEV;
 184         }
 185
 186         lpc_write(CFG_LDN, CFG_BRAM_LDN);
 187         bram_base = (lpc_read(0x60) << 8) | lpc_read(0x61);
 188         release_region(CFG_PORT, CFG_SIZE);
 189
 190         dev_info(dev, "Found Lenovo SE10 0x%x\n", chip_id);
 191
 192         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 193         if (!priv)
 194                 return -ENOMEM;
 195
 196         watchdog_set_drvdata(&priv->wdd, priv);
 197
 198         priv->wdd.parent = dev;
 199         priv->wdd.info = &wdt_info;
 200         priv->wdd.ops = &se10_wdt_ops;
 201         priv->wdd.timeout = WATCHDOG_TIMEOUT; /* Set default timeout */
 202         priv->wdd.min_timeout = MIN_TIMEOUT;
 203         priv->wdd.max_timeout = MAX_TIMEOUT;
 204
 205         set_bram(CUS_WDT_CFG, WATCHDOG_TIMEOUT); /* Set time to default */
 206
 207         watchdog_init_timeout(&priv->wdd, timeout, dev);
 208         watchdog_set_nowayout(&priv->wdd, nowayout);
 209         watchdog_stop_on_reboot(&priv->wdd);
 210         watchdog_stop_on_unregister(&priv->wdd);
 211
 212         ret = devm_watchdog_register_device(dev, &priv->wdd);
 213
 214         dev_dbg(&pdev->dev, "initialized. timeout=%d sec (nowayout=%d)\n",
 215                 priv->wdd.timeout, nowayout);
 216
 217         return ret;
 218 }
 219
 220 static struct platform_driver se10_wdt_driver = {
 221         .driver = {
 222                 .name = DRVNAME,
 223         },
 224         .probe  = se10_wdt_probe,
 225 };
 226
 227 static int se10_create_platform_device(const struct dmi_system_id *id)
 228 {
 229         int err;
 230
 231         se10_pdev = platform_device_alloc("lenovo-se10-wdt", -1);
 232         if (!se10_pdev)
 233                 return -ENOMEM;
 234
 235         err = platform_device_add(se10_pdev);
 236         if (err)
 237                 platform_device_put(se10_pdev);
 238
 239         return err;
 240 }
 241
 242 static const struct dmi_system_id se10_dmi_table[] __initconst = {
 243         {
 244                 .ident = "LENOVO-SE10",
 245                 .matches = {
 246                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 247                         DMI_MATCH(DMI_PRODUCT_NAME, "12NH"),
 248                 },
 249                 .callback = se10_create_platform_device,
 250         },
 251         {
 252                 .ident = "LENOVO-SE10",
 253                 .matches = {
 254                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 255                         DMI_MATCH(DMI_PRODUCT_NAME, "12NJ"),
 256                 },
 257                 .callback = se10_create_platform_device,
 258         },
 259         {
 260                 .ident = "LENOVO-SE10",
 261                 .matches = {
 262                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 263                         DMI_MATCH(DMI_PRODUCT_NAME, "12NK"),
 264                 },
 265                 .callback = se10_create_platform_device,
 266         },
 267         {
 268                 .ident = "LENOVO-SE10",
 269                 .matches = {
 270                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 271                         DMI_MATCH(DMI_PRODUCT_NAME, "12NL"),
 272                 },
 273                 .callback = se10_create_platform_device,
 274         },
 275         {
 276                 .ident = "LENOVO-SE10",
 277                 .matches = {
 278                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 279                         DMI_MATCH(DMI_PRODUCT_NAME, "12NM"),
 280                 },
 281                 .callback = se10_create_platform_device,
 282         },
 283         {}
 284 };
 285 MODULE_DEVICE_TABLE(dmi, se10_dmi_table);
 286
 287 static int __init se10_wdt_init(void)
 288 {
 289         if (!dmi_check_system(se10_dmi_table))
 290                 return -ENODEV;
 291
 292         return platform_driver_register(&se10_wdt_driver);
 293 }
 294
 295 static void __exit se10_wdt_exit(void)
 296 {
 297         if (se10_pdev)
 298                 platform_device_unregister(se10_pdev);
 299         platform_driver_unregister(&se10_wdt_driver);
 300 }
 301
 302 module_init(se10_wdt_init);
 303 module_exit(se10_wdt_exit);
 304
 305 MODULE_LICENSE("GPL");
 306 MODULE_AUTHOR("David Ober<dober@lenovo.com>");
 307 MODULE_AUTHOR("Mark Pearson <mpearson-lenovo@squebb.ca>");
 308 MODULE_DESCRIPTION("WDT driver for Lenovo SE10");