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/kernel.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 #include <linux/slab.h> 17 #include <linux/spi/spi.h> 18 #include <linux/sysfs.h> 19 #include <linux/eeprom_93xx46.h> 20 21 #define OP_START 0x4 22 #define OP_WRITE (OP_START | 0x1) 23 #define OP_READ (OP_START | 0x2) 24 #define ADDR_EWDS 0x00 25 #define ADDR_ERAL 0x20 26 #define ADDR_EWEN 0x30 27 28 struct eeprom_93xx46_dev { 29 struct spi_device *spi; 30 struct eeprom_93xx46_platform_data *pdata; 31 struct bin_attribute bin; 32 struct mutex lock; 33 int addrlen; 34 }; 35 36 static ssize_t 37 eeprom_93xx46_bin_read(struct file *filp, struct kobject *kobj, 38 struct bin_attribute *bin_attr, 39 char *buf, loff_t off, size_t count) 40 { 41 struct eeprom_93xx46_dev *edev; 42 struct device *dev; 43 struct spi_message m; 44 struct spi_transfer t[2]; 45 int bits, ret; 46 u16 cmd_addr; 47 48 dev = container_of(kobj, struct device, kobj); 49 edev = dev_get_drvdata(dev); 50 51 if (unlikely(off >= edev->bin.size)) 52 return 0; 53 if ((off + count) > edev->bin.size) 54 count = edev->bin.size - off; 55 if (unlikely(!count)) 56 return count; 57 58 cmd_addr = OP_READ << edev->addrlen; 59 60 if (edev->addrlen == 7) { 61 cmd_addr |= off & 0x7f; 62 bits = 10; 63 } else { 64 cmd_addr |= off & 0x3f; 65 bits = 9; 66 } 67 68 dev_dbg(&edev->spi->dev, "read cmd 0x%x, %d Hz\n", 69 cmd_addr, edev->spi->max_speed_hz); 70 71 spi_message_init(&m); 72 memset(t, 0, sizeof(t)); 73 74 t[0].tx_buf = (char *)&cmd_addr; 75 t[0].len = 2; 76 t[0].bits_per_word = bits; 77 spi_message_add_tail(&t[0], &m); 78 79 t[1].rx_buf = buf; 80 t[1].len = count; 81 t[1].bits_per_word = 8; 82 spi_message_add_tail(&t[1], &m); 83 84 mutex_lock(&edev->lock); 85 86 if (edev->pdata->prepare) 87 edev->pdata->prepare(edev); 88 89 ret = spi_sync(edev->spi, &m); 90 /* have to wait at least Tcsl ns */ 91 ndelay(250); 92 if (ret) { 93 dev_err(&edev->spi->dev, "read %zu bytes at %d: err. %d\n", 94 count, (int)off, ret); 95 } 96 97 if (edev->pdata->finish) 98 edev->pdata->finish(edev); 99 100 mutex_unlock(&edev->lock); 101 return ret ? : count; 102 } 103 104 static int eeprom_93xx46_ew(struct eeprom_93xx46_dev *edev, int is_on) 105 { 106 struct spi_message m; 107 struct spi_transfer t; 108 int bits, ret; 109 u16 cmd_addr; 110 111 cmd_addr = OP_START << edev->addrlen; 112 if (edev->addrlen == 7) { 113 cmd_addr |= (is_on ? ADDR_EWEN : ADDR_EWDS) << 1; 114 bits = 10; 115 } else { 116 cmd_addr |= (is_on ? ADDR_EWEN : ADDR_EWDS); 117 bits = 9; 118 } 119 120 dev_dbg(&edev->spi->dev, "ew cmd 0x%04x\n", cmd_addr); 121 122 spi_message_init(&m); 123 memset(&t, 0, sizeof(t)); 124 125 t.tx_buf = &cmd_addr; 126 t.len = 2; 127 t.bits_per_word = bits; 128 spi_message_add_tail(&t, &m); 129 130 mutex_lock(&edev->lock); 131 132 if (edev->pdata->prepare) 133 edev->pdata->prepare(edev); 134 135 ret = spi_sync(edev->spi, &m); 136 /* have to wait at least Tcsl ns */ 137 ndelay(250); 138 if (ret) 139 dev_err(&edev->spi->dev, "erase/write %sable error %d\n", 140 is_on ? "en" : "dis", ret); 141 142 if (edev->pdata->finish) 143 edev->pdata->finish(edev); 144 145 mutex_unlock(&edev->lock); 146 return ret; 147 } 148 149 static ssize_t 150 eeprom_93xx46_write_word(struct eeprom_93xx46_dev *edev, 151 const char *buf, unsigned off) 152 { 153 struct spi_message m; 154 struct spi_transfer t[2]; 155 int bits, data_len, ret; 156 u16 cmd_addr; 157 158 cmd_addr = OP_WRITE << edev->addrlen; 159 160 if (edev->addrlen == 7) { 161 cmd_addr |= off & 0x7f; 162 bits = 10; 163 data_len = 1; 164 } else { 165 cmd_addr |= off & 0x3f; 166 bits = 9; 167 data_len = 2; 168 } 169 170 dev_dbg(&edev->spi->dev, "write cmd 0x%x\n", cmd_addr); 171 172 spi_message_init(&m); 173 memset(t, 0, sizeof(t)); 174 175 t[0].tx_buf = (char *)&cmd_addr; 176 t[0].len = 2; 177 t[0].bits_per_word = bits; 178 spi_message_add_tail(&t[0], &m); 179 180 t[1].tx_buf = buf; 181 t[1].len = data_len; 182 t[1].bits_per_word = 8; 183 spi_message_add_tail(&t[1], &m); 184 185 ret = spi_sync(edev->spi, &m); 186 /* have to wait program cycle time Twc ms */ 187 mdelay(6); 188 return ret; 189 } 190 191 static ssize_t 192 eeprom_93xx46_bin_write(struct file *filp, struct kobject *kobj, 193 struct bin_attribute *bin_attr, 194 char *buf, loff_t off, size_t count) 195 { 196 struct eeprom_93xx46_dev *edev; 197 struct device *dev; 198 int i, ret, step = 1; 199 200 dev = container_of(kobj, struct device, kobj); 201 edev = dev_get_drvdata(dev); 202 203 if (unlikely(off >= edev->bin.size)) 204 return -EFBIG; 205 if ((off + count) > edev->bin.size) 206 count = edev->bin.size - off; 207 if (unlikely(!count)) 208 return count; 209 210 /* only write even number of bytes on 16-bit devices */ 211 if (edev->addrlen == 6) { 212 step = 2; 213 count &= ~1; 214 } 215 216 /* erase/write enable */ 217 ret = eeprom_93xx46_ew(edev, 1); 218 if (ret) 219 return ret; 220 221 mutex_lock(&edev->lock); 222 223 if (edev->pdata->prepare) 224 edev->pdata->prepare(edev); 225 226 for (i = 0; i < count; i += step) { 227 ret = eeprom_93xx46_write_word(edev, &buf[i], off + i); 228 if (ret) { 229 dev_err(&edev->spi->dev, "write failed at %d: %d\n", 230 (int)off + i, ret); 231 break; 232 } 233 } 234 235 if (edev->pdata->finish) 236 edev->pdata->finish(edev); 237 238 mutex_unlock(&edev->lock); 239 240 /* erase/write disable */ 241 eeprom_93xx46_ew(edev, 0); 242 return ret ? : count; 243 } 244 245 static int eeprom_93xx46_eral(struct eeprom_93xx46_dev *edev) 246 { 247 struct eeprom_93xx46_platform_data *pd = edev->pdata; 248 struct spi_message m; 249 struct spi_transfer t; 250 int bits, ret; 251 u16 cmd_addr; 252 253 cmd_addr = OP_START << edev->addrlen; 254 if (edev->addrlen == 7) { 255 cmd_addr |= ADDR_ERAL << 1; 256 bits = 10; 257 } else { 258 cmd_addr |= ADDR_ERAL; 259 bits = 9; 260 } 261 262 spi_message_init(&m); 263 memset(&t, 0, sizeof(t)); 264 265 t.tx_buf = &cmd_addr; 266 t.len = 2; 267 t.bits_per_word = bits; 268 spi_message_add_tail(&t, &m); 269 270 mutex_lock(&edev->lock); 271 272 if (edev->pdata->prepare) 273 edev->pdata->prepare(edev); 274 275 ret = spi_sync(edev->spi, &m); 276 if (ret) 277 dev_err(&edev->spi->dev, "erase error %d\n", ret); 278 /* have to wait erase cycle time Tec ms */ 279 mdelay(6); 280 281 if (pd->finish) 282 pd->finish(edev); 283 284 mutex_unlock(&edev->lock); 285 return ret; 286 } 287 288 static ssize_t eeprom_93xx46_store_erase(struct device *dev, 289 struct device_attribute *attr, 290 const char *buf, size_t count) 291 { 292 struct eeprom_93xx46_dev *edev = dev_get_drvdata(dev); 293 int erase = 0, ret; 294 295 sscanf(buf, "%d", &erase); 296 if (erase) { 297 ret = eeprom_93xx46_ew(edev, 1); 298 if (ret) 299 return ret; 300 ret = eeprom_93xx46_eral(edev); 301 if (ret) 302 return ret; 303 ret = eeprom_93xx46_ew(edev, 0); 304 if (ret) 305 return ret; 306 } 307 return count; 308 } 309 static DEVICE_ATTR(erase, S_IWUSR, NULL, eeprom_93xx46_store_erase); 310 311 static int eeprom_93xx46_probe(struct spi_device *spi) 312 { 313 struct eeprom_93xx46_platform_data *pd; 314 struct eeprom_93xx46_dev *edev; 315 int err; 316 317 pd = spi->dev.platform_data; 318 if (!pd) { 319 dev_err(&spi->dev, "missing platform data\n"); 320 return -ENODEV; 321 } 322 323 edev = kzalloc(sizeof(*edev), GFP_KERNEL); 324 if (!edev) 325 return -ENOMEM; 326 327 if (pd->flags & EE_ADDR8) 328 edev->addrlen = 7; 329 else if (pd->flags & EE_ADDR16) 330 edev->addrlen = 6; 331 else { 332 dev_err(&spi->dev, "unspecified address type\n"); 333 err = -EINVAL; 334 goto fail; 335 } 336 337 mutex_init(&edev->lock); 338 339 edev->spi = spi_dev_get(spi); 340 edev->pdata = pd; 341 342 sysfs_bin_attr_init(&edev->bin); 343 edev->bin.attr.name = "eeprom"; 344 edev->bin.attr.mode = S_IRUSR; 345 edev->bin.read = eeprom_93xx46_bin_read; 346 edev->bin.size = 128; 347 if (!(pd->flags & EE_READONLY)) { 348 edev->bin.write = eeprom_93xx46_bin_write; 349 edev->bin.attr.mode |= S_IWUSR; 350 } 351 352 err = sysfs_create_bin_file(&spi->dev.kobj, &edev->bin); 353 if (err) 354 goto fail; 355 356 dev_info(&spi->dev, "%d-bit eeprom %s\n", 357 (pd->flags & EE_ADDR8) ? 8 : 16, 358 (pd->flags & EE_READONLY) ? "(readonly)" : ""); 359 360 if (!(pd->flags & EE_READONLY)) { 361 if (device_create_file(&spi->dev, &dev_attr_erase)) 362 dev_err(&spi->dev, "can't create erase interface\n"); 363 } 364 365 spi_set_drvdata(spi, edev); 366 return 0; 367 fail: 368 kfree(edev); 369 return err; 370 } 371 372 static int eeprom_93xx46_remove(struct spi_device *spi) 373 { 374 struct eeprom_93xx46_dev *edev = spi_get_drvdata(spi); 375 376 if (!(edev->pdata->flags & EE_READONLY)) 377 device_remove_file(&spi->dev, &dev_attr_erase); 378 379 sysfs_remove_bin_file(&spi->dev.kobj, &edev->bin); 380 kfree(edev); 381 return 0; 382 } 383 384 static struct spi_driver eeprom_93xx46_driver = { 385 .driver = { 386 .name = "93xx46", 387 .owner = THIS_MODULE, 388 }, 389 .probe = eeprom_93xx46_probe, 390 .remove = eeprom_93xx46_remove, 391 }; 392 393 module_spi_driver(eeprom_93xx46_driver); 394 395 MODULE_LICENSE("GPL"); 396 MODULE_DESCRIPTION("Driver for 93xx46 EEPROMs"); 397 MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>"); 398 MODULE_ALIAS("spi:93xx46"); 399