drivers/hwmon/sch56xx-common.c

   1 /***************************************************************************
   2  *   Copyright (C) 2010-2011 Hans de Goede <hdegoede@redhat.com>           *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  18  ***************************************************************************/
  19
  20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22 #include <linux/module.h>
  23 #include <linux/init.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/err.h>
  26 #include <linux/io.h>
  27 #include <linux/acpi.h>
  28 #include <linux/delay.h>
  29 #include "sch56xx-common.h"
  30
  31 #define SIO_SCH56XX_LD_EM       0x0C    /* Embedded uController Logical Dev */
  32 #define SIO_UNLOCK_KEY          0x55    /* Key to enable Super-I/O */
  33 #define SIO_LOCK_KEY            0xAA    /* Key to disable Super-I/O */
  34
  35 #define SIO_REG_LDSEL           0x07    /* Logical device select */
  36 #define SIO_REG_DEVID           0x20    /* Device ID */
  37 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
  38 #define SIO_REG_ADDR            0x66    /* Logical device address (2 bytes) */
  39
  40 #define SIO_SCH5627_ID          0xC6    /* Chipset ID */
  41 #define SIO_SCH5636_ID          0xC7    /* Chipset ID */
  42
  43 #define REGION_LENGTH           9
  44
  45 #define SCH56XX_CMD_READ        0x02
  46 #define SCH56XX_CMD_WRITE       0x03
  47
  48 static struct platform_device *sch56xx_pdev;
  49
  50 /* Super I/O functions */
  51 static inline int superio_inb(int base, int reg)
  52 {
  53         outb(reg, base);
  54         return inb(base + 1);
  55 }
  56
  57 static inline int superio_enter(int base)
  58 {
  59         /* Don't step on other drivers' I/O space by accident */
  60         if (!request_muxed_region(base, 2, "sch56xx")) {
  61                 pr_err("I/O address 0x%04x already in use\n", base);
  62                 return -EBUSY;
  63         }
  64
  65         outb(SIO_UNLOCK_KEY, base);
  66
  67         return 0;
  68 }
  69
  70 static inline void superio_select(int base, int ld)
  71 {
  72         outb(SIO_REG_LDSEL, base);
  73         outb(ld, base + 1);
  74 }
  75
  76 static inline void superio_exit(int base)
  77 {
  78         outb(SIO_LOCK_KEY, base);
  79         release_region(base, 2);
  80 }
  81
  82 static int sch56xx_send_cmd(u16 addr, u8 cmd, u16 reg, u8 v)
  83 {
  84         u8 val;
  85         int i;
  86         /*
  87          * According to SMSC for the commands we use the maximum time for
  88          * the EM to respond is 15 ms, but testing shows in practice it
  89          * responds within 15-32 reads, so we first busy poll, and if
  90          * that fails sleep a bit and try again until we are way past
  91          * the 15 ms maximum response time.
  92          */
  93         const int max_busy_polls = 64;
  94         const int max_lazy_polls = 32;
  95
  96         /* (Optional) Write-Clear the EC to Host Mailbox Register */
  97         val = inb(addr + 1);
  98         outb(val, addr + 1);
  99
 100         /* Set Mailbox Address Pointer to first location in Region 1 */
 101         outb(0x00, addr + 2);
 102         outb(0x80, addr + 3);
 103
 104         /* Write Request Packet Header */
 105         outb(cmd, addr + 4); /* VREG Access Type read:0x02 write:0x03 */
 106         outb(0x01, addr + 5); /* # of Entries: 1 Byte (8-bit) */
 107         outb(0x04, addr + 2); /* Mailbox AP to first data entry loc. */
 108
 109         /* Write Value field */
 110         if (cmd == SCH56XX_CMD_WRITE)
 111                 outb(v, addr + 4);
 112
 113         /* Write Address field */
 114         outb(reg & 0xff, addr + 6);
 115         outb(reg >> 8, addr + 7);
 116
 117         /* Execute the Random Access Command */
 118         outb(0x01, addr); /* Write 01h to the Host-to-EC register */
 119
 120         /* EM Interface Polling "Algorithm" */
 121         for (i = 0; i < max_busy_polls + max_lazy_polls; i++) {
 122                 if (i >= max_busy_polls)
 123                         msleep(1);
 124                 /* Read Interrupt source Register */
 125                 val = inb(addr + 8);
 126                 /* Write Clear the interrupt source bits */
 127                 if (val)
 128                         outb(val, addr + 8);
 129                 /* Command Completed ? */
 130                 if (val & 0x01)
 131                         break;
 132         }
 133         if (i == max_busy_polls + max_lazy_polls) {
 134                 pr_err("Max retries exceeded reading virtual "
 135                        "register 0x%04hx (%d)\n", reg, 1);
 136                 return -EIO;
 137         }
 138
 139         /*
 140          * According to SMSC we may need to retry this, but sofar I've always
 141          * seen this succeed in 1 try.
 142          */
 143         for (i = 0; i < max_busy_polls; i++) {
 144                 /* Read EC-to-Host Register */
 145                 val = inb(addr + 1);
 146                 /* Command Completed ? */
 147                 if (val == 0x01)
 148                         break;
 149
 150                 if (i == 0)
 151                         pr_warn("EC reports: 0x%02x reading virtual register "
 152                                 "0x%04hx\n", (unsigned int)val, reg);
 153         }
 154         if (i == max_busy_polls) {
 155                 pr_err("Max retries exceeded reading virtual "
 156                        "register 0x%04hx (%d)\n", reg, 2);
 157                 return -EIO;
 158         }
 159
 160         /*
 161          * According to the SMSC app note we should now do:
 162          *
 163          * Set Mailbox Address Pointer to first location in Region 1 *
 164          * outb(0x00, addr + 2);
 165          * outb(0x80, addr + 3);
 166          *
 167          * But if we do that things don't work, so let's not.
 168          */
 169
 170         /* Read Value field */
 171         if (cmd == SCH56XX_CMD_READ)
 172                 return inb(addr + 4);
 173
 174         return 0;
 175 }
 176
 177 int sch56xx_read_virtual_reg(u16 addr, u16 reg)
 178 {
 179         return sch56xx_send_cmd(addr, SCH56XX_CMD_READ, reg, 0);
 180 }
 181 EXPORT_SYMBOL(sch56xx_read_virtual_reg);
 182
 183 int sch56xx_write_virtual_reg(u16 addr, u16 reg, u8 val)
 184 {
 185         return sch56xx_send_cmd(addr, SCH56XX_CMD_WRITE, reg, val);
 186 }
 187 EXPORT_SYMBOL(sch56xx_write_virtual_reg);
 188
 189 int sch56xx_read_virtual_reg16(u16 addr, u16 reg)
 190 {
 191         int lsb, msb;
 192
 193         /* Read LSB first, this will cause the matching MSB to be latched */
 194         lsb = sch56xx_read_virtual_reg(addr, reg);
 195         if (lsb < 0)
 196                 return lsb;
 197
 198         msb = sch56xx_read_virtual_reg(addr, reg + 1);
 199         if (msb < 0)
 200                 return msb;
 201
 202         return lsb | (msb << 8);
 203 }
 204 EXPORT_SYMBOL(sch56xx_read_virtual_reg16);
 205
 206 int sch56xx_read_virtual_reg12(u16 addr, u16 msb_reg, u16 lsn_reg,
 207                                int high_nibble)
 208 {
 209         int msb, lsn;
 210
 211         /* Read MSB first, this will cause the matching LSN to be latched */
 212         msb = sch56xx_read_virtual_reg(addr, msb_reg);
 213         if (msb < 0)
 214                 return msb;
 215
 216         lsn = sch56xx_read_virtual_reg(addr, lsn_reg);
 217         if (lsn < 0)
 218                 return lsn;
 219
 220         if (high_nibble)
 221                 return (msb << 4) | (lsn >> 4);
 222         else
 223                 return (msb << 4) | (lsn & 0x0f);
 224 }
 225 EXPORT_SYMBOL(sch56xx_read_virtual_reg12);
 226
 227 static int __init sch56xx_find(int sioaddr, unsigned short *address,
 228                                const char **name)
 229 {
 230         u8 devid;
 231         int err;
 232
 233         err = superio_enter(sioaddr);
 234         if (err)
 235                 return err;
 236
 237         devid = superio_inb(sioaddr, SIO_REG_DEVID);
 238         switch (devid) {
 239         case SIO_SCH5627_ID:
 240                 *name = "sch5627";
 241                 break;
 242         case SIO_SCH5636_ID:
 243                 *name = "sch5636";
 244                 break;
 245         default:
 246                 pr_debug("Unsupported device id: 0x%02x\n",
 247                          (unsigned int)devid);
 248                 err = -ENODEV;
 249                 goto exit;
 250         }
 251
 252         superio_select(sioaddr, SIO_SCH56XX_LD_EM);
 253
 254         if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) {
 255                 pr_warn("Device not activated\n");
 256                 err = -ENODEV;
 257                 goto exit;
 258         }
 259
 260         /*
 261          * Warning the order of the low / high byte is the other way around
 262          * as on most other superio devices!!
 263          */
 264         *address = superio_inb(sioaddr, SIO_REG_ADDR) |
 265                    superio_inb(sioaddr, SIO_REG_ADDR + 1) << 8;
 266         if (*address == 0) {
 267                 pr_warn("Base address not set\n");
 268                 err = -ENODEV;
 269                 goto exit;
 270         }
 271
 272 exit:
 273         superio_exit(sioaddr);
 274         return err;
 275 }
 276
 277 static int __init sch56xx_device_add(unsigned short address, const char *name)
 278 {
 279         struct resource res = {
 280                 .start  = address,
 281                 .end    = address + REGION_LENGTH - 1,
 282                 .flags  = IORESOURCE_IO,
 283         };
 284         int err;
 285
 286         sch56xx_pdev = platform_device_alloc(name, address);
 287         if (!sch56xx_pdev)
 288                 return -ENOMEM;
 289
 290         res.name = sch56xx_pdev->name;
 291         err = acpi_check_resource_conflict(&res);
 292         if (err)
 293                 goto exit_device_put;
 294
 295         err = platform_device_add_resources(sch56xx_pdev, &res, 1);
 296         if (err) {
 297                 pr_err("Device resource addition failed\n");
 298                 goto exit_device_put;
 299         }
 300
 301         err = platform_device_add(sch56xx_pdev);
 302         if (err) {
 303                 pr_err("Device addition failed\n");
 304                 goto exit_device_put;
 305         }
 306
 307         return 0;
 308
 309 exit_device_put:
 310         platform_device_put(sch56xx_pdev);
 311
 312         return err;
 313 }
 314
 315 static int __init sch56xx_init(void)
 316 {
 317         int err;
 318         unsigned short address;
 319         const char *name;
 320
 321         err = sch56xx_find(0x4e, &address, &name);
 322         if (err)
 323                 err = sch56xx_find(0x2e, &address, &name);
 324         if (err)
 325                 return err;
 326
 327         return sch56xx_device_add(address, name);
 328 }
 329
 330 static void __exit sch56xx_exit(void)
 331 {
 332         platform_device_unregister(sch56xx_pdev);
 333 }
 334
 335 MODULE_DESCRIPTION("SMSC SCH56xx Hardware Monitoring Common Code");
 336 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 337 MODULE_LICENSE("GPL");
 338
 339 module_init(sch56xx_init);
 340 module_exit(sch56xx_exit);