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 129e51d565fSWolfram Sang at25_bin_read(struct kobject *kobj, struct bin_attribute *bin_attr, 130e51d565fSWolfram Sang char *buf, loff_t off, size_t count) 131e51d565fSWolfram Sang { 132e51d565fSWolfram Sang struct device *dev; 133e51d565fSWolfram Sang struct at25_data *at25; 134e51d565fSWolfram Sang 135e51d565fSWolfram Sang dev = container_of(kobj, struct device, kobj); 136e51d565fSWolfram Sang at25 = dev_get_drvdata(dev); 137e51d565fSWolfram Sang 138e51d565fSWolfram Sang return at25_ee_read(at25, buf, off, count); 139e51d565fSWolfram Sang } 140e51d565fSWolfram Sang 141e51d565fSWolfram Sang 142e51d565fSWolfram Sang static ssize_t 1434cafbd0bSGeert Uytterhoeven at25_ee_write(struct at25_data *at25, const char *buf, loff_t off, 1444cafbd0bSGeert Uytterhoeven size_t count) 145e51d565fSWolfram Sang { 146e51d565fSWolfram Sang ssize_t status = 0; 147e51d565fSWolfram Sang unsigned written = 0; 148e51d565fSWolfram Sang unsigned buf_size; 149e51d565fSWolfram Sang u8 *bounce; 150e51d565fSWolfram Sang 15114dd1ff0SDavid Brownell if (unlikely(off >= at25->bin.size)) 15214dd1ff0SDavid Brownell return -EFBIG; 15314dd1ff0SDavid Brownell if ((off + count) > at25->bin.size) 15414dd1ff0SDavid Brownell count = at25->bin.size - off; 15514dd1ff0SDavid Brownell if (unlikely(!count)) 15614dd1ff0SDavid Brownell return count; 15714dd1ff0SDavid Brownell 158e51d565fSWolfram Sang /* Temp buffer starts with command and address */ 159e51d565fSWolfram Sang buf_size = at25->chip.page_size; 160e51d565fSWolfram Sang if (buf_size > io_limit) 161e51d565fSWolfram Sang buf_size = io_limit; 162e51d565fSWolfram Sang bounce = kmalloc(buf_size + at25->addrlen + 1, GFP_KERNEL); 163e51d565fSWolfram Sang if (!bounce) 164e51d565fSWolfram Sang return -ENOMEM; 165e51d565fSWolfram Sang 166e51d565fSWolfram Sang /* For write, rollover is within the page ... so we write at 167e51d565fSWolfram Sang * most one page, then manually roll over to the next page. 168e51d565fSWolfram Sang */ 169e51d565fSWolfram Sang bounce[0] = AT25_WRITE; 170e51d565fSWolfram Sang mutex_lock(&at25->lock); 171e51d565fSWolfram Sang do { 172e51d565fSWolfram Sang unsigned long timeout, retries; 173e51d565fSWolfram Sang unsigned segment; 174e51d565fSWolfram Sang unsigned offset = (unsigned) off; 175e51d565fSWolfram Sang u8 *cp = bounce + 1; 176f0d83679SSebastian Heutling int sr; 177e51d565fSWolfram Sang 178e51d565fSWolfram Sang *cp = AT25_WREN; 179e51d565fSWolfram Sang status = spi_write(at25->spi, cp, 1); 180e51d565fSWolfram Sang if (status < 0) { 181e51d565fSWolfram Sang dev_dbg(&at25->spi->dev, "WREN --> %d\n", 182e51d565fSWolfram Sang (int) status); 183e51d565fSWolfram Sang break; 184e51d565fSWolfram Sang } 185e51d565fSWolfram Sang 186e51d565fSWolfram Sang /* 8/16/24-bit address is written MSB first */ 187e51d565fSWolfram Sang switch (at25->addrlen) { 188e51d565fSWolfram Sang default: /* case 3 */ 189e51d565fSWolfram Sang *cp++ = offset >> 16; 190e51d565fSWolfram Sang case 2: 191e51d565fSWolfram Sang *cp++ = offset >> 8; 192e51d565fSWolfram Sang case 1: 193e51d565fSWolfram Sang case 0: /* can't happen: for better codegen */ 194e51d565fSWolfram Sang *cp++ = offset >> 0; 195e51d565fSWolfram Sang } 196e51d565fSWolfram Sang 197e51d565fSWolfram Sang /* Write as much of a page as we can */ 198e51d565fSWolfram Sang segment = buf_size - (offset % buf_size); 199e51d565fSWolfram Sang if (segment > count) 200e51d565fSWolfram Sang segment = count; 201e51d565fSWolfram Sang memcpy(cp, buf, segment); 202e51d565fSWolfram Sang status = spi_write(at25->spi, bounce, 203e51d565fSWolfram Sang segment + at25->addrlen + 1); 204e51d565fSWolfram Sang dev_dbg(&at25->spi->dev, 205e51d565fSWolfram Sang "write %u bytes at %u --> %d\n", 206e51d565fSWolfram Sang segment, offset, (int) status); 207e51d565fSWolfram Sang if (status < 0) 208e51d565fSWolfram Sang break; 209e51d565fSWolfram Sang 210e51d565fSWolfram Sang /* REVISIT this should detect (or prevent) failed writes 211e51d565fSWolfram Sang * to readonly sections of the EEPROM... 212e51d565fSWolfram Sang */ 213e51d565fSWolfram Sang 214e51d565fSWolfram Sang /* Wait for non-busy status */ 215e51d565fSWolfram Sang timeout = jiffies + msecs_to_jiffies(EE_TIMEOUT); 216e51d565fSWolfram Sang retries = 0; 217e51d565fSWolfram Sang do { 218e51d565fSWolfram Sang 219e51d565fSWolfram Sang sr = spi_w8r8(at25->spi, AT25_RDSR); 220e51d565fSWolfram Sang if (sr < 0 || (sr & AT25_SR_nRDY)) { 221e51d565fSWolfram Sang dev_dbg(&at25->spi->dev, 222e51d565fSWolfram Sang "rdsr --> %d (%02x)\n", sr, sr); 223e51d565fSWolfram Sang /* at HZ=100, this is sloooow */ 224e51d565fSWolfram Sang msleep(1); 225e51d565fSWolfram Sang continue; 226e51d565fSWolfram Sang } 227e51d565fSWolfram Sang if (!(sr & AT25_SR_nRDY)) 228e51d565fSWolfram Sang break; 229e51d565fSWolfram Sang } while (retries++ < 3 || time_before_eq(jiffies, timeout)); 230e51d565fSWolfram Sang 231f0d83679SSebastian Heutling if ((sr < 0) || (sr & AT25_SR_nRDY)) { 232e51d565fSWolfram Sang dev_err(&at25->spi->dev, 233e51d565fSWolfram Sang "write %d bytes offset %d, " 234e51d565fSWolfram Sang "timeout after %u msecs\n", 235e51d565fSWolfram Sang segment, offset, 236e51d565fSWolfram Sang jiffies_to_msecs(jiffies - 237e51d565fSWolfram Sang (timeout - EE_TIMEOUT))); 238e51d565fSWolfram Sang status = -ETIMEDOUT; 239e51d565fSWolfram Sang break; 240e51d565fSWolfram Sang } 241e51d565fSWolfram Sang 242e51d565fSWolfram Sang off += segment; 243e51d565fSWolfram Sang buf += segment; 244e51d565fSWolfram Sang count -= segment; 245e51d565fSWolfram Sang written += segment; 246e51d565fSWolfram Sang 247e51d565fSWolfram Sang } while (count > 0); 248e51d565fSWolfram Sang 249e51d565fSWolfram Sang mutex_unlock(&at25->lock); 250e51d565fSWolfram Sang 251e51d565fSWolfram Sang kfree(bounce); 252e51d565fSWolfram Sang return written ? written : status; 253e51d565fSWolfram Sang } 254e51d565fSWolfram Sang 255e51d565fSWolfram Sang static ssize_t 256e51d565fSWolfram Sang at25_bin_write(struct kobject *kobj, struct bin_attribute *bin_attr, 257e51d565fSWolfram Sang char *buf, loff_t off, size_t count) 258e51d565fSWolfram Sang { 259e51d565fSWolfram Sang struct device *dev; 260e51d565fSWolfram Sang struct at25_data *at25; 261e51d565fSWolfram Sang 262e51d565fSWolfram Sang dev = container_of(kobj, struct device, kobj); 263e51d565fSWolfram Sang at25 = dev_get_drvdata(dev); 264e51d565fSWolfram Sang 265e51d565fSWolfram Sang return at25_ee_write(at25, buf, off, count); 266e51d565fSWolfram Sang } 267e51d565fSWolfram Sang 268e51d565fSWolfram Sang /*-------------------------------------------------------------------------*/ 269e51d565fSWolfram Sang 27014dd1ff0SDavid Brownell /* Let in-kernel code access the eeprom data. */ 27114dd1ff0SDavid Brownell 27214dd1ff0SDavid Brownell static ssize_t at25_mem_read(struct memory_accessor *mem, char *buf, 27314dd1ff0SDavid Brownell off_t offset, size_t count) 27414dd1ff0SDavid Brownell { 27514dd1ff0SDavid Brownell struct at25_data *at25 = container_of(mem, struct at25_data, mem); 27614dd1ff0SDavid Brownell 27714dd1ff0SDavid Brownell return at25_ee_read(at25, buf, offset, count); 27814dd1ff0SDavid Brownell } 27914dd1ff0SDavid Brownell 2804cafbd0bSGeert Uytterhoeven static ssize_t at25_mem_write(struct memory_accessor *mem, const char *buf, 28114dd1ff0SDavid Brownell off_t offset, size_t count) 28214dd1ff0SDavid Brownell { 28314dd1ff0SDavid Brownell struct at25_data *at25 = container_of(mem, struct at25_data, mem); 28414dd1ff0SDavid Brownell 28514dd1ff0SDavid Brownell return at25_ee_write(at25, buf, offset, count); 28614dd1ff0SDavid Brownell } 28714dd1ff0SDavid Brownell 28814dd1ff0SDavid Brownell /*-------------------------------------------------------------------------*/ 28914dd1ff0SDavid Brownell 290e51d565fSWolfram Sang static int at25_probe(struct spi_device *spi) 291e51d565fSWolfram Sang { 292e51d565fSWolfram Sang struct at25_data *at25 = NULL; 293e51d565fSWolfram Sang const struct spi_eeprom *chip; 294e51d565fSWolfram Sang int err; 295e51d565fSWolfram Sang int sr; 296e51d565fSWolfram Sang int addrlen; 297e51d565fSWolfram Sang 298e51d565fSWolfram Sang /* Chip description */ 299e51d565fSWolfram Sang chip = spi->dev.platform_data; 300e51d565fSWolfram Sang if (!chip) { 301e51d565fSWolfram Sang dev_dbg(&spi->dev, "no chip description\n"); 302e51d565fSWolfram Sang err = -ENODEV; 303e51d565fSWolfram Sang goto fail; 304e51d565fSWolfram Sang } 305e51d565fSWolfram Sang 306e51d565fSWolfram Sang /* For now we only support 8/16/24 bit addressing */ 307e51d565fSWolfram Sang if (chip->flags & EE_ADDR1) 308e51d565fSWolfram Sang addrlen = 1; 309e51d565fSWolfram Sang else if (chip->flags & EE_ADDR2) 310e51d565fSWolfram Sang addrlen = 2; 311e51d565fSWolfram Sang else if (chip->flags & EE_ADDR3) 312e51d565fSWolfram Sang addrlen = 3; 313e51d565fSWolfram Sang else { 314e51d565fSWolfram Sang dev_dbg(&spi->dev, "unsupported address type\n"); 315e51d565fSWolfram Sang err = -EINVAL; 316e51d565fSWolfram Sang goto fail; 317e51d565fSWolfram Sang } 318e51d565fSWolfram Sang 319e51d565fSWolfram Sang /* Ping the chip ... the status register is pretty portable, 320e51d565fSWolfram Sang * unlike probing manufacturer IDs. We do expect that system 321e51d565fSWolfram Sang * firmware didn't write it in the past few milliseconds! 322e51d565fSWolfram Sang */ 323e51d565fSWolfram Sang sr = spi_w8r8(spi, AT25_RDSR); 324e51d565fSWolfram Sang if (sr < 0 || sr & AT25_SR_nRDY) { 325e51d565fSWolfram Sang dev_dbg(&spi->dev, "rdsr --> %d (%02x)\n", sr, sr); 326e51d565fSWolfram Sang err = -ENXIO; 327e51d565fSWolfram Sang goto fail; 328e51d565fSWolfram Sang } 329e51d565fSWolfram Sang 330e51d565fSWolfram Sang if (!(at25 = kzalloc(sizeof *at25, GFP_KERNEL))) { 331e51d565fSWolfram Sang err = -ENOMEM; 332e51d565fSWolfram Sang goto fail; 333e51d565fSWolfram Sang } 334e51d565fSWolfram Sang 335e51d565fSWolfram Sang mutex_init(&at25->lock); 336e51d565fSWolfram Sang at25->chip = *chip; 337e51d565fSWolfram Sang at25->spi = spi_dev_get(spi); 338e51d565fSWolfram Sang dev_set_drvdata(&spi->dev, at25); 339e51d565fSWolfram Sang at25->addrlen = addrlen; 340e51d565fSWolfram Sang 341e51d565fSWolfram Sang /* Export the EEPROM bytes through sysfs, since that's convenient. 34214dd1ff0SDavid Brownell * And maybe to other kernel code; it might hold a board's Ethernet 34314dd1ff0SDavid Brownell * address, or board-specific calibration data generated on the 34414dd1ff0SDavid Brownell * manufacturing floor. 34514dd1ff0SDavid Brownell * 346e51d565fSWolfram Sang * Default to root-only access to the data; EEPROMs often hold data 347e51d565fSWolfram Sang * that's sensitive for read and/or write, like ethernet addresses, 348e51d565fSWolfram Sang * security codes, board-specific manufacturing calibrations, etc. 349e51d565fSWolfram Sang */ 350e51d565fSWolfram Sang at25->bin.attr.name = "eeprom"; 351e51d565fSWolfram Sang at25->bin.attr.mode = S_IRUSR; 352e51d565fSWolfram Sang at25->bin.read = at25_bin_read; 35314dd1ff0SDavid Brownell at25->mem.read = at25_mem_read; 354e51d565fSWolfram Sang 355e51d565fSWolfram Sang at25->bin.size = at25->chip.byte_len; 356e51d565fSWolfram Sang if (!(chip->flags & EE_READONLY)) { 357e51d565fSWolfram Sang at25->bin.write = at25_bin_write; 358e51d565fSWolfram Sang at25->bin.attr.mode |= S_IWUSR; 35914dd1ff0SDavid Brownell at25->mem.write = at25_mem_write; 360e51d565fSWolfram Sang } 361e51d565fSWolfram Sang 362e51d565fSWolfram Sang err = sysfs_create_bin_file(&spi->dev.kobj, &at25->bin); 363e51d565fSWolfram Sang if (err) 364e51d565fSWolfram Sang goto fail; 365e51d565fSWolfram Sang 36614dd1ff0SDavid Brownell if (chip->setup) 36714dd1ff0SDavid Brownell chip->setup(&at25->mem, chip->context); 36814dd1ff0SDavid Brownell 369e51d565fSWolfram Sang dev_info(&spi->dev, "%Zd %s %s eeprom%s, pagesize %u\n", 370e51d565fSWolfram Sang (at25->bin.size < 1024) 371e51d565fSWolfram Sang ? at25->bin.size 372e51d565fSWolfram Sang : (at25->bin.size / 1024), 373e51d565fSWolfram Sang (at25->bin.size < 1024) ? "Byte" : "KByte", 374e51d565fSWolfram Sang at25->chip.name, 375e51d565fSWolfram Sang (chip->flags & EE_READONLY) ? " (readonly)" : "", 376e51d565fSWolfram Sang at25->chip.page_size); 377e51d565fSWolfram Sang return 0; 378e51d565fSWolfram Sang fail: 379e51d565fSWolfram Sang dev_dbg(&spi->dev, "probe err %d\n", err); 380e51d565fSWolfram Sang kfree(at25); 381e51d565fSWolfram Sang return err; 382e51d565fSWolfram Sang } 383e51d565fSWolfram Sang 384e51d565fSWolfram Sang static int __devexit at25_remove(struct spi_device *spi) 385e51d565fSWolfram Sang { 386e51d565fSWolfram Sang struct at25_data *at25; 387e51d565fSWolfram Sang 388e51d565fSWolfram Sang at25 = dev_get_drvdata(&spi->dev); 389e51d565fSWolfram Sang sysfs_remove_bin_file(&spi->dev.kobj, &at25->bin); 390e51d565fSWolfram Sang kfree(at25); 391e51d565fSWolfram Sang return 0; 392e51d565fSWolfram Sang } 393e51d565fSWolfram Sang 394e51d565fSWolfram Sang /*-------------------------------------------------------------------------*/ 395e51d565fSWolfram Sang 396e51d565fSWolfram Sang static struct spi_driver at25_driver = { 397e51d565fSWolfram Sang .driver = { 398e51d565fSWolfram Sang .name = "at25", 399e51d565fSWolfram Sang .owner = THIS_MODULE, 400e51d565fSWolfram Sang }, 401e51d565fSWolfram Sang .probe = at25_probe, 402e51d565fSWolfram Sang .remove = __devexit_p(at25_remove), 403e51d565fSWolfram Sang }; 404e51d565fSWolfram Sang 405e51d565fSWolfram Sang static int __init at25_init(void) 406e51d565fSWolfram Sang { 407e51d565fSWolfram Sang return spi_register_driver(&at25_driver); 408e51d565fSWolfram Sang } 409e51d565fSWolfram Sang module_init(at25_init); 410e51d565fSWolfram Sang 411e51d565fSWolfram Sang static void __exit at25_exit(void) 412e51d565fSWolfram Sang { 413e51d565fSWolfram Sang spi_unregister_driver(&at25_driver); 414e51d565fSWolfram Sang } 415e51d565fSWolfram Sang module_exit(at25_exit); 416e51d565fSWolfram Sang 417e51d565fSWolfram Sang MODULE_DESCRIPTION("Driver for most SPI EEPROMs"); 418e51d565fSWolfram Sang MODULE_AUTHOR("David Brownell"); 419e51d565fSWolfram Sang MODULE_LICENSE("GPL"); 420*e0626e38SAnton Vorontsov MODULE_ALIAS("spi:at25"); 421