1 /* 2 * Driver for 93xx46 EEPROMs 3 * 4 * (C) 2011 DENX Software Engineering, Anatolij Gustschin <agust@denx.de> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <linux/delay.h> 12 #include <linux/device.h> 13 #include <linux/gpio/consumer.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/of.h> 18 #include <linux/of_device.h> 19 #include <linux/of_gpio.h> 20 #include <linux/slab.h> 21 #include <linux/spi/spi.h> 22 #include <linux/nvmem-provider.h> 23 #include <linux/regmap.h> 24 #include <linux/eeprom_93xx46.h> 25 26 #define OP_START 0x4 27 #define OP_WRITE (OP_START | 0x1) 28 #define OP_READ (OP_START | 0x2) 29 #define ADDR_EWDS 0x00 30 #define ADDR_ERAL 0x20 31 #define ADDR_EWEN 0x30 32 33 struct eeprom_93xx46_devtype_data { 34 unsigned int quirks; 35 }; 36 37 static const struct eeprom_93xx46_devtype_data atmel_at93c46d_data = { 38 .quirks = EEPROM_93XX46_QUIRK_SINGLE_WORD_READ | 39 EEPROM_93XX46_QUIRK_INSTRUCTION_LENGTH, 40 }; 41 42 struct eeprom_93xx46_dev { 43 struct spi_device *spi; 44 struct eeprom_93xx46_platform_data *pdata; 45 struct mutex lock; 46 struct regmap_config regmap_config; 47 struct nvmem_config nvmem_config; 48 struct nvmem_device *nvmem; 49 int addrlen; 50 int size; 51 }; 52 53 static inline bool has_quirk_single_word_read(struct eeprom_93xx46_dev *edev) 54 { 55 return edev->pdata->quirks & EEPROM_93XX46_QUIRK_SINGLE_WORD_READ; 56 } 57 58 static inline bool has_quirk_instruction_length(struct eeprom_93xx46_dev *edev) 59 { 60 return edev->pdata->quirks & EEPROM_93XX46_QUIRK_INSTRUCTION_LENGTH; 61 } 62 63 static ssize_t 64 eeprom_93xx46_read(struct eeprom_93xx46_dev *edev, char *buf, 65 unsigned off, size_t count) 66 { 67 ssize_t ret = 0; 68 69 if (unlikely(off >= edev->size)) 70 return 0; 71 if ((off + count) > edev->size) 72 count = edev->size - off; 73 if (unlikely(!count)) 74 return count; 75 76 mutex_lock(&edev->lock); 77 78 if (edev->pdata->prepare) 79 edev->pdata->prepare(edev); 80 81 while (count) { 82 struct spi_message m; 83 struct spi_transfer t[2] = { { 0 } }; 84 u16 cmd_addr = OP_READ << edev->addrlen; 85 size_t nbytes = count; 86 int bits; 87 int err; 88 89 if (edev->addrlen == 7) { 90 cmd_addr |= off & 0x7f; 91 bits = 10; 92 if (has_quirk_single_word_read(edev)) 93 nbytes = 1; 94 } else { 95 cmd_addr |= (off >> 1) & 0x3f; 96 bits = 9; 97 if (has_quirk_single_word_read(edev)) 98 nbytes = 2; 99 } 100 101 dev_dbg(&edev->spi->dev, "read cmd 0x%x, %d Hz\n", 102 cmd_addr, edev->spi->max_speed_hz); 103 104 spi_message_init(&m); 105 106 t[0].tx_buf = (char *)&cmd_addr; 107 t[0].len = 2; 108 t[0].bits_per_word = bits; 109 spi_message_add_tail(&t[0], &m); 110 111 t[1].rx_buf = buf; 112 t[1].len = count; 113 t[1].bits_per_word = 8; 114 spi_message_add_tail(&t[1], &m); 115 116 err = spi_sync(edev->spi, &m); 117 /* have to wait at least Tcsl ns */ 118 ndelay(250); 119 120 if (err) { 121 dev_err(&edev->spi->dev, "read %zu bytes at %d: err. %d\n", 122 nbytes, (int)off, err); 123 ret = err; 124 break; 125 } 126 127 buf += nbytes; 128 off += nbytes; 129 count -= nbytes; 130 ret += nbytes; 131 } 132 133 if (edev->pdata->finish) 134 edev->pdata->finish(edev); 135 136 mutex_unlock(&edev->lock); 137 return ret; 138 } 139 140 static int eeprom_93xx46_ew(struct eeprom_93xx46_dev *edev, int is_on) 141 { 142 struct spi_message m; 143 struct spi_transfer t; 144 int bits, ret; 145 u16 cmd_addr; 146 147 cmd_addr = OP_START << edev->addrlen; 148 if (edev->addrlen == 7) { 149 cmd_addr |= (is_on ? ADDR_EWEN : ADDR_EWDS) << 1; 150 bits = 10; 151 } else { 152 cmd_addr |= (is_on ? ADDR_EWEN : ADDR_EWDS); 153 bits = 9; 154 } 155 156 if (has_quirk_instruction_length(edev)) { 157 cmd_addr <<= 2; 158 bits += 2; 159 } 160 161 dev_dbg(&edev->spi->dev, "ew%s cmd 0x%04x, %d bits\n", 162 is_on ? "en" : "ds", cmd_addr, bits); 163 164 spi_message_init(&m); 165 memset(&t, 0, sizeof(t)); 166 167 t.tx_buf = &cmd_addr; 168 t.len = 2; 169 t.bits_per_word = bits; 170 spi_message_add_tail(&t, &m); 171 172 mutex_lock(&edev->lock); 173 174 if (edev->pdata->prepare) 175 edev->pdata->prepare(edev); 176 177 ret = spi_sync(edev->spi, &m); 178 /* have to wait at least Tcsl ns */ 179 ndelay(250); 180 if (ret) 181 dev_err(&edev->spi->dev, "erase/write %sable error %d\n", 182 is_on ? "en" : "dis", ret); 183 184 if (edev->pdata->finish) 185 edev->pdata->finish(edev); 186 187 mutex_unlock(&edev->lock); 188 return ret; 189 } 190 191 static ssize_t 192 eeprom_93xx46_write_word(struct eeprom_93xx46_dev *edev, 193 const char *buf, unsigned off) 194 { 195 struct spi_message m; 196 struct spi_transfer t[2]; 197 int bits, data_len, ret; 198 u16 cmd_addr; 199 200 cmd_addr = OP_WRITE << edev->addrlen; 201 202 if (edev->addrlen == 7) { 203 cmd_addr |= off & 0x7f; 204 bits = 10; 205 data_len = 1; 206 } else { 207 cmd_addr |= (off >> 1) & 0x3f; 208 bits = 9; 209 data_len = 2; 210 } 211 212 dev_dbg(&edev->spi->dev, "write cmd 0x%x\n", cmd_addr); 213 214 spi_message_init(&m); 215 memset(t, 0, sizeof(t)); 216 217 t[0].tx_buf = (char *)&cmd_addr; 218 t[0].len = 2; 219 t[0].bits_per_word = bits; 220 spi_message_add_tail(&t[0], &m); 221 222 t[1].tx_buf = buf; 223 t[1].len = data_len; 224 t[1].bits_per_word = 8; 225 spi_message_add_tail(&t[1], &m); 226 227 ret = spi_sync(edev->spi, &m); 228 /* have to wait program cycle time Twc ms */ 229 mdelay(6); 230 return ret; 231 } 232 233 static ssize_t 234 eeprom_93xx46_write(struct eeprom_93xx46_dev *edev, const char *buf, 235 loff_t off, size_t count) 236 { 237 int i, ret, step = 1; 238 239 if (unlikely(off >= edev->size)) 240 return -EFBIG; 241 if ((off + count) > edev->size) 242 count = edev->size - off; 243 if (unlikely(!count)) 244 return count; 245 246 /* only write even number of bytes on 16-bit devices */ 247 if (edev->addrlen == 6) { 248 step = 2; 249 count &= ~1; 250 } 251 252 /* erase/write enable */ 253 ret = eeprom_93xx46_ew(edev, 1); 254 if (ret) 255 return ret; 256 257 mutex_lock(&edev->lock); 258 259 if (edev->pdata->prepare) 260 edev->pdata->prepare(edev); 261 262 for (i = 0; i < count; i += step) { 263 ret = eeprom_93xx46_write_word(edev, &buf[i], off + i); 264 if (ret) { 265 dev_err(&edev->spi->dev, "write failed at %d: %d\n", 266 (int)off + i, ret); 267 break; 268 } 269 } 270 271 if (edev->pdata->finish) 272 edev->pdata->finish(edev); 273 274 mutex_unlock(&edev->lock); 275 276 /* erase/write disable */ 277 eeprom_93xx46_ew(edev, 0); 278 return ret ? : count; 279 } 280 281 /* 282 * Provide a regmap interface, which is registered with the NVMEM 283 * framework 284 */ 285 static int eeprom_93xx46_regmap_read(void *context, const void *reg, 286 size_t reg_size, void *val, 287 size_t val_size) 288 { 289 struct eeprom_93xx46_dev *eeprom_93xx46 = context; 290 off_t offset = *(u32 *)reg; 291 int err; 292 293 err = eeprom_93xx46_read(eeprom_93xx46, val, offset, val_size); 294 if (err) 295 return err; 296 return 0; 297 } 298 299 static int eeprom_93xx46_regmap_write(void *context, const void *data, 300 size_t count) 301 { 302 struct eeprom_93xx46_dev *eeprom_93xx46 = context; 303 const char *buf; 304 u32 offset; 305 size_t len; 306 int err; 307 308 memcpy(&offset, data, sizeof(offset)); 309 buf = (const char *)data + sizeof(offset); 310 len = count - sizeof(offset); 311 312 err = eeprom_93xx46_write(eeprom_93xx46, buf, offset, len); 313 if (err) 314 return err; 315 return 0; 316 } 317 318 static const struct regmap_bus eeprom_93xx46_regmap_bus = { 319 .read = eeprom_93xx46_regmap_read, 320 .write = eeprom_93xx46_regmap_write, 321 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE, 322 }; 323 324 static int eeprom_93xx46_eral(struct eeprom_93xx46_dev *edev) 325 { 326 struct eeprom_93xx46_platform_data *pd = edev->pdata; 327 struct spi_message m; 328 struct spi_transfer t; 329 int bits, ret; 330 u16 cmd_addr; 331 332 cmd_addr = OP_START << edev->addrlen; 333 if (edev->addrlen == 7) { 334 cmd_addr |= ADDR_ERAL << 1; 335 bits = 10; 336 } else { 337 cmd_addr |= ADDR_ERAL; 338 bits = 9; 339 } 340 341 if (has_quirk_instruction_length(edev)) { 342 cmd_addr <<= 2; 343 bits += 2; 344 } 345 346 dev_dbg(&edev->spi->dev, "eral cmd 0x%04x, %d bits\n", cmd_addr, bits); 347 348 spi_message_init(&m); 349 memset(&t, 0, sizeof(t)); 350 351 t.tx_buf = &cmd_addr; 352 t.len = 2; 353 t.bits_per_word = bits; 354 spi_message_add_tail(&t, &m); 355 356 mutex_lock(&edev->lock); 357 358 if (edev->pdata->prepare) 359 edev->pdata->prepare(edev); 360 361 ret = spi_sync(edev->spi, &m); 362 if (ret) 363 dev_err(&edev->spi->dev, "erase error %d\n", ret); 364 /* have to wait erase cycle time Tec ms */ 365 mdelay(6); 366 367 if (pd->finish) 368 pd->finish(edev); 369 370 mutex_unlock(&edev->lock); 371 return ret; 372 } 373 374 static ssize_t eeprom_93xx46_store_erase(struct device *dev, 375 struct device_attribute *attr, 376 const char *buf, size_t count) 377 { 378 struct eeprom_93xx46_dev *edev = dev_get_drvdata(dev); 379 int erase = 0, ret; 380 381 sscanf(buf, "%d", &erase); 382 if (erase) { 383 ret = eeprom_93xx46_ew(edev, 1); 384 if (ret) 385 return ret; 386 ret = eeprom_93xx46_eral(edev); 387 if (ret) 388 return ret; 389 ret = eeprom_93xx46_ew(edev, 0); 390 if (ret) 391 return ret; 392 } 393 return count; 394 } 395 static DEVICE_ATTR(erase, S_IWUSR, NULL, eeprom_93xx46_store_erase); 396 397 static void select_assert(void *context) 398 { 399 struct eeprom_93xx46_dev *edev = context; 400 401 gpiod_set_value_cansleep(edev->pdata->select, 1); 402 } 403 404 static void select_deassert(void *context) 405 { 406 struct eeprom_93xx46_dev *edev = context; 407 408 gpiod_set_value_cansleep(edev->pdata->select, 0); 409 } 410 411 static const struct of_device_id eeprom_93xx46_of_table[] = { 412 { .compatible = "eeprom-93xx46", }, 413 { .compatible = "atmel,at93c46d", .data = &atmel_at93c46d_data, }, 414 {} 415 }; 416 MODULE_DEVICE_TABLE(of, eeprom_93xx46_of_table); 417 418 static int eeprom_93xx46_probe_dt(struct spi_device *spi) 419 { 420 const struct of_device_id *of_id = 421 of_match_device(eeprom_93xx46_of_table, &spi->dev); 422 struct device_node *np = spi->dev.of_node; 423 struct eeprom_93xx46_platform_data *pd; 424 u32 tmp; 425 int gpio; 426 enum of_gpio_flags of_flags; 427 int ret; 428 429 pd = devm_kzalloc(&spi->dev, sizeof(*pd), GFP_KERNEL); 430 if (!pd) 431 return -ENOMEM; 432 433 ret = of_property_read_u32(np, "data-size", &tmp); 434 if (ret < 0) { 435 dev_err(&spi->dev, "data-size property not found\n"); 436 return ret; 437 } 438 439 if (tmp == 8) { 440 pd->flags |= EE_ADDR8; 441 } else if (tmp == 16) { 442 pd->flags |= EE_ADDR16; 443 } else { 444 dev_err(&spi->dev, "invalid data-size (%d)\n", tmp); 445 return -EINVAL; 446 } 447 448 if (of_property_read_bool(np, "read-only")) 449 pd->flags |= EE_READONLY; 450 451 gpio = of_get_named_gpio_flags(np, "select-gpios", 0, &of_flags); 452 if (gpio_is_valid(gpio)) { 453 unsigned long flags = 454 of_flags == OF_GPIO_ACTIVE_LOW ? GPIOF_ACTIVE_LOW : 0; 455 456 ret = devm_gpio_request_one(&spi->dev, gpio, flags, 457 "eeprom_93xx46_select"); 458 if (ret) 459 return ret; 460 461 pd->select = gpio_to_desc(gpio); 462 pd->prepare = select_assert; 463 pd->finish = select_deassert; 464 465 gpiod_direction_output(pd->select, 0); 466 } 467 468 if (of_id->data) { 469 const struct eeprom_93xx46_devtype_data *data = of_id->data; 470 471 pd->quirks = data->quirks; 472 } 473 474 spi->dev.platform_data = pd; 475 476 return 0; 477 } 478 479 static int eeprom_93xx46_probe(struct spi_device *spi) 480 { 481 struct eeprom_93xx46_platform_data *pd; 482 struct eeprom_93xx46_dev *edev; 483 struct regmap *regmap; 484 int err; 485 486 if (spi->dev.of_node) { 487 err = eeprom_93xx46_probe_dt(spi); 488 if (err < 0) 489 return err; 490 } 491 492 pd = spi->dev.platform_data; 493 if (!pd) { 494 dev_err(&spi->dev, "missing platform data\n"); 495 return -ENODEV; 496 } 497 498 edev = kzalloc(sizeof(*edev), GFP_KERNEL); 499 if (!edev) 500 return -ENOMEM; 501 502 if (pd->flags & EE_ADDR8) 503 edev->addrlen = 7; 504 else if (pd->flags & EE_ADDR16) 505 edev->addrlen = 6; 506 else { 507 dev_err(&spi->dev, "unspecified address type\n"); 508 err = -EINVAL; 509 goto fail; 510 } 511 512 mutex_init(&edev->lock); 513 514 edev->spi = spi_dev_get(spi); 515 edev->pdata = pd; 516 517 edev->size = 128; 518 519 edev->regmap_config.reg_bits = 32; 520 edev->regmap_config.val_bits = 8; 521 edev->regmap_config.reg_stride = 1; 522 edev->regmap_config.max_register = edev->size - 1; 523 524 regmap = devm_regmap_init(&spi->dev, &eeprom_93xx46_regmap_bus, edev, 525 &edev->regmap_config); 526 if (IS_ERR(regmap)) { 527 dev_err(&spi->dev, "regmap init failed\n"); 528 err = PTR_ERR(regmap); 529 goto fail; 530 } 531 532 edev->nvmem_config.name = dev_name(&spi->dev); 533 edev->nvmem_config.dev = &spi->dev; 534 edev->nvmem_config.read_only = pd->flags & EE_READONLY; 535 edev->nvmem_config.root_only = true; 536 edev->nvmem_config.owner = THIS_MODULE; 537 edev->nvmem_config.compat = true; 538 edev->nvmem_config.base_dev = &spi->dev; 539 540 edev->nvmem = nvmem_register(&edev->nvmem_config); 541 if (IS_ERR(edev->nvmem)) { 542 err = PTR_ERR(edev->nvmem); 543 goto fail; 544 } 545 546 dev_info(&spi->dev, "%d-bit eeprom %s\n", 547 (pd->flags & EE_ADDR8) ? 8 : 16, 548 (pd->flags & EE_READONLY) ? "(readonly)" : ""); 549 550 if (!(pd->flags & EE_READONLY)) { 551 if (device_create_file(&spi->dev, &dev_attr_erase)) 552 dev_err(&spi->dev, "can't create erase interface\n"); 553 } 554 555 spi_set_drvdata(spi, edev); 556 return 0; 557 fail: 558 kfree(edev); 559 return err; 560 } 561 562 static int eeprom_93xx46_remove(struct spi_device *spi) 563 { 564 struct eeprom_93xx46_dev *edev = spi_get_drvdata(spi); 565 566 nvmem_unregister(edev->nvmem); 567 568 if (!(edev->pdata->flags & EE_READONLY)) 569 device_remove_file(&spi->dev, &dev_attr_erase); 570 571 kfree(edev); 572 return 0; 573 } 574 575 static struct spi_driver eeprom_93xx46_driver = { 576 .driver = { 577 .name = "93xx46", 578 .of_match_table = of_match_ptr(eeprom_93xx46_of_table), 579 }, 580 .probe = eeprom_93xx46_probe, 581 .remove = eeprom_93xx46_remove, 582 }; 583 584 module_spi_driver(eeprom_93xx46_driver); 585 586 MODULE_LICENSE("GPL"); 587 MODULE_DESCRIPTION("Driver for 93xx46 EEPROMs"); 588 MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>"); 589 MODULE_ALIAS("spi:93xx46"); 590