1 /* 2 * This program is free software; you can redistribute it and/or modify 3 * it under the terms of the GNU General Public License version 2 as 4 * published by the Free Software Foundation. 5 * 6 * This program is distributed in the hope that it will be useful, 7 * but WITHOUT ANY WARRANTY; without even the implied warranty of 8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 9 * GNU General Public License for more details. 10 * 11 * Copyright (C) 2012 ARM Limited 12 */ 13 14 #include <linux/err.h> 15 #include <linux/gpio.h> 16 #include <linux/io.h> 17 #include <linux/leds.h> 18 #include <linux/of_address.h> 19 #include <linux/platform_device.h> 20 #include <linux/regulator/driver.h> 21 #include <linux/slab.h> 22 #include <linux/stat.h> 23 #include <linux/timer.h> 24 #include <linux/vexpress.h> 25 26 #define SYS_ID 0x000 27 #define SYS_SW 0x004 28 #define SYS_LED 0x008 29 #define SYS_100HZ 0x024 30 #define SYS_FLAGS 0x030 31 #define SYS_FLAGSSET 0x030 32 #define SYS_FLAGSCLR 0x034 33 #define SYS_NVFLAGS 0x038 34 #define SYS_NVFLAGSSET 0x038 35 #define SYS_NVFLAGSCLR 0x03c 36 #define SYS_MCI 0x048 37 #define SYS_FLASH 0x04c 38 #define SYS_CFGSW 0x058 39 #define SYS_24MHZ 0x05c 40 #define SYS_MISC 0x060 41 #define SYS_DMA 0x064 42 #define SYS_PROCID0 0x084 43 #define SYS_PROCID1 0x088 44 #define SYS_CFGDATA 0x0a0 45 #define SYS_CFGCTRL 0x0a4 46 #define SYS_CFGSTAT 0x0a8 47 48 #define SYS_HBI_MASK 0xfff 49 #define SYS_ID_HBI_SHIFT 16 50 #define SYS_PROCIDx_HBI_SHIFT 0 51 52 #define SYS_LED_LED(n) (1 << (n)) 53 54 #define SYS_MCI_CARDIN (1 << 0) 55 #define SYS_MCI_WPROT (1 << 1) 56 57 #define SYS_FLASH_WPn (1 << 0) 58 59 #define SYS_MISC_MASTERSITE (1 << 14) 60 61 #define SYS_CFGCTRL_START (1 << 31) 62 #define SYS_CFGCTRL_WRITE (1 << 30) 63 #define SYS_CFGCTRL_DCC(n) (((n) & 0xf) << 26) 64 #define SYS_CFGCTRL_FUNC(n) (((n) & 0x3f) << 20) 65 #define SYS_CFGCTRL_SITE(n) (((n) & 0x3) << 16) 66 #define SYS_CFGCTRL_POSITION(n) (((n) & 0xf) << 12) 67 #define SYS_CFGCTRL_DEVICE(n) (((n) & 0xfff) << 0) 68 69 #define SYS_CFGSTAT_ERR (1 << 1) 70 #define SYS_CFGSTAT_COMPLETE (1 << 0) 71 72 73 static void __iomem *vexpress_sysreg_base; 74 static struct device *vexpress_sysreg_dev; 75 static int vexpress_master_site; 76 77 78 void vexpress_flags_set(u32 data) 79 { 80 writel(~0, vexpress_sysreg_base + SYS_FLAGSCLR); 81 writel(data, vexpress_sysreg_base + SYS_FLAGSSET); 82 } 83 84 u32 vexpress_get_procid(int site) 85 { 86 if (site == VEXPRESS_SITE_MASTER) 87 site = vexpress_master_site; 88 89 return readl(vexpress_sysreg_base + (site == VEXPRESS_SITE_DB1 ? 90 SYS_PROCID0 : SYS_PROCID1)); 91 } 92 93 u32 vexpress_get_hbi(int site) 94 { 95 u32 id; 96 97 switch (site) { 98 case VEXPRESS_SITE_MB: 99 id = readl(vexpress_sysreg_base + SYS_ID); 100 return (id >> SYS_ID_HBI_SHIFT) & SYS_HBI_MASK; 101 case VEXPRESS_SITE_MASTER: 102 case VEXPRESS_SITE_DB1: 103 case VEXPRESS_SITE_DB2: 104 id = vexpress_get_procid(site); 105 return (id >> SYS_PROCIDx_HBI_SHIFT) & SYS_HBI_MASK; 106 } 107 108 return ~0; 109 } 110 111 void __iomem *vexpress_get_24mhz_clock_base(void) 112 { 113 return vexpress_sysreg_base + SYS_24MHZ; 114 } 115 116 117 static void vexpress_sysreg_find_prop(struct device_node *node, 118 const char *name, u32 *val) 119 { 120 of_node_get(node); 121 while (node) { 122 if (of_property_read_u32(node, name, val) == 0) { 123 of_node_put(node); 124 return; 125 } 126 node = of_get_next_parent(node); 127 } 128 } 129 130 unsigned __vexpress_get_site(struct device *dev, struct device_node *node) 131 { 132 u32 site = 0; 133 134 WARN_ON(dev && node && dev->of_node != node); 135 if (dev && !node) 136 node = dev->of_node; 137 138 if (node) { 139 vexpress_sysreg_find_prop(node, "arm,vexpress,site", &site); 140 } else if (dev && dev->bus == &platform_bus_type) { 141 struct platform_device *pdev = to_platform_device(dev); 142 143 if (pdev->num_resources == 1 && 144 pdev->resource[0].flags == IORESOURCE_BUS) 145 site = pdev->resource[0].start; 146 } else if (dev && strncmp(dev_name(dev), "ct:", 3) == 0) { 147 site = VEXPRESS_SITE_MASTER; 148 } 149 150 if (site == VEXPRESS_SITE_MASTER) 151 site = vexpress_master_site; 152 153 return site; 154 } 155 156 157 struct vexpress_sysreg_config_func { 158 u32 template; 159 u32 device; 160 }; 161 162 static struct vexpress_config_bridge *vexpress_sysreg_config_bridge; 163 static struct timer_list vexpress_sysreg_config_timer; 164 static u32 *vexpress_sysreg_config_data; 165 static int vexpress_sysreg_config_tries; 166 167 static void *vexpress_sysreg_config_func_get(struct device *dev, 168 struct device_node *node) 169 { 170 struct vexpress_sysreg_config_func *config_func; 171 u32 site; 172 u32 position = 0; 173 u32 dcc = 0; 174 u32 func_device[2]; 175 int err = -EFAULT; 176 177 if (node) { 178 of_node_get(node); 179 vexpress_sysreg_find_prop(node, "arm,vexpress,site", &site); 180 vexpress_sysreg_find_prop(node, "arm,vexpress,position", 181 &position); 182 vexpress_sysreg_find_prop(node, "arm,vexpress,dcc", &dcc); 183 err = of_property_read_u32_array(node, 184 "arm,vexpress-sysreg,func", func_device, 185 ARRAY_SIZE(func_device)); 186 of_node_put(node); 187 } else if (dev && dev->bus == &platform_bus_type) { 188 struct platform_device *pdev = to_platform_device(dev); 189 190 if (pdev->num_resources == 1 && 191 pdev->resource[0].flags == IORESOURCE_BUS) { 192 site = pdev->resource[0].start; 193 func_device[0] = pdev->resource[0].end; 194 func_device[1] = pdev->id; 195 err = 0; 196 } 197 } 198 if (err) 199 return NULL; 200 201 config_func = kzalloc(sizeof(*config_func), GFP_KERNEL); 202 if (!config_func) 203 return NULL; 204 205 config_func->template = SYS_CFGCTRL_DCC(dcc); 206 config_func->template |= SYS_CFGCTRL_FUNC(func_device[0]); 207 config_func->template |= SYS_CFGCTRL_SITE(site == VEXPRESS_SITE_MASTER ? 208 vexpress_master_site : site); 209 config_func->template |= SYS_CFGCTRL_POSITION(position); 210 config_func->device |= func_device[1]; 211 212 dev_dbg(vexpress_sysreg_dev, "func 0x%p = 0x%x, %d\n", config_func, 213 config_func->template, config_func->device); 214 215 return config_func; 216 } 217 218 static void vexpress_sysreg_config_func_put(void *func) 219 { 220 kfree(func); 221 } 222 223 static int vexpress_sysreg_config_func_exec(void *func, int offset, 224 bool write, u32 *data) 225 { 226 int status; 227 struct vexpress_sysreg_config_func *config_func = func; 228 u32 command; 229 230 if (WARN_ON(!vexpress_sysreg_base)) 231 return -ENOENT; 232 233 command = readl(vexpress_sysreg_base + SYS_CFGCTRL); 234 if (WARN_ON(command & SYS_CFGCTRL_START)) 235 return -EBUSY; 236 237 command = SYS_CFGCTRL_START; 238 command |= write ? SYS_CFGCTRL_WRITE : 0; 239 command |= config_func->template; 240 command |= SYS_CFGCTRL_DEVICE(config_func->device + offset); 241 242 /* Use a canary for reads */ 243 if (!write) 244 *data = 0xdeadbeef; 245 246 dev_dbg(vexpress_sysreg_dev, "command %x, data %x\n", 247 command, *data); 248 writel(*data, vexpress_sysreg_base + SYS_CFGDATA); 249 writel(0, vexpress_sysreg_base + SYS_CFGSTAT); 250 writel(command, vexpress_sysreg_base + SYS_CFGCTRL); 251 mb(); 252 253 if (vexpress_sysreg_dev) { 254 /* Schedule completion check */ 255 if (!write) 256 vexpress_sysreg_config_data = data; 257 vexpress_sysreg_config_tries = 100; 258 mod_timer(&vexpress_sysreg_config_timer, 259 jiffies + usecs_to_jiffies(100)); 260 status = VEXPRESS_CONFIG_STATUS_WAIT; 261 } else { 262 /* Early execution, no timer available, have to spin */ 263 u32 cfgstat; 264 265 do { 266 cpu_relax(); 267 cfgstat = readl(vexpress_sysreg_base + SYS_CFGSTAT); 268 } while (!cfgstat); 269 270 if (!write && (cfgstat & SYS_CFGSTAT_COMPLETE)) 271 *data = readl(vexpress_sysreg_base + SYS_CFGDATA); 272 status = VEXPRESS_CONFIG_STATUS_DONE; 273 274 if (cfgstat & SYS_CFGSTAT_ERR) 275 status = -EINVAL; 276 } 277 278 return status; 279 } 280 281 struct vexpress_config_bridge_info vexpress_sysreg_config_bridge_info = { 282 .name = "vexpress-sysreg", 283 .func_get = vexpress_sysreg_config_func_get, 284 .func_put = vexpress_sysreg_config_func_put, 285 .func_exec = vexpress_sysreg_config_func_exec, 286 }; 287 288 static void vexpress_sysreg_config_complete(unsigned long data) 289 { 290 int status = VEXPRESS_CONFIG_STATUS_DONE; 291 u32 cfgstat = readl(vexpress_sysreg_base + SYS_CFGSTAT); 292 293 if (cfgstat & SYS_CFGSTAT_ERR) 294 status = -EINVAL; 295 if (!vexpress_sysreg_config_tries--) 296 status = -ETIMEDOUT; 297 298 if (status < 0) { 299 dev_err(vexpress_sysreg_dev, "error %d\n", status); 300 } else if (!(cfgstat & SYS_CFGSTAT_COMPLETE)) { 301 mod_timer(&vexpress_sysreg_config_timer, 302 jiffies + usecs_to_jiffies(50)); 303 return; 304 } 305 306 if (vexpress_sysreg_config_data) { 307 *vexpress_sysreg_config_data = readl(vexpress_sysreg_base + 308 SYS_CFGDATA); 309 dev_dbg(vexpress_sysreg_dev, "read data %x\n", 310 *vexpress_sysreg_config_data); 311 vexpress_sysreg_config_data = NULL; 312 } 313 314 vexpress_config_complete(vexpress_sysreg_config_bridge, status); 315 } 316 317 318 void vexpress_sysreg_setup(struct device_node *node) 319 { 320 if (WARN_ON(!vexpress_sysreg_base)) 321 return; 322 323 if (readl(vexpress_sysreg_base + SYS_MISC) & SYS_MISC_MASTERSITE) 324 vexpress_master_site = VEXPRESS_SITE_DB2; 325 else 326 vexpress_master_site = VEXPRESS_SITE_DB1; 327 328 vexpress_sysreg_config_bridge = vexpress_config_bridge_register( 329 node, &vexpress_sysreg_config_bridge_info); 330 WARN_ON(!vexpress_sysreg_config_bridge); 331 } 332 333 void __init vexpress_sysreg_early_init(void __iomem *base) 334 { 335 vexpress_sysreg_base = base; 336 vexpress_sysreg_setup(NULL); 337 } 338 339 void __init vexpress_sysreg_of_early_init(void) 340 { 341 struct device_node *node; 342 343 if (vexpress_sysreg_base) 344 return; 345 346 node = of_find_compatible_node(NULL, NULL, "arm,vexpress-sysreg"); 347 if (node) { 348 vexpress_sysreg_base = of_iomap(node, 0); 349 vexpress_sysreg_setup(node); 350 } 351 } 352 353 354 #define VEXPRESS_SYSREG_GPIO(_name, _reg, _value) \ 355 [VEXPRESS_GPIO_##_name] = { \ 356 .reg = _reg, \ 357 .value = _reg##_##_value, \ 358 } 359 360 static struct vexpress_sysreg_gpio { 361 unsigned long reg; 362 u32 value; 363 } vexpress_sysreg_gpios[] = { 364 VEXPRESS_SYSREG_GPIO(MMC_CARDIN, SYS_MCI, CARDIN), 365 VEXPRESS_SYSREG_GPIO(MMC_WPROT, SYS_MCI, WPROT), 366 VEXPRESS_SYSREG_GPIO(FLASH_WPn, SYS_FLASH, WPn), 367 VEXPRESS_SYSREG_GPIO(LED0, SYS_LED, LED(0)), 368 VEXPRESS_SYSREG_GPIO(LED1, SYS_LED, LED(1)), 369 VEXPRESS_SYSREG_GPIO(LED2, SYS_LED, LED(2)), 370 VEXPRESS_SYSREG_GPIO(LED3, SYS_LED, LED(3)), 371 VEXPRESS_SYSREG_GPIO(LED4, SYS_LED, LED(4)), 372 VEXPRESS_SYSREG_GPIO(LED5, SYS_LED, LED(5)), 373 VEXPRESS_SYSREG_GPIO(LED6, SYS_LED, LED(6)), 374 VEXPRESS_SYSREG_GPIO(LED7, SYS_LED, LED(7)), 375 }; 376 377 static int vexpress_sysreg_gpio_direction_input(struct gpio_chip *chip, 378 unsigned offset) 379 { 380 return 0; 381 } 382 383 static int vexpress_sysreg_gpio_get(struct gpio_chip *chip, 384 unsigned offset) 385 { 386 struct vexpress_sysreg_gpio *gpio = &vexpress_sysreg_gpios[offset]; 387 u32 reg_value = readl(vexpress_sysreg_base + gpio->reg); 388 389 return !!(reg_value & gpio->value); 390 } 391 392 static void vexpress_sysreg_gpio_set(struct gpio_chip *chip, 393 unsigned offset, int value) 394 { 395 struct vexpress_sysreg_gpio *gpio = &vexpress_sysreg_gpios[offset]; 396 u32 reg_value = readl(vexpress_sysreg_base + gpio->reg); 397 398 if (value) 399 reg_value |= gpio->value; 400 else 401 reg_value &= ~gpio->value; 402 403 writel(reg_value, vexpress_sysreg_base + gpio->reg); 404 } 405 406 static int vexpress_sysreg_gpio_direction_output(struct gpio_chip *chip, 407 unsigned offset, int value) 408 { 409 vexpress_sysreg_gpio_set(chip, offset, value); 410 411 return 0; 412 } 413 414 static struct gpio_chip vexpress_sysreg_gpio_chip = { 415 .label = "vexpress-sysreg", 416 .direction_input = vexpress_sysreg_gpio_direction_input, 417 .direction_output = vexpress_sysreg_gpio_direction_output, 418 .get = vexpress_sysreg_gpio_get, 419 .set = vexpress_sysreg_gpio_set, 420 .ngpio = ARRAY_SIZE(vexpress_sysreg_gpios), 421 .base = 0, 422 }; 423 424 425 #define VEXPRESS_SYSREG_GREEN_LED(_name, _default_trigger, _gpio) \ 426 { \ 427 .name = "v2m:green:"_name, \ 428 .default_trigger = _default_trigger, \ 429 .gpio = VEXPRESS_GPIO_##_gpio, \ 430 } 431 432 struct gpio_led vexpress_sysreg_leds[] = { 433 VEXPRESS_SYSREG_GREEN_LED("user1", "heartbeat", LED0), 434 VEXPRESS_SYSREG_GREEN_LED("user2", "mmc0", LED1), 435 VEXPRESS_SYSREG_GREEN_LED("user3", "cpu0", LED2), 436 VEXPRESS_SYSREG_GREEN_LED("user4", "cpu1", LED3), 437 VEXPRESS_SYSREG_GREEN_LED("user5", "cpu2", LED4), 438 VEXPRESS_SYSREG_GREEN_LED("user6", "cpu3", LED5), 439 VEXPRESS_SYSREG_GREEN_LED("user7", "cpu4", LED6), 440 VEXPRESS_SYSREG_GREEN_LED("user8", "cpu5", LED7), 441 }; 442 443 struct gpio_led_platform_data vexpress_sysreg_leds_pdata = { 444 .num_leds = ARRAY_SIZE(vexpress_sysreg_leds), 445 .leds = vexpress_sysreg_leds, 446 }; 447 448 449 static ssize_t vexpress_sysreg_sys_id_show(struct device *dev, 450 struct device_attribute *attr, char *buf) 451 { 452 return sprintf(buf, "0x%08x\n", readl(vexpress_sysreg_base + SYS_ID)); 453 } 454 455 DEVICE_ATTR(sys_id, S_IRUGO, vexpress_sysreg_sys_id_show, NULL); 456 457 static int vexpress_sysreg_probe(struct platform_device *pdev) 458 { 459 int err; 460 struct resource *res = platform_get_resource(pdev, 461 IORESOURCE_MEM, 0); 462 463 if (!devm_request_mem_region(&pdev->dev, res->start, 464 resource_size(res), pdev->name)) { 465 dev_err(&pdev->dev, "Failed to request memory region!\n"); 466 return -EBUSY; 467 } 468 469 if (!vexpress_sysreg_base) { 470 vexpress_sysreg_base = devm_ioremap(&pdev->dev, res->start, 471 resource_size(res)); 472 vexpress_sysreg_setup(pdev->dev.of_node); 473 } 474 475 if (!vexpress_sysreg_base) { 476 dev_err(&pdev->dev, "Failed to obtain base address!\n"); 477 return -EFAULT; 478 } 479 480 setup_timer(&vexpress_sysreg_config_timer, 481 vexpress_sysreg_config_complete, 0); 482 483 vexpress_sysreg_gpio_chip.dev = &pdev->dev; 484 err = gpiochip_add(&vexpress_sysreg_gpio_chip); 485 if (err) { 486 vexpress_config_bridge_unregister( 487 vexpress_sysreg_config_bridge); 488 dev_err(&pdev->dev, "Failed to register GPIO chip! (%d)\n", 489 err); 490 return err; 491 } 492 493 vexpress_sysreg_dev = &pdev->dev; 494 495 platform_device_register_data(vexpress_sysreg_dev, "leds-gpio", 496 PLATFORM_DEVID_AUTO, &vexpress_sysreg_leds_pdata, 497 sizeof(vexpress_sysreg_leds_pdata)); 498 499 device_create_file(vexpress_sysreg_dev, &dev_attr_sys_id); 500 501 return 0; 502 } 503 504 static const struct of_device_id vexpress_sysreg_match[] = { 505 { .compatible = "arm,vexpress-sysreg", }, 506 {}, 507 }; 508 509 static struct platform_driver vexpress_sysreg_driver = { 510 .driver = { 511 .name = "vexpress-sysreg", 512 .of_match_table = vexpress_sysreg_match, 513 }, 514 .probe = vexpress_sysreg_probe, 515 }; 516 517 static int __init vexpress_sysreg_init(void) 518 { 519 vexpress_sysreg_of_early_init(); 520 return platform_driver_register(&vexpress_sysreg_driver); 521 } 522 core_initcall(vexpress_sysreg_init); 523