drivers/platform/x86/ibm_rtl.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * IBM Real-Time Linux driver
   4  *
   5  * Copyright (C) IBM Corporation, 2010
   6  *
   7  * Author: Keith Mannthey <[email protected]>
   8  *         Vernon Mauery <[email protected]>
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/kernel.h>
  14 #include <linux/delay.h>
  15 #include <linux/module.h>
  16 #include <linux/io.h>
  17 #include <linux/dmi.h>
  18 #include <linux/efi.h>
  19 #include <linux/mutex.h>
  20 #include <asm/bios_ebda.h>
  21
  22 #include <linux/io-64-nonatomic-lo-hi.h>
  23
  24 static bool force;
  25 module_param(force, bool, 0);
  26 MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
  27
  28 static bool debug;
  29 module_param(debug, bool, 0644);
  30 MODULE_PARM_DESC(debug, "Show debug output");
  31
  32 MODULE_DESCRIPTION("IBM Premium Real Time Mode (PRTM) driver");
  33 MODULE_LICENSE("GPL");
  34 MODULE_AUTHOR("Keith Mannthey <[email protected]>");
  35 MODULE_AUTHOR("Vernon Mauery <[email protected]>");
  36
  37 #define RTL_ADDR_TYPE_IO    1
  38 #define RTL_ADDR_TYPE_MMIO  2
  39
  40 #define RTL_CMD_ENTER_PRTM  1
  41 #define RTL_CMD_EXIT_PRTM   2
  42
  43 /* The RTL table as presented by the EBDA: */
  44 struct ibm_rtl_table {
  45         char signature[5]; /* signature should be "_RTL_" */
  46         u8 version;
  47         u8 rt_status;
  48         u8 command;
  49         u8 command_status;
  50         u8 cmd_address_type;
  51         u8 cmd_granularity;
  52         u8 cmd_offset;
  53         u16 reserve1;
  54         u32 cmd_port_address; /* platform dependent address */
  55         u32 cmd_port_value;   /* platform dependent value */
  56 } __attribute__((packed));
  57
  58 /* to locate "_RTL_" signature do a masked 5-byte integer compare */
  59 #define RTL_SIGNATURE 0x0000005f4c54525fULL
  60 #define RTL_MASK      0x000000ffffffffffULL
  61
  62 #define RTL_DEBUG(fmt, ...)                             \
  63 do {                                                    \
  64         if (debug)                                      \
  65                 pr_info(fmt, ##__VA_ARGS__);            \
  66 } while (0)
  67
  68 static DEFINE_MUTEX(rtl_lock);
  69 static struct ibm_rtl_table __iomem *rtl_table;
  70 static void __iomem *ebda_map;
  71 static void __iomem *rtl_cmd_addr;
  72 static u8 rtl_cmd_type;
  73 static u8 rtl_cmd_width;
  74
  75 static void __iomem *rtl_port_map(phys_addr_t addr, unsigned long len)
  76 {
  77         if (rtl_cmd_type == RTL_ADDR_TYPE_MMIO)
  78                 return ioremap(addr, len);
  79         return ioport_map(addr, len);
  80 }
  81
  82 static void rtl_port_unmap(void __iomem *addr)
  83 {
  84         if (addr && rtl_cmd_type == RTL_ADDR_TYPE_MMIO)
  85                 iounmap(addr);
  86         else
  87                 ioport_unmap(addr);
  88 }
  89
  90 static int ibm_rtl_write(u8 value)
  91 {
  92         int ret = 0, count = 0;
  93         u32 cmd_port_val;
  94
  95         RTL_DEBUG("%s(%d)\n", __func__, value);
  96
  97         value = value == 1 ? RTL_CMD_ENTER_PRTM : RTL_CMD_EXIT_PRTM;
  98
  99         mutex_lock(&rtl_lock);
 100
 101         if (ioread8(&rtl_table->rt_status) != value) {
 102                 iowrite8(value, &rtl_table->command);
 103
 104                 switch (rtl_cmd_width) {
 105                 case 8:
 106                         cmd_port_val = ioread8(&rtl_table->cmd_port_value);
 107                         RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
 108                         iowrite8((u8)cmd_port_val, rtl_cmd_addr);
 109                         break;
 110                 case 16:
 111                         cmd_port_val = ioread16(&rtl_table->cmd_port_value);
 112                         RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
 113                         iowrite16((u16)cmd_port_val, rtl_cmd_addr);
 114                         break;
 115                 case 32:
 116                         cmd_port_val = ioread32(&rtl_table->cmd_port_value);
 117                         RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
 118                         iowrite32(cmd_port_val, rtl_cmd_addr);
 119                         break;
 120                 }
 121
 122                 while (ioread8(&rtl_table->command)) {
 123                         msleep(10);
 124                         if (count++ > 500) {
 125                                 pr_err("Hardware not responding to "
 126                                        "mode switch request\n");
 127                                 ret = -EIO;
 128                                 break;
 129                         }
 130
 131                 }
 132
 133                 if (ioread8(&rtl_table->command_status)) {
 134                         RTL_DEBUG("command_status reports failed command\n");
 135                         ret = -EIO;
 136                 }
 137         }
 138
 139         mutex_unlock(&rtl_lock);
 140         return ret;
 141 }
 142
 143 static ssize_t rtl_show_version(struct device *dev,
 144                                 struct device_attribute *attr,
 145                                 char *buf)
 146 {
 147         return sprintf(buf, "%d\n", (int)ioread8(&rtl_table->version));
 148 }
 149
 150 static ssize_t rtl_show_state(struct device *dev,
 151                               struct device_attribute *attr,
 152                               char *buf)
 153 {
 154         return sprintf(buf, "%d\n", ioread8(&rtl_table->rt_status));
 155 }
 156
 157 static ssize_t rtl_set_state(struct device *dev,
 158                              struct device_attribute *attr,
 159                              const char *buf,
 160                              size_t count)
 161 {
 162         ssize_t ret;
 163
 164         if (count < 1 || count > 2)
 165                 return -EINVAL;
 166
 167         switch (buf[0]) {
 168         case '0':
 169                 ret = ibm_rtl_write(0);
 170                 break;
 171         case '1':
 172                 ret = ibm_rtl_write(1);
 173                 break;
 174         default:
 175                 ret = -EINVAL;
 176         }
 177         if (ret >= 0)
 178                 ret = count;
 179
 180         return ret;
 181 }
 182
 183 static const struct bus_type rtl_subsys = {
 184         .name = "ibm_rtl",
 185         .dev_name = "ibm_rtl",
 186 };
 187
 188 static DEVICE_ATTR(version, S_IRUGO, rtl_show_version, NULL);
 189 static DEVICE_ATTR(state, 0600, rtl_show_state, rtl_set_state);
 190
 191 static struct device_attribute *rtl_attributes[] = {
 192         &dev_attr_version,
 193         &dev_attr_state,
 194         NULL
 195 };
 196
 197
 198 static int rtl_setup_sysfs(void) {
 199         int ret, i;
 200
 201         ret = subsys_system_register(&rtl_subsys, NULL);
 202         if (!ret) {
 203                 struct device *dev_root = bus_get_dev_root(&rtl_subsys);
 204
 205                 if (dev_root) {
 206                         for (i = 0; rtl_attributes[i]; i ++)
 207                                 device_create_file(dev_root, rtl_attributes[i]);
 208                         put_device(dev_root);
 209                 }
 210         }
 211         return ret;
 212 }
 213
 214 static void rtl_teardown_sysfs(void) {
 215         struct device *dev_root = bus_get_dev_root(&rtl_subsys);
 216         int i;
 217
 218         if (dev_root) {
 219                 for (i = 0; rtl_attributes[i]; i ++)
 220                         device_remove_file(dev_root, rtl_attributes[i]);
 221                 put_device(dev_root);
 222         }
 223         bus_unregister(&rtl_subsys);
 224 }
 225
 226
 227 static const struct dmi_system_id ibm_rtl_dmi_table[] __initconst = {
 228         {                                                  \
 229                 .matches = {                               \
 230                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),  \
 231                 },                                         \
 232         },
 233         { }
 234 };
 235
 236 static int __init ibm_rtl_init(void) {
 237         unsigned long ebda_addr, ebda_size;
 238         unsigned int ebda_kb;
 239         int ret = -ENODEV, i;
 240
 241         if (force)
 242                 pr_warn("module loaded by force\n");
 243         /* first ensure that we are running on IBM HW */
 244         else if (efi_enabled(EFI_BOOT) || !dmi_check_system(ibm_rtl_dmi_table))
 245                 return -ENODEV;
 246
 247         /* Get the address for the Extended BIOS Data Area */
 248         ebda_addr = get_bios_ebda();
 249         if (!ebda_addr) {
 250                 RTL_DEBUG("no BIOS EBDA found\n");
 251                 return -ENODEV;
 252         }
 253
 254         ebda_map = ioremap(ebda_addr, 4);
 255         if (!ebda_map)
 256                 return -ENOMEM;
 257
 258         /* First word in the EDBA is the Size in KB */
 259         ebda_kb = ioread16(ebda_map);
 260         RTL_DEBUG("EBDA is %d kB\n", ebda_kb);
 261
 262         if (ebda_kb == 0)
 263                 goto out;
 264
 265         iounmap(ebda_map);
 266         ebda_size = ebda_kb*1024;
 267
 268         /* Remap the whole table */
 269         ebda_map = ioremap(ebda_addr, ebda_size);
 270         if (!ebda_map)
 271                 return -ENOMEM;
 272
 273         /* search for the _RTL_ signature at the start of the table */
 274         for (i = 0 ; i < ebda_size/sizeof(unsigned int); i++) {
 275                 struct ibm_rtl_table __iomem * tmp;
 276                 tmp = (struct ibm_rtl_table __iomem *) (ebda_map+i);
 277                 if ((readq(&tmp->signature) & RTL_MASK) == RTL_SIGNATURE) {
 278                         phys_addr_t addr;
 279                         unsigned int plen;
 280                         RTL_DEBUG("found RTL_SIGNATURE at %p\n", tmp);
 281                         rtl_table = tmp;
 282                         /* The address, value, width and offset are platform
 283                          * dependent and found in the ibm_rtl_table */
 284                         rtl_cmd_width = ioread8(&rtl_table->cmd_granularity);
 285                         rtl_cmd_type = ioread8(&rtl_table->cmd_address_type);
 286                         RTL_DEBUG("rtl_cmd_width = %u, rtl_cmd_type = %u\n",
 287                                   rtl_cmd_width, rtl_cmd_type);
 288                         addr = ioread32(&rtl_table->cmd_port_address);
 289                         RTL_DEBUG("addr = %#llx\n", (unsigned long long)addr);
 290                         plen = rtl_cmd_width/sizeof(char);
 291                         rtl_cmd_addr = rtl_port_map(addr, plen);
 292                         RTL_DEBUG("rtl_cmd_addr = %p\n", rtl_cmd_addr);
 293                         if (!rtl_cmd_addr) {
 294                                 ret = -ENOMEM;
 295                                 break;
 296                         }
 297                         ret = rtl_setup_sysfs();
 298                         break;
 299                 }
 300         }
 301
 302 out:
 303         if (ret) {
 304                 iounmap(ebda_map);
 305                 rtl_port_unmap(rtl_cmd_addr);
 306         }
 307
 308         return ret;
 309 }
 310
 311 static void __exit ibm_rtl_exit(void)
 312 {
 313         if (rtl_table) {
 314                 RTL_DEBUG("cleaning up");
 315                 /* do not leave the machine in SMI-free mode */
 316                 ibm_rtl_write(0);
 317                 /* unmap, unlink and remove all traces */
 318                 rtl_teardown_sysfs();
 319                 iounmap(ebda_map);
 320                 rtl_port_unmap(rtl_cmd_addr);
 321         }
 322 }
 323
 324 module_init(ibm_rtl_init);
 325 module_exit(ibm_rtl_exit);