1e51d565fSWolfram Sang /* 2e51d565fSWolfram Sang * at25.c -- support most SPI EEPROMs, such as Atmel AT25 models 3e51d565fSWolfram Sang * 4e51d565fSWolfram Sang * Copyright (C) 2006 David Brownell 5e51d565fSWolfram Sang * 6e51d565fSWolfram Sang * This program is free software; you can redistribute it and/or modify 7e51d565fSWolfram Sang * it under the terms of the GNU General Public License as published by 8e51d565fSWolfram Sang * the Free Software Foundation; either version 2 of the License, or 9e51d565fSWolfram Sang * (at your option) any later version. 10e51d565fSWolfram Sang */ 11e51d565fSWolfram Sang 12e51d565fSWolfram Sang #include <linux/kernel.h> 13e51d565fSWolfram Sang #include <linux/init.h> 14e51d565fSWolfram Sang #include <linux/module.h> 15e51d565fSWolfram Sang #include <linux/slab.h> 16e51d565fSWolfram Sang #include <linux/delay.h> 17e51d565fSWolfram Sang #include <linux/device.h> 18e51d565fSWolfram Sang #include <linux/sched.h> 19e51d565fSWolfram Sang 20e51d565fSWolfram Sang #include <linux/spi/spi.h> 21e51d565fSWolfram Sang #include <linux/spi/eeprom.h> 22e51d565fSWolfram Sang 23e51d565fSWolfram Sang 24e51d565fSWolfram Sang /* 25e51d565fSWolfram Sang * NOTE: this is an *EEPROM* driver. The vagaries of product naming 26e51d565fSWolfram Sang * mean that some AT25 products are EEPROMs, and others are FLASH. 27e51d565fSWolfram Sang * Handle FLASH chips with the drivers/mtd/devices/m25p80.c driver, 28e51d565fSWolfram Sang * not this one! 29e51d565fSWolfram Sang */ 30e51d565fSWolfram Sang 31e51d565fSWolfram Sang struct at25_data { 32e51d565fSWolfram Sang struct spi_device *spi; 3314dd1ff0SDavid Brownell struct memory_accessor mem; 34e51d565fSWolfram Sang struct mutex lock; 35e51d565fSWolfram Sang struct spi_eeprom chip; 36e51d565fSWolfram Sang struct bin_attribute bin; 37e51d565fSWolfram Sang unsigned addrlen; 38e51d565fSWolfram Sang }; 39e51d565fSWolfram Sang 40e51d565fSWolfram Sang #define AT25_WREN 0x06 /* latch the write enable */ 41e51d565fSWolfram Sang #define AT25_WRDI 0x04 /* reset the write enable */ 42e51d565fSWolfram Sang #define AT25_RDSR 0x05 /* read status register */ 43e51d565fSWolfram Sang #define AT25_WRSR 0x01 /* write status register */ 44e51d565fSWolfram Sang #define AT25_READ 0x03 /* read byte(s) */ 45e51d565fSWolfram Sang #define AT25_WRITE 0x02 /* write byte(s)/sector */ 46e51d565fSWolfram Sang 47e51d565fSWolfram Sang #define AT25_SR_nRDY 0x01 /* nRDY = write-in-progress */ 48e51d565fSWolfram Sang #define AT25_SR_WEN 0x02 /* write enable (latched) */ 49e51d565fSWolfram Sang #define AT25_SR_BP0 0x04 /* BP for software writeprotect */ 50e51d565fSWolfram Sang #define AT25_SR_BP1 0x08 51e51d565fSWolfram Sang #define AT25_SR_WPEN 0x80 /* writeprotect enable */ 52e51d565fSWolfram Sang 53e51d565fSWolfram Sang 54e51d565fSWolfram Sang #define EE_MAXADDRLEN 3 /* 24 bit addresses, up to 2 MBytes */ 55e51d565fSWolfram Sang 56e51d565fSWolfram Sang /* Specs often allow 5 msec for a page write, sometimes 20 msec; 57e51d565fSWolfram Sang * it's important to recover from write timeouts. 58e51d565fSWolfram Sang */ 59e51d565fSWolfram Sang #define EE_TIMEOUT 25 60e51d565fSWolfram Sang 61e51d565fSWolfram Sang /*-------------------------------------------------------------------------*/ 62e51d565fSWolfram Sang 63e51d565fSWolfram Sang #define io_limit PAGE_SIZE /* bytes */ 64e51d565fSWolfram Sang 65e51d565fSWolfram Sang static ssize_t 66e51d565fSWolfram Sang at25_ee_read( 67e51d565fSWolfram Sang struct at25_data *at25, 68e51d565fSWolfram Sang char *buf, 69e51d565fSWolfram Sang unsigned offset, 70e51d565fSWolfram Sang size_t count 71e51d565fSWolfram Sang ) 72e51d565fSWolfram Sang { 73e51d565fSWolfram Sang u8 command[EE_MAXADDRLEN + 1]; 74e51d565fSWolfram Sang u8 *cp; 75e51d565fSWolfram Sang ssize_t status; 76e51d565fSWolfram Sang struct spi_transfer t[2]; 77e51d565fSWolfram Sang struct spi_message m; 78e51d565fSWolfram Sang 7914dd1ff0SDavid Brownell if (unlikely(offset >= at25->bin.size)) 8014dd1ff0SDavid Brownell return 0; 8114dd1ff0SDavid Brownell if ((offset + count) > at25->bin.size) 8214dd1ff0SDavid Brownell count = at25->bin.size - offset; 8314dd1ff0SDavid Brownell if (unlikely(!count)) 8414dd1ff0SDavid Brownell return count; 8514dd1ff0SDavid Brownell 86e51d565fSWolfram Sang cp = command; 87e51d565fSWolfram Sang *cp++ = AT25_READ; 88e51d565fSWolfram Sang 89e51d565fSWolfram Sang /* 8/16/24-bit address is written MSB first */ 90e51d565fSWolfram Sang switch (at25->addrlen) { 91e51d565fSWolfram Sang default: /* case 3 */ 92e51d565fSWolfram Sang *cp++ = offset >> 16; 93e51d565fSWolfram Sang case 2: 94e51d565fSWolfram Sang *cp++ = offset >> 8; 95e51d565fSWolfram Sang case 1: 96e51d565fSWolfram Sang case 0: /* can't happen: for better codegen */ 97e51d565fSWolfram Sang *cp++ = offset >> 0; 98e51d565fSWolfram Sang } 99e51d565fSWolfram Sang 100e51d565fSWolfram Sang spi_message_init(&m); 101e51d565fSWolfram Sang memset(t, 0, sizeof t); 102e51d565fSWolfram Sang 103e51d565fSWolfram Sang t[0].tx_buf = command; 104e51d565fSWolfram Sang t[0].len = at25->addrlen + 1; 105e51d565fSWolfram Sang spi_message_add_tail(&t[0], &m); 106e51d565fSWolfram Sang 107e51d565fSWolfram Sang t[1].rx_buf = buf; 108e51d565fSWolfram Sang t[1].len = count; 109e51d565fSWolfram Sang spi_message_add_tail(&t[1], &m); 110e51d565fSWolfram Sang 111e51d565fSWolfram Sang mutex_lock(&at25->lock); 112e51d565fSWolfram Sang 113e51d565fSWolfram Sang /* Read it all at once. 114e51d565fSWolfram Sang * 115e51d565fSWolfram Sang * REVISIT that's potentially a problem with large chips, if 116e51d565fSWolfram Sang * other devices on the bus need to be accessed regularly or 117e51d565fSWolfram Sang * this chip is clocked very slowly 118e51d565fSWolfram Sang */ 119e51d565fSWolfram Sang status = spi_sync(at25->spi, &m); 120e51d565fSWolfram Sang dev_dbg(&at25->spi->dev, 121e51d565fSWolfram Sang "read %Zd bytes at %d --> %d\n", 122e51d565fSWolfram Sang count, offset, (int) status); 123e51d565fSWolfram Sang 124e51d565fSWolfram Sang mutex_unlock(&at25->lock); 125e51d565fSWolfram Sang return status ? status : count; 126e51d565fSWolfram Sang } 127e51d565fSWolfram Sang 128e51d565fSWolfram Sang static ssize_t 1292c3c8beaSChris Wright at25_bin_read(struct file *filp, struct kobject *kobj, 1302c3c8beaSChris Wright struct bin_attribute *bin_attr, 131e51d565fSWolfram Sang char *buf, loff_t off, size_t count) 132e51d565fSWolfram Sang { 133e51d565fSWolfram Sang struct device *dev; 134e51d565fSWolfram Sang struct at25_data *at25; 135e51d565fSWolfram Sang 136e51d565fSWolfram Sang dev = container_of(kobj, struct device, kobj); 137e51d565fSWolfram Sang at25 = dev_get_drvdata(dev); 138e51d565fSWolfram Sang 139e51d565fSWolfram Sang return at25_ee_read(at25, buf, off, count); 140e51d565fSWolfram Sang } 141e51d565fSWolfram Sang 142e51d565fSWolfram Sang 143e51d565fSWolfram Sang static ssize_t 1444cafbd0bSGeert Uytterhoeven at25_ee_write(struct at25_data *at25, const char *buf, loff_t off, 1454cafbd0bSGeert Uytterhoeven size_t count) 146e51d565fSWolfram Sang { 147e51d565fSWolfram Sang ssize_t status = 0; 148e51d565fSWolfram Sang unsigned written = 0; 149e51d565fSWolfram Sang unsigned buf_size; 150e51d565fSWolfram Sang u8 *bounce; 151e51d565fSWolfram Sang 15214dd1ff0SDavid Brownell if (unlikely(off >= at25->bin.size)) 15314dd1ff0SDavid Brownell return -EFBIG; 15414dd1ff0SDavid Brownell if ((off + count) > at25->bin.size) 15514dd1ff0SDavid Brownell count = at25->bin.size - off; 15614dd1ff0SDavid Brownell if (unlikely(!count)) 15714dd1ff0SDavid Brownell return count; 15814dd1ff0SDavid Brownell 159e51d565fSWolfram Sang /* Temp buffer starts with command and address */ 160e51d565fSWolfram Sang buf_size = at25->chip.page_size; 161e51d565fSWolfram Sang if (buf_size > io_limit) 162e51d565fSWolfram Sang buf_size = io_limit; 163e51d565fSWolfram Sang bounce = kmalloc(buf_size + at25->addrlen + 1, GFP_KERNEL); 164e51d565fSWolfram Sang if (!bounce) 165e51d565fSWolfram Sang return -ENOMEM; 166e51d565fSWolfram Sang 167e51d565fSWolfram Sang /* For write, rollover is within the page ... so we write at 168e51d565fSWolfram Sang * most one page, then manually roll over to the next page. 169e51d565fSWolfram Sang */ 170e51d565fSWolfram Sang bounce[0] = AT25_WRITE; 171e51d565fSWolfram Sang mutex_lock(&at25->lock); 172e51d565fSWolfram Sang do { 173e51d565fSWolfram Sang unsigned long timeout, retries; 174e51d565fSWolfram Sang unsigned segment; 175e51d565fSWolfram Sang unsigned offset = (unsigned) off; 176e51d565fSWolfram Sang u8 *cp = bounce + 1; 177f0d83679SSebastian Heutling int sr; 178e51d565fSWolfram Sang 179e51d565fSWolfram Sang *cp = AT25_WREN; 180e51d565fSWolfram Sang status = spi_write(at25->spi, cp, 1); 181e51d565fSWolfram Sang if (status < 0) { 182e51d565fSWolfram Sang dev_dbg(&at25->spi->dev, "WREN --> %d\n", 183e51d565fSWolfram Sang (int) status); 184e51d565fSWolfram Sang break; 185e51d565fSWolfram Sang } 186e51d565fSWolfram Sang 187e51d565fSWolfram Sang /* 8/16/24-bit address is written MSB first */ 188e51d565fSWolfram Sang switch (at25->addrlen) { 189e51d565fSWolfram Sang default: /* case 3 */ 190e51d565fSWolfram Sang *cp++ = offset >> 16; 191e51d565fSWolfram Sang case 2: 192e51d565fSWolfram Sang *cp++ = offset >> 8; 193e51d565fSWolfram Sang case 1: 194e51d565fSWolfram Sang case 0: /* can't happen: for better codegen */ 195e51d565fSWolfram Sang *cp++ = offset >> 0; 196e51d565fSWolfram Sang } 197e51d565fSWolfram Sang 198e51d565fSWolfram Sang /* Write as much of a page as we can */ 199e51d565fSWolfram Sang segment = buf_size - (offset % buf_size); 200e51d565fSWolfram Sang if (segment > count) 201e51d565fSWolfram Sang segment = count; 202e51d565fSWolfram Sang memcpy(cp, buf, segment); 203e51d565fSWolfram Sang status = spi_write(at25->spi, bounce, 204e51d565fSWolfram Sang segment + at25->addrlen + 1); 205e51d565fSWolfram Sang dev_dbg(&at25->spi->dev, 206e51d565fSWolfram Sang "write %u bytes at %u --> %d\n", 207e51d565fSWolfram Sang segment, offset, (int) status); 208e51d565fSWolfram Sang if (status < 0) 209e51d565fSWolfram Sang break; 210e51d565fSWolfram Sang 211e51d565fSWolfram Sang /* REVISIT this should detect (or prevent) failed writes 212e51d565fSWolfram Sang * to readonly sections of the EEPROM... 213e51d565fSWolfram Sang */ 214e51d565fSWolfram Sang 215e51d565fSWolfram Sang /* Wait for non-busy status */ 216e51d565fSWolfram Sang timeout = jiffies + msecs_to_jiffies(EE_TIMEOUT); 217e51d565fSWolfram Sang retries = 0; 218e51d565fSWolfram Sang do { 219e51d565fSWolfram Sang 220e51d565fSWolfram Sang sr = spi_w8r8(at25->spi, AT25_RDSR); 221e51d565fSWolfram Sang if (sr < 0 || (sr & AT25_SR_nRDY)) { 222e51d565fSWolfram Sang dev_dbg(&at25->spi->dev, 223e51d565fSWolfram Sang "rdsr --> %d (%02x)\n", sr, sr); 224e51d565fSWolfram Sang /* at HZ=100, this is sloooow */ 225e51d565fSWolfram Sang msleep(1); 226e51d565fSWolfram Sang continue; 227e51d565fSWolfram Sang } 228e51d565fSWolfram Sang if (!(sr & AT25_SR_nRDY)) 229e51d565fSWolfram Sang break; 230e51d565fSWolfram Sang } while (retries++ < 3 || time_before_eq(jiffies, timeout)); 231e51d565fSWolfram Sang 232f0d83679SSebastian Heutling if ((sr < 0) || (sr & AT25_SR_nRDY)) { 233e51d565fSWolfram Sang dev_err(&at25->spi->dev, 234e51d565fSWolfram Sang "write %d bytes offset %d, " 235e51d565fSWolfram Sang "timeout after %u msecs\n", 236e51d565fSWolfram Sang segment, offset, 237e51d565fSWolfram Sang jiffies_to_msecs(jiffies - 238e51d565fSWolfram Sang (timeout - EE_TIMEOUT))); 239e51d565fSWolfram Sang status = -ETIMEDOUT; 240e51d565fSWolfram Sang break; 241e51d565fSWolfram Sang } 242e51d565fSWolfram Sang 243e51d565fSWolfram Sang off += segment; 244e51d565fSWolfram Sang buf += segment; 245e51d565fSWolfram Sang count -= segment; 246e51d565fSWolfram Sang written += segment; 247e51d565fSWolfram Sang 248e51d565fSWolfram Sang } while (count > 0); 249e51d565fSWolfram Sang 250e51d565fSWolfram Sang mutex_unlock(&at25->lock); 251e51d565fSWolfram Sang 252e51d565fSWolfram Sang kfree(bounce); 253e51d565fSWolfram Sang return written ? written : status; 254e51d565fSWolfram Sang } 255e51d565fSWolfram Sang 256e51d565fSWolfram Sang static ssize_t 2572c3c8beaSChris Wright at25_bin_write(struct file *filp, struct kobject *kobj, 2582c3c8beaSChris Wright struct bin_attribute *bin_attr, 259e51d565fSWolfram Sang char *buf, loff_t off, size_t count) 260e51d565fSWolfram Sang { 261e51d565fSWolfram Sang struct device *dev; 262e51d565fSWolfram Sang struct at25_data *at25; 263e51d565fSWolfram Sang 264e51d565fSWolfram Sang dev = container_of(kobj, struct device, kobj); 265e51d565fSWolfram Sang at25 = dev_get_drvdata(dev); 266e51d565fSWolfram Sang 267e51d565fSWolfram Sang return at25_ee_write(at25, buf, off, count); 268e51d565fSWolfram Sang } 269e51d565fSWolfram Sang 270e51d565fSWolfram Sang /*-------------------------------------------------------------------------*/ 271e51d565fSWolfram Sang 27214dd1ff0SDavid Brownell /* Let in-kernel code access the eeprom data. */ 27314dd1ff0SDavid Brownell 27414dd1ff0SDavid Brownell static ssize_t at25_mem_read(struct memory_accessor *mem, char *buf, 27514dd1ff0SDavid Brownell off_t offset, size_t count) 27614dd1ff0SDavid Brownell { 27714dd1ff0SDavid Brownell struct at25_data *at25 = container_of(mem, struct at25_data, mem); 27814dd1ff0SDavid Brownell 27914dd1ff0SDavid Brownell return at25_ee_read(at25, buf, offset, count); 28014dd1ff0SDavid Brownell } 28114dd1ff0SDavid Brownell 2824cafbd0bSGeert Uytterhoeven static ssize_t at25_mem_write(struct memory_accessor *mem, const char *buf, 28314dd1ff0SDavid Brownell off_t offset, size_t count) 28414dd1ff0SDavid Brownell { 28514dd1ff0SDavid Brownell struct at25_data *at25 = container_of(mem, struct at25_data, mem); 28614dd1ff0SDavid Brownell 28714dd1ff0SDavid Brownell return at25_ee_write(at25, buf, offset, count); 28814dd1ff0SDavid Brownell } 28914dd1ff0SDavid Brownell 29014dd1ff0SDavid Brownell /*-------------------------------------------------------------------------*/ 29114dd1ff0SDavid Brownell 292e51d565fSWolfram Sang static int at25_probe(struct spi_device *spi) 293e51d565fSWolfram Sang { 294e51d565fSWolfram Sang struct at25_data *at25 = NULL; 295e51d565fSWolfram Sang const struct spi_eeprom *chip; 296e51d565fSWolfram Sang int err; 297e51d565fSWolfram Sang int sr; 298e51d565fSWolfram Sang int addrlen; 299e51d565fSWolfram Sang 300e51d565fSWolfram Sang /* Chip description */ 301e51d565fSWolfram Sang chip = spi->dev.platform_data; 302e51d565fSWolfram Sang if (!chip) { 303e51d565fSWolfram Sang dev_dbg(&spi->dev, "no chip description\n"); 304e51d565fSWolfram Sang err = -ENODEV; 305e51d565fSWolfram Sang goto fail; 306e51d565fSWolfram Sang } 307e51d565fSWolfram Sang 308e51d565fSWolfram Sang /* For now we only support 8/16/24 bit addressing */ 309e51d565fSWolfram Sang if (chip->flags & EE_ADDR1) 310e51d565fSWolfram Sang addrlen = 1; 311e51d565fSWolfram Sang else if (chip->flags & EE_ADDR2) 312e51d565fSWolfram Sang addrlen = 2; 313e51d565fSWolfram Sang else if (chip->flags & EE_ADDR3) 314e51d565fSWolfram Sang addrlen = 3; 315e51d565fSWolfram Sang else { 316e51d565fSWolfram Sang dev_dbg(&spi->dev, "unsupported address type\n"); 317e51d565fSWolfram Sang err = -EINVAL; 318e51d565fSWolfram Sang goto fail; 319e51d565fSWolfram Sang } 320e51d565fSWolfram Sang 321e51d565fSWolfram Sang /* Ping the chip ... the status register is pretty portable, 322e51d565fSWolfram Sang * unlike probing manufacturer IDs. We do expect that system 323e51d565fSWolfram Sang * firmware didn't write it in the past few milliseconds! 324e51d565fSWolfram Sang */ 325e51d565fSWolfram Sang sr = spi_w8r8(spi, AT25_RDSR); 326e51d565fSWolfram Sang if (sr < 0 || sr & AT25_SR_nRDY) { 327e51d565fSWolfram Sang dev_dbg(&spi->dev, "rdsr --> %d (%02x)\n", sr, sr); 328e51d565fSWolfram Sang err = -ENXIO; 329e51d565fSWolfram Sang goto fail; 330e51d565fSWolfram Sang } 331e51d565fSWolfram Sang 332e51d565fSWolfram Sang if (!(at25 = kzalloc(sizeof *at25, GFP_KERNEL))) { 333e51d565fSWolfram Sang err = -ENOMEM; 334e51d565fSWolfram Sang goto fail; 335e51d565fSWolfram Sang } 336e51d565fSWolfram Sang 337e51d565fSWolfram Sang mutex_init(&at25->lock); 338e51d565fSWolfram Sang at25->chip = *chip; 339e51d565fSWolfram Sang at25->spi = spi_dev_get(spi); 340e51d565fSWolfram Sang dev_set_drvdata(&spi->dev, at25); 341e51d565fSWolfram Sang at25->addrlen = addrlen; 342e51d565fSWolfram Sang 343e51d565fSWolfram Sang /* Export the EEPROM bytes through sysfs, since that's convenient. 34414dd1ff0SDavid Brownell * And maybe to other kernel code; it might hold a board's Ethernet 34514dd1ff0SDavid Brownell * address, or board-specific calibration data generated on the 34614dd1ff0SDavid Brownell * manufacturing floor. 34714dd1ff0SDavid Brownell * 348e51d565fSWolfram Sang * Default to root-only access to the data; EEPROMs often hold data 349e51d565fSWolfram Sang * that's sensitive for read and/or write, like ethernet addresses, 350e51d565fSWolfram Sang * security codes, board-specific manufacturing calibrations, etc. 351e51d565fSWolfram Sang */ 352f937331bSWolfram Sang sysfs_bin_attr_init(&at25->bin); 353e51d565fSWolfram Sang at25->bin.attr.name = "eeprom"; 354e51d565fSWolfram Sang at25->bin.attr.mode = S_IRUSR; 355e51d565fSWolfram Sang at25->bin.read = at25_bin_read; 35614dd1ff0SDavid Brownell at25->mem.read = at25_mem_read; 357e51d565fSWolfram Sang 358e51d565fSWolfram Sang at25->bin.size = at25->chip.byte_len; 359e51d565fSWolfram Sang if (!(chip->flags & EE_READONLY)) { 360e51d565fSWolfram Sang at25->bin.write = at25_bin_write; 361e51d565fSWolfram Sang at25->bin.attr.mode |= S_IWUSR; 36214dd1ff0SDavid Brownell at25->mem.write = at25_mem_write; 363e51d565fSWolfram Sang } 364e51d565fSWolfram Sang 365e51d565fSWolfram Sang err = sysfs_create_bin_file(&spi->dev.kobj, &at25->bin); 366e51d565fSWolfram Sang if (err) 367e51d565fSWolfram Sang goto fail; 368e51d565fSWolfram Sang 36914dd1ff0SDavid Brownell if (chip->setup) 37014dd1ff0SDavid Brownell chip->setup(&at25->mem, chip->context); 37114dd1ff0SDavid Brownell 372e51d565fSWolfram Sang dev_info(&spi->dev, "%Zd %s %s eeprom%s, pagesize %u\n", 373e51d565fSWolfram Sang (at25->bin.size < 1024) 374e51d565fSWolfram Sang ? at25->bin.size 375e51d565fSWolfram Sang : (at25->bin.size / 1024), 376e51d565fSWolfram Sang (at25->bin.size < 1024) ? "Byte" : "KByte", 377e51d565fSWolfram Sang at25->chip.name, 378e51d565fSWolfram Sang (chip->flags & EE_READONLY) ? " (readonly)" : "", 379e51d565fSWolfram Sang at25->chip.page_size); 380e51d565fSWolfram Sang return 0; 381e51d565fSWolfram Sang fail: 382e51d565fSWolfram Sang dev_dbg(&spi->dev, "probe err %d\n", err); 383e51d565fSWolfram Sang kfree(at25); 384e51d565fSWolfram Sang return err; 385e51d565fSWolfram Sang } 386e51d565fSWolfram Sang 387e51d565fSWolfram Sang static int __devexit at25_remove(struct spi_device *spi) 388e51d565fSWolfram Sang { 389e51d565fSWolfram Sang struct at25_data *at25; 390e51d565fSWolfram Sang 391e51d565fSWolfram Sang at25 = dev_get_drvdata(&spi->dev); 392e51d565fSWolfram Sang sysfs_remove_bin_file(&spi->dev.kobj, &at25->bin); 393e51d565fSWolfram Sang kfree(at25); 394e51d565fSWolfram Sang return 0; 395e51d565fSWolfram Sang } 396e51d565fSWolfram Sang 397e51d565fSWolfram Sang /*-------------------------------------------------------------------------*/ 398e51d565fSWolfram Sang 399e51d565fSWolfram Sang static struct spi_driver at25_driver = { 400e51d565fSWolfram Sang .driver = { 401e51d565fSWolfram Sang .name = "at25", 402e51d565fSWolfram Sang .owner = THIS_MODULE, 403e51d565fSWolfram Sang }, 404e51d565fSWolfram Sang .probe = at25_probe, 405e51d565fSWolfram Sang .remove = __devexit_p(at25_remove), 406e51d565fSWolfram Sang }; 407e51d565fSWolfram Sang 408*a3dc3c9eSAxel Lin module_spi_driver(at25_driver); 409e51d565fSWolfram Sang 410e51d565fSWolfram Sang MODULE_DESCRIPTION("Driver for most SPI EEPROMs"); 411e51d565fSWolfram Sang MODULE_AUTHOR("David Brownell"); 412e51d565fSWolfram Sang MODULE_LICENSE("GPL"); 413e0626e38SAnton Vorontsov MODULE_ALIAS("spi:at25"); 414