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]; |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 38 | static size_t nvram_len; |
Hauke Mehrtens | f4c4d58 | 2013-10-13 22:56:50 +0200 | [diff] [blame] | 39 | static const u32 nvram_sizes[] = {0x8000, 0xF000, 0x10000}; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 40 | |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 41 | static u32 find_nvram_size(void __iomem *end) |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 42 | { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 43 | struct nvram_header __iomem *header; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 44 | int i; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 45 | |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 46 | for (i = 0; i < ARRAY_SIZE(nvram_sizes); i++) { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 47 | header = (struct nvram_header *)(end - nvram_sizes[i]); |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 48 | if (header->magic == NVRAM_MAGIC) |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 49 | return nvram_sizes[i]; |
Hauke Mehrtens | 08ccf572 | 2011-07-23 01:20:12 +0200 | [diff] [blame] | 50 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 51 | |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 52 | return 0; |
| 53 | } |
| 54 | |
| 55 | /* Probe for NVRAM header */ |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 56 | static int nvram_find_and_copy(void __iomem *iobase, u32 lim) |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 57 | { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 58 | struct nvram_header __iomem *header; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 59 | u32 off; |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 60 | u32 size; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 61 | |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 62 | if (nvram_len) { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 63 | pr_warn("nvram already initialized\n"); |
| 64 | return -EEXIST; |
| 65 | } |
| 66 | |
Hauke Mehrtens | c448567 | 2012-12-26 19:51:11 +0000 | [diff] [blame] | 67 | /* TODO: when nvram is on nand flash check for bad blocks first. */ |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 68 | off = FLASH_MIN; |
| 69 | while (off <= lim) { |
| 70 | /* Windowed flash access */ |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 71 | size = find_nvram_size(iobase + off); |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 72 | if (size) { |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 73 | header = (struct nvram_header *)(iobase + off - size); |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 74 | goto found; |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 75 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 76 | off <<= 1; |
| 77 | } |
| 78 | |
| 79 | /* 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] | 80 | header = (struct nvram_header *)(iobase + 4096); |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 81 | if (header->magic == NVRAM_MAGIC) { |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 82 | size = NVRAM_SPACE; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 83 | goto found; |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 84 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 85 | |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 86 | header = (struct nvram_header *)(iobase + 1024); |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 87 | if (header->magic == NVRAM_MAGIC) { |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 88 | size = NVRAM_SPACE; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 89 | goto found; |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 90 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 91 | |
Hauke Mehrtens | f36738d | 2012-12-26 19:51:13 +0000 | [diff] [blame] | 92 | pr_err("no nvram found\n"); |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 93 | return -ENXIO; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 94 | |
| 95 | found: |
Stephen Boyd | 1f330c3 | 2016-01-20 14:58:41 -0800 | [diff] [blame] | 96 | __ioread32_copy(nvram_buf, header, sizeof(*header) / 4); |
Aaro Koskinen | 4c11e55 | 2016-03-17 14:17:20 -0700 | [diff] [blame] | 97 | nvram_len = ((struct nvram_header *)(nvram_buf))->len; |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 98 | if (nvram_len > size) { |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 99 | pr_err("The nvram size according to the header seems to be bigger than the partition on flash\n"); |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 100 | nvram_len = size; |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 101 | } |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 102 | if (nvram_len >= NVRAM_SPACE) { |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 103 | pr_err("nvram on flash (%i bytes) is bigger than the reserved space in memory, will just copy the first %i bytes\n", |
Aaro Koskinen | 4c11e55 | 2016-03-17 14:17:20 -0700 | [diff] [blame] | 104 | nvram_len, NVRAM_SPACE - 1); |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 105 | nvram_len = NVRAM_SPACE - 1; |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 106 | } |
| 107 | /* proceed reading data after header */ |
Stephen Boyd | 1f330c3 | 2016-01-20 14:58:41 -0800 | [diff] [blame] | 108 | __ioread32_copy(nvram_buf + sizeof(*header), header + 1, |
| 109 | DIV_ROUND_UP(nvram_len, 4)); |
Rafał Miłecki | d28c9a5 | 2015-05-12 18:46:11 +0200 | [diff] [blame] | 110 | nvram_buf[NVRAM_SPACE - 1] = '\0'; |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 111 | |
| 112 | return 0; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 113 | } |
| 114 | |
Rafał Miłecki | 21400f2 | 2014-09-03 22:59:45 +0200 | [diff] [blame] | 115 | /* |
| 116 | * On bcm47xx we need access to the NVRAM very early, so we can't use mtd |
| 117 | * subsystem to access flash. We can't even use platform device / driver to |
| 118 | * store memory offset. |
| 119 | * To handle this we provide following symbol. It's supposed to be called as |
| 120 | * soon as we get info about flash device, before any NVRAM entry is needed. |
| 121 | */ |
| 122 | int bcm47xx_nvram_init_from_mem(u32 base, u32 lim) |
Rafał Miłecki | 8d602dd | 2014-09-03 22:51:06 +0200 | [diff] [blame] | 123 | { |
| 124 | void __iomem *iobase; |
| 125 | int err; |
| 126 | |
| 127 | iobase = ioremap_nocache(base, lim); |
| 128 | if (!iobase) |
| 129 | return -ENOMEM; |
| 130 | |
| 131 | err = nvram_find_and_copy(iobase, lim); |
| 132 | |
| 133 | iounmap(iobase); |
| 134 | |
| 135 | return err; |
| 136 | } |
| 137 | |
Hauke Mehrtens | e58da16 | 2012-12-26 19:51:12 +0000 | [diff] [blame] | 138 | static int nvram_init(void) |
Rafał Miłecki | bb76563 | 2012-12-26 08:29:17 +0000 | [diff] [blame] | 139 | { |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 140 | #ifdef CONFIG_MTD |
| 141 | struct mtd_info *mtd; |
| 142 | struct nvram_header header; |
| 143 | size_t bytes_read; |
Rafał Miłecki | 40d1217 | 2015-04-01 08:23:05 +0200 | [diff] [blame] | 144 | int err; |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 145 | |
| 146 | mtd = get_mtd_device_nm("nvram"); |
| 147 | if (IS_ERR(mtd)) |
| 148 | return -ENODEV; |
| 149 | |
Rafał Miłecki | 40d1217 | 2015-04-01 08:23:05 +0200 | [diff] [blame] | 150 | err = mtd_read(mtd, 0, sizeof(header), &bytes_read, (uint8_t *)&header); |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 151 | if (!err && header.magic == NVRAM_MAGIC && |
| 152 | header.len > sizeof(header)) { |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 153 | nvram_len = header.len; |
| 154 | if (nvram_len >= NVRAM_SPACE) { |
Rafał Miłecki | 40d1217 | 2015-04-01 08:23:05 +0200 | [diff] [blame] | 155 | pr_err("nvram on flash (%i bytes) is bigger than the reserved space in memory, will just copy the first %i bytes\n", |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 156 | header.len, NVRAM_SPACE); |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 157 | nvram_len = NVRAM_SPACE - 1; |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 158 | } |
Rafał Miłecki | 40d1217 | 2015-04-01 08:23:05 +0200 | [diff] [blame] | 159 | |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 160 | err = mtd_read(mtd, 0, nvram_len, &nvram_len, |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 161 | (u8 *)nvram_buf); |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 162 | return err; |
Rafał Miłecki | 9d1d086 | 2014-10-29 10:05:06 +0100 | [diff] [blame] | 163 | } |
| 164 | #endif |
Rafał Miłecki | 7177efc | 2014-10-28 13:30:23 +0100 | [diff] [blame] | 165 | |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 166 | return -ENXIO; |
Rafał Miłecki | bb76563 | 2012-12-26 08:29:17 +0000 | [diff] [blame] | 167 | } |
| 168 | |
Rafał Miłecki | 341097f | 2014-10-30 12:50:03 +0100 | [diff] [blame] | 169 | 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] | 170 | { |
| 171 | char *var, *value, *end, *eq; |
Rafał Miłecki | 5bfad4ee | 2015-05-12 18:46:12 +0200 | [diff] [blame] | 172 | int err; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 173 | |
| 174 | if (!name) |
Hauke Mehrtens | ee7e2f3 | 2012-12-26 19:51:09 +0000 | [diff] [blame] | 175 | return -EINVAL; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 176 | |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 177 | if (!nvram_len) { |
Hauke Mehrtens | e58da16 | 2012-12-26 19:51:12 +0000 | [diff] [blame] | 178 | err = nvram_init(); |
Hauke Mehrtens | cc4403e | 2012-12-26 19:51:10 +0000 | [diff] [blame] | 179 | if (err) |
| 180 | return err; |
| 181 | } |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 182 | |
| 183 | /* Look for name=value and return value */ |
| 184 | var = &nvram_buf[sizeof(struct nvram_header)]; |
Rafał Miłecki | 5bfad4ee | 2015-05-12 18:46:12 +0200 | [diff] [blame] | 185 | end = nvram_buf + sizeof(nvram_buf); |
| 186 | while (var < end && *var) { |
| 187 | eq = strchr(var, '='); |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 188 | if (!eq) |
| 189 | break; |
| 190 | value = eq + 1; |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 191 | if (eq - var == strlen(name) && |
| 192 | strncmp(var, name, eq - var) == 0) |
Hauke Mehrtens | 44d4b2a | 2012-02-28 00:56:11 +0100 | [diff] [blame] | 193 | return snprintf(val, val_len, "%s", value); |
Rafał Miłecki | 5bfad4ee | 2015-05-12 18:46:12 +0200 | [diff] [blame] | 194 | var = value + strlen(value) + 1; |
Rafał Miłecki | 50c9791 | 2015-04-01 08:23:03 +0200 | [diff] [blame] | 195 | } |
Hauke Mehrtens | ee7e2f3 | 2012-12-26 19:51:09 +0000 | [diff] [blame] | 196 | return -ENOENT; |
Waldemar Brodkorb | 121915c | 2010-06-08 19:06:01 +0200 | [diff] [blame] | 197 | } |
Hauke Mehrtens | 111bd98 | 2012-12-26 19:51:14 +0000 | [diff] [blame] | 198 | EXPORT_SYMBOL(bcm47xx_nvram_getenv); |
Hauke Mehrtens | 62cf3bc | 2013-09-18 13:31:15 +0200 | [diff] [blame] | 199 | |
| 200 | int bcm47xx_nvram_gpio_pin(const char *name) |
| 201 | { |
| 202 | int i, err; |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 203 | char nvram_var[] = "gpioXX"; |
| 204 | char buf[NVRAM_MAX_GPIO_VALUE_LEN]; |
Hauke Mehrtens | 62cf3bc | 2013-09-18 13:31:15 +0200 | [diff] [blame] | 205 | |
Rafał Miłecki | d548ca6 | 2014-12-10 17:38:26 +0100 | [diff] [blame] | 206 | /* TODO: Optimize it to don't call getenv so many times */ |
| 207 | for (i = 0; i < NVRAM_MAX_GPIO_ENTRIES; i++) { |
Hauke Mehrtens | 62cf3bc | 2013-09-18 13:31:15 +0200 | [diff] [blame] | 208 | err = snprintf(nvram_var, sizeof(nvram_var), "gpio%i", i); |
| 209 | if (err <= 0) |
| 210 | continue; |
| 211 | err = bcm47xx_nvram_getenv(nvram_var, buf, sizeof(buf)); |
| 212 | if (err <= 0) |
| 213 | continue; |
| 214 | if (!strcmp(name, buf)) |
| 215 | return i; |
| 216 | } |
| 217 | return -ENOENT; |
| 218 | } |
| 219 | EXPORT_SYMBOL(bcm47xx_nvram_gpio_pin); |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 220 | |
| 221 | char *bcm47xx_nvram_get_contents(size_t *nvram_size) |
| 222 | { |
| 223 | int err; |
| 224 | char *nvram; |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 225 | |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 226 | if (!nvram_len) { |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 227 | err = nvram_init(); |
| 228 | if (err) |
| 229 | return NULL; |
| 230 | } |
| 231 | |
Rafał Miłecki | 94a0535 | 2015-06-06 23:16:23 +0200 | [diff] [blame] | 232 | *nvram_size = nvram_len - sizeof(struct nvram_header); |
Hante Meuleman | 55cab93b | 2015-05-21 15:27:23 +0200 | [diff] [blame] | 233 | nvram = vmalloc(*nvram_size); |
| 234 | if (!nvram) |
| 235 | return NULL; |
| 236 | memcpy(nvram, &nvram_buf[sizeof(struct nvram_header)], *nvram_size); |
| 237 | |
| 238 | return nvram; |
| 239 | } |
| 240 | EXPORT_SYMBOL(bcm47xx_nvram_get_contents); |
Rafał Miłecki | f6e734a | 2015-06-10 23:05:08 +0200 | [diff] [blame] | 241 | |
Axel Lin | 72ccc89 | 2015-08-19 10:32:23 +0800 | [diff] [blame] | 242 | MODULE_LICENSE("GPL v2"); |