drivers/misc/eeprom/eeprom_93xx46.c

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