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