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