Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 1 | /* |
| 2 | * BCM947xx nvram variable access |
| 3 | * |
| 4 | * Copyright (C) 2005 Broadcom Corporation |
| 5 | * Copyright (C) 2006 Felix Fietkau <nbd@openwrt.org> |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 6 | * Copyright (C) 2010-2012 Hauke Mehrtens <hauke@hauke-m.de> |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 7 | * |
Ralf Baechle | 7034228 | 2013-01-22 12:59:30 +0100 | [diff] [blame] | 8 | * This program is free software; you can redistribute it and/or modify it |
| 9 | * under the terms of the GNU General Public License as published by the |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 10 | * Free Software Foundation; either version 2 of the License, or (at your |
| 11 | * option) any later version. |
| 12 | */ |
| 13 | |
Rafał Miłecki | 50c9791 | 2015-04-01 08:23:03 +0200 | [diff] [blame] | 14 | #include <linux/io.h> |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 15 | #include <linux/types.h> |
| 16 | #include <linux/module.h> |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 17 | #include <linux/kernel.h> |
| 18 | #include <linux/string.h> |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 19 | #include <linux/mtd/mtd.h> |
Rafał Miłecki | 138173d | 2014-12-01 07:58:18 +0100 | [diff] [blame] | 20 | #include <linux/bcm47xx_nvram.h> |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 21 | |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 22 | #define NVRAM_MAGIC 0x48534C46 /* 'FLSH' */ |
Rafał Miłecki | 6ab7c29 | 2015-04-01 08:23:04 +0200 | [diff] [blame] | 23 | #define NVRAM_SPACE 0x10000 |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 24 | #define NVRAM_MAX_GPIO_ENTRIES 32 |
| 25 | #define NVRAM_MAX_GPIO_VALUE_LEN 30 |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 26 | |
| 27 | #define FLASH_MIN 0x00020000 /* Minimum flash size */ |
| 28 | |
| 29 | struct nvram_header { |
| 30 | u32 magic; |
| 31 | u32 len; |
| 32 | u32 crc_ver_init; /* 0:7 crc, 8:15 ver, 16:31 sdram_init */ |
| 33 | u32 config_refresh; /* 0:15 sdram_config, 16:31 sdram_refresh */ |
| 34 | u32 config_ncdl; /* ncdl values for memc */ |
| 35 | }; |
| 36 | |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 37 | static char nvram_buf[NVRAM_SPACE]; |
Hauke Mehrtens | f4c4d58 | 2013-10-13 22:56:50 +0200 | [diff] [blame] | 38 | static const u32 nvram_sizes[] = {0x8000, 0xF000, 0x10000}; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 39 | |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 40 | static u32 find_nvram_size(void __iomem *end) |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 41 | { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 42 | struct nvram_header __iomem *header; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 43 | int i; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 44 | |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 45 | for (i = 0; i < ARRAY_SIZE(nvram_sizes); i++) { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 46 | header = (struct nvram_header *)(end - nvram_sizes[i]); |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 47 | if (header->magic == NVRAM_MAGIC) |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 48 | return nvram_sizes[i]; |
Hauke Mehrtens | 08ccf572 | 2011-07-23 01:20:12 +0200 | [diff] [blame] | 49 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 50 | |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 51 | return 0; |
| 52 | } |
| 53 | |
| 54 | /* Probe for NVRAM header */ |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 55 | static int nvram_find_and_copy(void __iomem *iobase, u32 lim) |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 56 | { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 57 | struct nvram_header __iomem *header; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 58 | int i; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 59 | u32 off; |
| 60 | u32 *src, *dst; |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 61 | u32 size; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 62 | |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 63 | if (nvram_buf[0]) { |
| 64 | pr_warn("nvram already initialized\n"); |
| 65 | return -EEXIST; |
| 66 | } |
| 67 | |
Hauke Mehrtens | c448567 | 2012-12-26 19:51:11 +0000 | [diff] [blame] | 68 | /* TODO: when nvram is on nand flash check for bad blocks first. */ |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 69 | off = FLASH_MIN; |
| 70 | while (off <= lim) { |
| 71 | /* Windowed flash access */ |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 72 | size = find_nvram_size(iobase + off); |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 73 | if (size) { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 74 | header = (struct nvram_header *)(iobase + off - size); |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 75 | goto found; |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 76 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 77 | off <<= 1; |
| 78 | } |
| 79 | |
| 80 | /* Try embedded NVRAM at 4 KB and 1 KB as last resorts */ |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 81 | header = (struct nvram_header *)(iobase + 4096); |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 82 | if (header->magic == NVRAM_MAGIC) { |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 83 | size = NVRAM_SPACE; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 84 | goto found; |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 85 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 86 | |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 87 | header = (struct nvram_header *)(iobase + 1024); |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 88 | if (header->magic == NVRAM_MAGIC) { |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 89 | size = NVRAM_SPACE; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 90 | goto found; |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 91 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 92 | |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 93 | pr_err("no nvram found\n"); |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 94 | return -ENXIO; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 95 | |
| 96 | found: |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 97 | if (header->len > size) |
| 98 | pr_err("The nvram size accoridng to the header seems to be bigger than the partition on flash\n"); |
| 99 | if (header->len > NVRAM_SPACE) |
| 100 | pr_err("nvram on flash (%i bytes) is bigger than the reserved space in memory, will just copy the first %i bytes\n", |
| 101 | header->len, NVRAM_SPACE); |
| 102 | |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 103 | src = (u32 *)header; |
| 104 | dst = (u32 *)nvram_buf; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 105 | for (i = 0; i < sizeof(struct nvram_header); i += 4) |
Rafał Miłecki | 23d2bc4 | 2014-12-10 11:49:53 +0100 | [diff] [blame] | 106 | *dst++ = __raw_readl(src++); |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 107 | for (; i < header->len && i < NVRAM_SPACE && i < size; i += 4) |
Rafał Miłecki | 23d2bc4 | 2014-12-10 11:49:53 +0100 | [diff] [blame] | 108 | *dst++ = readl(src++); |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 109 | |
| 110 | return 0; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 111 | } |
| 112 | |
Rafał Miłecki | 21400f2 | 2014-09-03 22:59:45 +0200 | [diff] [blame] | 113 | /* |
| 114 | * On bcm47xx we need access to the NVRAM very early, so we can't use mtd |
| 115 | * subsystem to access flash. We can't even use platform device / driver to |
| 116 | * store memory offset. |
| 117 | * To handle this we provide following symbol. It's supposed to be called as |
| 118 | * soon as we get info about flash device, before any NVRAM entry is needed. |
| 119 | */ |
| 120 | int bcm47xx_nvram_init_from_mem(u32 base, u32 lim) |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 121 | { |
| 122 | void __iomem *iobase; |
| 123 | int err; |
| 124 | |
| 125 | iobase = ioremap_nocache(base, lim); |
| 126 | if (!iobase) |
| 127 | return -ENOMEM; |
| 128 | |
| 129 | err = nvram_find_and_copy(iobase, lim); |
| 130 | |
| 131 | iounmap(iobase); |
| 132 | |
| 133 | return err; |
| 134 | } |
| 135 | |
Hauke Mehrtens | e58da16 | 2012-12-26 19:51:12 +0000 | [diff] [blame] | 136 | static int nvram_init(void) |
Rafał Miłecki | bb76563 | 2012-12-26 08:29:17 +0000 | [diff] [blame] | 137 | { |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 138 | #ifdef CONFIG_MTD |
| 139 | struct mtd_info *mtd; |
| 140 | struct nvram_header header; |
| 141 | size_t bytes_read; |
Rafał Miłecki | 40d1217 | 2015-04-01 08:23:05 +0200 | [diff] [blame] | 142 | int err; |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 143 | |
| 144 | mtd = get_mtd_device_nm("nvram"); |
| 145 | if (IS_ERR(mtd)) |
| 146 | return -ENODEV; |
| 147 | |
Rafał Miłecki | 40d1217 | 2015-04-01 08:23:05 +0200 | [diff] [blame] | 148 | err = mtd_read(mtd, 0, sizeof(header), &bytes_read, (uint8_t *)&header); |
| 149 | if (!err && header.magic == NVRAM_MAGIC) { |
| 150 | u8 *dst = (uint8_t *)nvram_buf; |
| 151 | size_t len = header.len; |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 152 | |
Rafał Miłecki | 40d1217 | 2015-04-01 08:23:05 +0200 | [diff] [blame] | 153 | if (header.len > NVRAM_SPACE) { |
| 154 | pr_err("nvram on flash (%i bytes) is bigger than the reserved space in memory, will just copy the first %i bytes\n", |
| 155 | header.len, NVRAM_SPACE); |
| 156 | len = NVRAM_SPACE; |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 157 | } |
Rafał Miłecki | 40d1217 | 2015-04-01 08:23:05 +0200 | [diff] [blame] | 158 | |
| 159 | err = mtd_read(mtd, 0, len, &bytes_read, dst); |
| 160 | if (err) |
| 161 | return err; |
| 162 | |
| 163 | return 0; |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 164 | } |
| 165 | #endif |
Rafał Miłecki | 7177efc | 2014-10-28 13:30:23 +0100 | [diff] [blame] | 166 | |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 167 | return -ENXIO; |
Rafał Miłecki | bb76563 | 2012-12-26 08:29:17 +0000 | [diff] [blame] | 168 | } |
| 169 | |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 170 | int bcm47xx_nvram_getenv(const char *name, char *val, size_t val_len) |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 171 | { |
| 172 | char *var, *value, *end, *eq; |
Rafał Miłecki | 80aaaa8 | 2014-12-10 11:49:54 +0100 | [diff] [blame] | 173 | int data_left, err; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 174 | |
| 175 | if (!name) |
Hauke Mehrtens | ee7e2f3 | 2012-12-26 19:51:09 +0000 | [diff] [blame] | 176 | return -EINVAL; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 177 | |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 178 | if (!nvram_buf[0]) { |
Hauke Mehrtens | e58da16 | 2012-12-26 19:51:12 +0000 | [diff] [blame] | 179 | err = nvram_init(); |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 180 | if (err) |
| 181 | return err; |
| 182 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 183 | |
| 184 | /* Look for name=value and return value */ |
| 185 | var = &nvram_buf[sizeof(struct nvram_header)]; |
| 186 | end = nvram_buf + sizeof(nvram_buf) - 2; |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 187 | end[0] = '\0'; |
| 188 | end[1] = '\0'; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 189 | for (; *var; var = value + strlen(value) + 1) { |
Rafał Miłecki | 80aaaa8 | 2014-12-10 11:49:54 +0100 | [diff] [blame] | 190 | data_left = end - var; |
| 191 | |
| 192 | eq = strnchr(var, data_left, '='); |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 193 | if (!eq) |
| 194 | break; |
| 195 | value = eq + 1; |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 196 | if (eq - var == strlen(name) && |
| 197 | strncmp(var, name, eq - var) == 0) |
Hauke Mehrtens | 44d4b2a | 2012-02-28 00:56:11 +0100 | [diff] [blame] | 198 | return snprintf(val, val_len, "%s", value); |
Rafał Miłecki | 50c9791 | 2015-04-01 08:23:03 +0200 | [diff] [blame] | 199 | } |
Hauke Mehrtens | ee7e2f3 | 2012-12-26 19:51:09 +0000 | [diff] [blame] | 200 | return -ENOENT; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 201 | } |
Hauke Mehrtens | 111bd98 | 2012-12-26 19:51:14 +0000 | [diff] [blame] | 202 | EXPORT_SYMBOL(bcm47xx_nvram_getenv); |
Hauke Mehrtens | 62cf3bc | 2013-09-18 13:31:15 +0200 | [diff] [blame] | 203 | |
| 204 | int bcm47xx_nvram_gpio_pin(const char *name) |
| 205 | { |
| 206 | int i, err; |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 207 | char nvram_var[] = "gpioXX"; |
| 208 | char buf[NVRAM_MAX_GPIO_VALUE_LEN]; |
Hauke Mehrtens | 62cf3bc | 2013-09-18 13:31:15 +0200 | [diff] [blame] | 209 | |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 210 | /* TODO: Optimize it to don't call getenv so many times */ |
| 211 | for (i = 0; i < NVRAM_MAX_GPIO_ENTRIES; i++) { |
Hauke Mehrtens | 62cf3bc | 2013-09-18 13:31:15 +0200 | [diff] [blame] | 212 | err = snprintf(nvram_var, sizeof(nvram_var), "gpio%i", i); |
| 213 | if (err <= 0) |
| 214 | continue; |
| 215 | err = bcm47xx_nvram_getenv(nvram_var, buf, sizeof(buf)); |
| 216 | if (err <= 0) |
| 217 | continue; |
| 218 | if (!strcmp(name, buf)) |
| 219 | return i; |
| 220 | } |
| 221 | return -ENOENT; |
| 222 | } |
| 223 | EXPORT_SYMBOL(bcm47xx_nvram_gpio_pin); |