1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (c) 2001 Maciej W. Rozycki 4 */ 5 6 #include <linux/init.h> 7 #include <linux/ioport.h> 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/mtd/mtd.h> 11 #include <linux/slab.h> 12 #include <linux/types.h> 13 14 #include <asm/addrspace.h> 15 #include <asm/bootinfo.h> 16 #include <asm/dec/ioasic_addrs.h> 17 #include <asm/dec/kn02.h> 18 #include <asm/dec/kn03.h> 19 #include <asm/io.h> 20 #include <asm/paccess.h> 21 22 #include "ms02-nv.h" 23 24 25 static char version[] __initdata = 26 "ms02-nv.c: v.1.0.0 13 Aug 2001 Maciej W. Rozycki.\n"; 27 28 MODULE_AUTHOR("Maciej W. Rozycki <macro@linux-mips.org>"); 29 MODULE_DESCRIPTION("DEC MS02-NV NVRAM module driver"); 30 MODULE_LICENSE("GPL"); 31 32 33 /* 34 * Addresses we probe for an MS02-NV at. Modules may be located 35 * at any 8MiB boundary within a 0MiB up to 112MiB range or at any 32MiB 36 * boundary within a 0MiB up to 448MiB range. We don't support a module 37 * at 0MiB, though. 38 */ 39 static ulong ms02nv_addrs[] __initdata = { 40 0x07000000, 0x06800000, 0x06000000, 0x05800000, 0x05000000, 41 0x04800000, 0x04000000, 0x03800000, 0x03000000, 0x02800000, 42 0x02000000, 0x01800000, 0x01000000, 0x00800000 43 }; 44 45 static const char ms02nv_name[] = "DEC MS02-NV NVRAM"; 46 static const char ms02nv_res_diag_ram[] = "Diagnostic RAM"; 47 static const char ms02nv_res_user_ram[] = "General-purpose RAM"; 48 static const char ms02nv_res_csr[] = "Control and status register"; 49 50 static struct mtd_info *root_ms02nv_mtd; 51 52 53 static int ms02nv_read(struct mtd_info *mtd, loff_t from, 54 size_t len, size_t *retlen, u_char *buf) 55 { 56 struct ms02nv_private *mp = mtd->priv; 57 58 memcpy(buf, mp->uaddr + from, len); 59 *retlen = len; 60 return 0; 61 } 62 63 static int ms02nv_write(struct mtd_info *mtd, loff_t to, 64 size_t len, size_t *retlen, const u_char *buf) 65 { 66 struct ms02nv_private *mp = mtd->priv; 67 68 memcpy(mp->uaddr + to, buf, len); 69 *retlen = len; 70 return 0; 71 } 72 73 74 static inline uint ms02nv_probe_one(ulong addr) 75 { 76 ms02nv_uint *ms02nv_diagp; 77 ms02nv_uint *ms02nv_magicp; 78 uint ms02nv_diag; 79 uint ms02nv_magic; 80 size_t size; 81 82 int err; 83 84 /* 85 * The firmware writes MS02NV_ID at MS02NV_MAGIC and also 86 * a diagnostic status at MS02NV_DIAG. 87 */ 88 ms02nv_diagp = (ms02nv_uint *)(CKSEG1ADDR(addr + MS02NV_DIAG)); 89 ms02nv_magicp = (ms02nv_uint *)(CKSEG1ADDR(addr + MS02NV_MAGIC)); 90 err = get_dbe(ms02nv_magic, ms02nv_magicp); 91 if (err) 92 return 0; 93 if (ms02nv_magic != MS02NV_ID) 94 return 0; 95 96 ms02nv_diag = *ms02nv_diagp; 97 size = (ms02nv_diag & MS02NV_DIAG_SIZE_MASK) << MS02NV_DIAG_SIZE_SHIFT; 98 if (size > MS02NV_CSR) 99 size = MS02NV_CSR; 100 101 return size; 102 } 103 104 static int __init ms02nv_init_one(ulong addr) 105 { 106 struct mtd_info *mtd; 107 struct ms02nv_private *mp; 108 struct resource *mod_res; 109 struct resource *diag_res; 110 struct resource *user_res; 111 struct resource *csr_res; 112 ulong fixaddr; 113 size_t size, fixsize; 114 115 static int version_printed; 116 117 int ret = -ENODEV; 118 119 /* The module decodes 8MiB of address space. */ 120 mod_res = kzalloc(sizeof(*mod_res), GFP_KERNEL); 121 if (!mod_res) 122 return -ENOMEM; 123 124 mod_res->name = ms02nv_name; 125 mod_res->start = addr; 126 mod_res->end = addr + MS02NV_SLOT_SIZE - 1; 127 mod_res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 128 if (request_resource(&iomem_resource, mod_res) < 0) 129 goto err_out_mod_res; 130 131 size = ms02nv_probe_one(addr); 132 if (!size) 133 goto err_out_mod_res_rel; 134 135 if (!version_printed) { 136 printk(KERN_INFO "%s", version); 137 version_printed = 1; 138 } 139 140 ret = -ENOMEM; 141 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL); 142 if (!mtd) 143 goto err_out_mod_res_rel; 144 mp = kzalloc(sizeof(*mp), GFP_KERNEL); 145 if (!mp) 146 goto err_out_mtd; 147 148 mtd->priv = mp; 149 mp->resource.module = mod_res; 150 151 /* Firmware's diagnostic NVRAM area. */ 152 diag_res = kzalloc(sizeof(*diag_res), GFP_KERNEL); 153 if (!diag_res) 154 goto err_out_mp; 155 156 diag_res->name = ms02nv_res_diag_ram; 157 diag_res->start = addr; 158 diag_res->end = addr + MS02NV_RAM - 1; 159 diag_res->flags = IORESOURCE_BUSY; 160 request_resource(mod_res, diag_res); 161 162 mp->resource.diag_ram = diag_res; 163 164 /* User-available general-purpose NVRAM area. */ 165 user_res = kzalloc(sizeof(*user_res), GFP_KERNEL); 166 if (!user_res) 167 goto err_out_diag_res; 168 169 user_res->name = ms02nv_res_user_ram; 170 user_res->start = addr + MS02NV_RAM; 171 user_res->end = addr + size - 1; 172 user_res->flags = IORESOURCE_BUSY; 173 request_resource(mod_res, user_res); 174 175 mp->resource.user_ram = user_res; 176 177 /* Control and status register. */ 178 csr_res = kzalloc(sizeof(*csr_res), GFP_KERNEL); 179 if (!csr_res) 180 goto err_out_user_res; 181 182 csr_res->name = ms02nv_res_csr; 183 csr_res->start = addr + MS02NV_CSR; 184 csr_res->end = addr + MS02NV_CSR + 3; 185 csr_res->flags = IORESOURCE_BUSY; 186 request_resource(mod_res, csr_res); 187 188 mp->resource.csr = csr_res; 189 190 mp->addr = phys_to_virt(addr); 191 mp->size = size; 192 193 /* 194 * Hide the firmware's diagnostic area. It may get destroyed 195 * upon a reboot. Take paging into account for mapping support. 196 */ 197 fixaddr = (addr + MS02NV_RAM + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1); 198 fixsize = (size - (fixaddr - addr)) & ~(PAGE_SIZE - 1); 199 mp->uaddr = phys_to_virt(fixaddr); 200 201 mtd->type = MTD_RAM; 202 mtd->flags = MTD_CAP_RAM; 203 mtd->size = fixsize; 204 mtd->name = ms02nv_name; 205 mtd->owner = THIS_MODULE; 206 mtd->_read = ms02nv_read; 207 mtd->_write = ms02nv_write; 208 mtd->writesize = 1; 209 210 ret = -EIO; 211 if (mtd_device_register(mtd, NULL, 0)) { 212 printk(KERN_ERR 213 "ms02-nv: Unable to register MTD device, aborting!\n"); 214 goto err_out_csr_res; 215 } 216 217 printk(KERN_INFO "mtd%d: %s at 0x%08lx, size %zuMiB.\n", 218 mtd->index, ms02nv_name, addr, size >> 20); 219 220 mp->next = root_ms02nv_mtd; 221 root_ms02nv_mtd = mtd; 222 223 return 0; 224 225 226 err_out_csr_res: 227 release_resource(csr_res); 228 kfree(csr_res); 229 err_out_user_res: 230 release_resource(user_res); 231 kfree(user_res); 232 err_out_diag_res: 233 release_resource(diag_res); 234 kfree(diag_res); 235 err_out_mp: 236 kfree(mp); 237 err_out_mtd: 238 kfree(mtd); 239 err_out_mod_res_rel: 240 release_resource(mod_res); 241 err_out_mod_res: 242 kfree(mod_res); 243 return ret; 244 } 245 246 static void __exit ms02nv_remove_one(void) 247 { 248 struct mtd_info *mtd = root_ms02nv_mtd; 249 struct ms02nv_private *mp = mtd->priv; 250 251 root_ms02nv_mtd = mp->next; 252 253 mtd_device_unregister(mtd); 254 255 release_resource(mp->resource.csr); 256 kfree(mp->resource.csr); 257 release_resource(mp->resource.user_ram); 258 kfree(mp->resource.user_ram); 259 release_resource(mp->resource.diag_ram); 260 kfree(mp->resource.diag_ram); 261 release_resource(mp->resource.module); 262 kfree(mp->resource.module); 263 kfree(mp); 264 kfree(mtd); 265 } 266 267 268 static int __init ms02nv_init(void) 269 { 270 volatile u32 *csr; 271 uint stride = 0; 272 int count = 0; 273 int i; 274 275 switch (mips_machtype) { 276 case MACH_DS5000_200: 277 csr = (volatile u32 *)CKSEG1ADDR(KN02_SLOT_BASE + KN02_CSR); 278 if (*csr & KN02_CSR_BNK32M) 279 stride = 2; 280 break; 281 case MACH_DS5000_2X0: 282 case MACH_DS5900: 283 csr = (volatile u32 *)CKSEG1ADDR(KN03_SLOT_BASE + IOASIC_MCR); 284 if (*csr & KN03_MCR_BNK32M) 285 stride = 2; 286 break; 287 default: 288 return -ENODEV; 289 break; 290 } 291 292 for (i = 0; i < ARRAY_SIZE(ms02nv_addrs); i++) 293 if (!ms02nv_init_one(ms02nv_addrs[i] << stride)) 294 count++; 295 296 return (count > 0) ? 0 : -ENODEV; 297 } 298 299 static void __exit ms02nv_cleanup(void) 300 { 301 while (root_ms02nv_mtd) 302 ms02nv_remove_one(); 303 } 304 305 306 module_init(ms02nv_init); 307 module_exit(ms02nv_cleanup); 308