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