15195e509SWolfram Sang /* 25195e509SWolfram Sang * at24.c - handle most I2C EEPROMs 35195e509SWolfram Sang * 45195e509SWolfram Sang * Copyright (C) 2005-2007 David Brownell 55195e509SWolfram Sang * Copyright (C) 2008 Wolfram Sang, Pengutronix 65195e509SWolfram Sang * 75195e509SWolfram Sang * This program is free software; you can redistribute it and/or modify 85195e509SWolfram Sang * it under the terms of the GNU General Public License as published by 95195e509SWolfram Sang * the Free Software Foundation; either version 2 of the License, or 105195e509SWolfram Sang * (at your option) any later version. 115195e509SWolfram Sang */ 125195e509SWolfram Sang #include <linux/kernel.h> 135195e509SWolfram Sang #include <linux/init.h> 145195e509SWolfram Sang #include <linux/module.h> 155195e509SWolfram Sang #include <linux/slab.h> 165195e509SWolfram Sang #include <linux/delay.h> 175195e509SWolfram Sang #include <linux/mutex.h> 185195e509SWolfram Sang #include <linux/sysfs.h> 195195e509SWolfram Sang #include <linux/mod_devicetable.h> 205195e509SWolfram Sang #include <linux/log2.h> 215195e509SWolfram Sang #include <linux/bitops.h> 225195e509SWolfram Sang #include <linux/jiffies.h> 235195e509SWolfram Sang #include <linux/i2c.h> 245195e509SWolfram Sang #include <linux/i2c/at24.h> 255195e509SWolfram Sang 265195e509SWolfram Sang /* 275195e509SWolfram Sang * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable. 285195e509SWolfram Sang * Differences between different vendor product lines (like Atmel AT24C or 295195e509SWolfram Sang * MicroChip 24LC, etc) won't much matter for typical read/write access. 305195e509SWolfram Sang * There are also I2C RAM chips, likewise interchangeable. One example 315195e509SWolfram Sang * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes). 325195e509SWolfram Sang * 335195e509SWolfram Sang * However, misconfiguration can lose data. "Set 16-bit memory address" 345195e509SWolfram Sang * to a part with 8-bit addressing will overwrite data. Writing with too 355195e509SWolfram Sang * big a page size also loses data. And it's not safe to assume that the 365195e509SWolfram Sang * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC 375195e509SWolfram Sang * uses 0x51, for just one example. 385195e509SWolfram Sang * 395195e509SWolfram Sang * Accordingly, explicit board-specific configuration data should be used 405195e509SWolfram Sang * in almost all cases. (One partial exception is an SMBus used to access 415195e509SWolfram Sang * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.) 425195e509SWolfram Sang * 435195e509SWolfram Sang * So this driver uses "new style" I2C driver binding, expecting to be 445195e509SWolfram Sang * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or 455195e509SWolfram Sang * similar kernel-resident tables; or, configuration data coming from 465195e509SWolfram Sang * a bootloader. 475195e509SWolfram Sang * 485195e509SWolfram Sang * Other than binding model, current differences from "eeprom" driver are 495195e509SWolfram Sang * that this one handles write access and isn't restricted to 24c02 devices. 505195e509SWolfram Sang * It also handles larger devices (32 kbit and up) with two-byte addresses, 515195e509SWolfram Sang * which won't work on pure SMBus systems. 525195e509SWolfram Sang */ 535195e509SWolfram Sang 545195e509SWolfram Sang struct at24_data { 555195e509SWolfram Sang struct at24_platform_data chip; 567274ec8bSKevin Hilman struct memory_accessor macc; 575195e509SWolfram Sang bool use_smbus; 585195e509SWolfram Sang 595195e509SWolfram Sang /* 605195e509SWolfram Sang * Lock protects against activities from other Linux tasks, 615195e509SWolfram Sang * but not from changes by other I2C masters. 625195e509SWolfram Sang */ 635195e509SWolfram Sang struct mutex lock; 645195e509SWolfram Sang struct bin_attribute bin; 655195e509SWolfram Sang 665195e509SWolfram Sang u8 *writebuf; 675195e509SWolfram Sang unsigned write_max; 685195e509SWolfram Sang unsigned num_addresses; 695195e509SWolfram Sang 705195e509SWolfram Sang /* 715195e509SWolfram Sang * Some chips tie up multiple I2C addresses; dummy devices reserve 725195e509SWolfram Sang * them for us, and we'll use them with SMBus calls. 735195e509SWolfram Sang */ 745195e509SWolfram Sang struct i2c_client *client[]; 755195e509SWolfram Sang }; 765195e509SWolfram Sang 775195e509SWolfram Sang /* 785195e509SWolfram Sang * This parameter is to help this driver avoid blocking other drivers out 795195e509SWolfram Sang * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C 805195e509SWolfram Sang * clock, one 256 byte read takes about 1/43 second which is excessive; 815195e509SWolfram Sang * but the 1/170 second it takes at 400 kHz may be quite reasonable; and 825195e509SWolfram Sang * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible. 835195e509SWolfram Sang * 845195e509SWolfram Sang * This value is forced to be a power of two so that writes align on pages. 855195e509SWolfram Sang */ 865195e509SWolfram Sang static unsigned io_limit = 128; 875195e509SWolfram Sang module_param(io_limit, uint, 0); 885195e509SWolfram Sang MODULE_PARM_DESC(io_limit, "Maximum bytes per I/O (default 128)"); 895195e509SWolfram Sang 905195e509SWolfram Sang /* 915195e509SWolfram Sang * Specs often allow 5 msec for a page write, sometimes 20 msec; 925195e509SWolfram Sang * it's important to recover from write timeouts. 935195e509SWolfram Sang */ 945195e509SWolfram Sang static unsigned write_timeout = 25; 955195e509SWolfram Sang module_param(write_timeout, uint, 0); 965195e509SWolfram Sang MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)"); 975195e509SWolfram Sang 985195e509SWolfram Sang #define AT24_SIZE_BYTELEN 5 995195e509SWolfram Sang #define AT24_SIZE_FLAGS 8 1005195e509SWolfram Sang 1015195e509SWolfram Sang #define AT24_BITMASK(x) (BIT(x) - 1) 1025195e509SWolfram Sang 1035195e509SWolfram Sang /* create non-zero magic value for given eeprom parameters */ 1045195e509SWolfram Sang #define AT24_DEVICE_MAGIC(_len, _flags) \ 1055195e509SWolfram Sang ((1 << AT24_SIZE_FLAGS | (_flags)) \ 1065195e509SWolfram Sang << AT24_SIZE_BYTELEN | ilog2(_len)) 1075195e509SWolfram Sang 1085195e509SWolfram Sang static const struct i2c_device_id at24_ids[] = { 1095195e509SWolfram Sang /* needs 8 addresses as A0-A2 are ignored */ 1105195e509SWolfram Sang { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) }, 1115195e509SWolfram Sang /* old variants can't be handled with this generic entry! */ 1125195e509SWolfram Sang { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) }, 1135195e509SWolfram Sang { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) }, 1145195e509SWolfram Sang /* spd is a 24c02 in memory DIMMs */ 1155195e509SWolfram Sang { "spd", AT24_DEVICE_MAGIC(2048 / 8, 1165195e509SWolfram Sang AT24_FLAG_READONLY | AT24_FLAG_IRUGO) }, 1175195e509SWolfram Sang { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) }, 1185195e509SWolfram Sang /* 24rf08 quirk is handled at i2c-core */ 1195195e509SWolfram Sang { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 1205195e509SWolfram Sang { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) }, 1215195e509SWolfram Sang { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) }, 1225195e509SWolfram Sang { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) }, 1235195e509SWolfram Sang { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) }, 1245195e509SWolfram Sang { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) }, 1255195e509SWolfram Sang { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) }, 1265195e509SWolfram Sang { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) }, 1275195e509SWolfram Sang { "at24", 0 }, 1285195e509SWolfram Sang { /* END OF LIST */ } 1295195e509SWolfram Sang }; 1305195e509SWolfram Sang MODULE_DEVICE_TABLE(i2c, at24_ids); 1315195e509SWolfram Sang 1325195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 1335195e509SWolfram Sang 1345195e509SWolfram Sang /* 1355195e509SWolfram Sang * This routine supports chips which consume multiple I2C addresses. It 1365195e509SWolfram Sang * computes the addressing information to be used for a given r/w request. 1375195e509SWolfram Sang * Assumes that sanity checks for offset happened at sysfs-layer. 1385195e509SWolfram Sang */ 1395195e509SWolfram Sang static struct i2c_client *at24_translate_offset(struct at24_data *at24, 1405195e509SWolfram Sang unsigned *offset) 1415195e509SWolfram Sang { 1425195e509SWolfram Sang unsigned i; 1435195e509SWolfram Sang 1445195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) { 1455195e509SWolfram Sang i = *offset >> 16; 1465195e509SWolfram Sang *offset &= 0xffff; 1475195e509SWolfram Sang } else { 1485195e509SWolfram Sang i = *offset >> 8; 1495195e509SWolfram Sang *offset &= 0xff; 1505195e509SWolfram Sang } 1515195e509SWolfram Sang 1525195e509SWolfram Sang return at24->client[i]; 1535195e509SWolfram Sang } 1545195e509SWolfram Sang 1555195e509SWolfram Sang static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf, 1565195e509SWolfram Sang unsigned offset, size_t count) 1575195e509SWolfram Sang { 1585195e509SWolfram Sang struct i2c_msg msg[2]; 1595195e509SWolfram Sang u8 msgbuf[2]; 1605195e509SWolfram Sang struct i2c_client *client; 1614d29196cSWolfram Sang unsigned long timeout, read_time; 1625195e509SWolfram Sang int status, i; 1635195e509SWolfram Sang 1645195e509SWolfram Sang memset(msg, 0, sizeof(msg)); 1655195e509SWolfram Sang 1665195e509SWolfram Sang /* 1675195e509SWolfram Sang * REVISIT some multi-address chips don't rollover page reads to 1685195e509SWolfram Sang * the next slave address, so we may need to truncate the count. 1695195e509SWolfram Sang * Those chips might need another quirk flag. 1705195e509SWolfram Sang * 1715195e509SWolfram Sang * If the real hardware used four adjacent 24c02 chips and that 1725195e509SWolfram Sang * were misconfigured as one 24c08, that would be a similar effect: 1735195e509SWolfram Sang * one "eeprom" file not four, but larger reads would fail when 1745195e509SWolfram Sang * they crossed certain pages. 1755195e509SWolfram Sang */ 1765195e509SWolfram Sang 1775195e509SWolfram Sang /* 1785195e509SWolfram Sang * Slave address and byte offset derive from the offset. Always 1795195e509SWolfram Sang * set the byte address; on a multi-master board, another master 1805195e509SWolfram Sang * may have changed the chip's "current" address pointer. 1815195e509SWolfram Sang */ 1825195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 1835195e509SWolfram Sang 1845195e509SWolfram Sang if (count > io_limit) 1855195e509SWolfram Sang count = io_limit; 1865195e509SWolfram Sang 1875195e509SWolfram Sang if (at24->use_smbus) { 1884d29196cSWolfram Sang /* Smaller eeproms can work given some SMBus extension calls */ 1895195e509SWolfram Sang if (count > I2C_SMBUS_BLOCK_MAX) 1905195e509SWolfram Sang count = I2C_SMBUS_BLOCK_MAX; 1914d29196cSWolfram Sang } else { 1925195e509SWolfram Sang /* 1934d29196cSWolfram Sang * When we have a better choice than SMBus calls, use a 1944d29196cSWolfram Sang * combined I2C message. Write address; then read up to 1954d29196cSWolfram Sang * io_limit data bytes. Note that read page rollover helps us 1964d29196cSWolfram Sang * here (unlike writes). msgbuf is u8 and will cast to our 1974d29196cSWolfram Sang * needs. 1985195e509SWolfram Sang */ 1995195e509SWolfram Sang i = 0; 2005195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 2015195e509SWolfram Sang msgbuf[i++] = offset >> 8; 2025195e509SWolfram Sang msgbuf[i++] = offset; 2035195e509SWolfram Sang 2045195e509SWolfram Sang msg[0].addr = client->addr; 2055195e509SWolfram Sang msg[0].buf = msgbuf; 2065195e509SWolfram Sang msg[0].len = i; 2075195e509SWolfram Sang 2085195e509SWolfram Sang msg[1].addr = client->addr; 2095195e509SWolfram Sang msg[1].flags = I2C_M_RD; 2105195e509SWolfram Sang msg[1].buf = buf; 2115195e509SWolfram Sang msg[1].len = count; 2124d29196cSWolfram Sang } 2135195e509SWolfram Sang 2144d29196cSWolfram Sang /* 2154d29196cSWolfram Sang * Reads fail if the previous write didn't complete yet. We may 2164d29196cSWolfram Sang * loop a few times until this one succeeds, waiting at least 2174d29196cSWolfram Sang * long enough for one entire page write to work. 2184d29196cSWolfram Sang */ 2194d29196cSWolfram Sang timeout = jiffies + msecs_to_jiffies(write_timeout); 2204d29196cSWolfram Sang do { 2214d29196cSWolfram Sang read_time = jiffies; 2224d29196cSWolfram Sang if (at24->use_smbus) { 2234d29196cSWolfram Sang status = i2c_smbus_read_i2c_block_data(client, offset, 2244d29196cSWolfram Sang count, buf); 2254d29196cSWolfram Sang } else { 2265195e509SWolfram Sang status = i2c_transfer(client->adapter, msg, 2); 2275195e509SWolfram Sang if (status == 2) 2284d29196cSWolfram Sang status = count; 2294d29196cSWolfram Sang } 2304d29196cSWolfram Sang dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 2314d29196cSWolfram Sang count, offset, status, jiffies); 2324d29196cSWolfram Sang 2334d29196cSWolfram Sang if (status == count) 2345195e509SWolfram Sang return count; 2354d29196cSWolfram Sang 2364d29196cSWolfram Sang /* REVISIT: at HZ=100, this is sloooow */ 2374d29196cSWolfram Sang msleep(1); 2384d29196cSWolfram Sang } while (time_before(read_time, timeout)); 2394d29196cSWolfram Sang 2404d29196cSWolfram Sang return -ETIMEDOUT; 2415195e509SWolfram Sang } 2425195e509SWolfram Sang 2437274ec8bSKevin Hilman static ssize_t at24_read(struct at24_data *at24, 2445195e509SWolfram Sang char *buf, loff_t off, size_t count) 2455195e509SWolfram Sang { 2465195e509SWolfram Sang ssize_t retval = 0; 2475195e509SWolfram Sang 2485195e509SWolfram Sang if (unlikely(!count)) 2495195e509SWolfram Sang return count; 2505195e509SWolfram Sang 2515195e509SWolfram Sang /* 2525195e509SWolfram Sang * Read data from chip, protecting against concurrent updates 2535195e509SWolfram Sang * from this host, but not from other I2C masters. 2545195e509SWolfram Sang */ 2555195e509SWolfram Sang mutex_lock(&at24->lock); 2565195e509SWolfram Sang 2575195e509SWolfram Sang while (count) { 2585195e509SWolfram Sang ssize_t status; 2595195e509SWolfram Sang 2605195e509SWolfram Sang status = at24_eeprom_read(at24, buf, off, count); 2615195e509SWolfram Sang if (status <= 0) { 2625195e509SWolfram Sang if (retval == 0) 2635195e509SWolfram Sang retval = status; 2645195e509SWolfram Sang break; 2655195e509SWolfram Sang } 2665195e509SWolfram Sang buf += status; 2675195e509SWolfram Sang off += status; 2685195e509SWolfram Sang count -= status; 2695195e509SWolfram Sang retval += status; 2705195e509SWolfram Sang } 2715195e509SWolfram Sang 2725195e509SWolfram Sang mutex_unlock(&at24->lock); 2735195e509SWolfram Sang 2745195e509SWolfram Sang return retval; 2755195e509SWolfram Sang } 2765195e509SWolfram Sang 2777274ec8bSKevin Hilman static ssize_t at24_bin_read(struct kobject *kobj, struct bin_attribute *attr, 2787274ec8bSKevin Hilman char *buf, loff_t off, size_t count) 2797274ec8bSKevin Hilman { 2807274ec8bSKevin Hilman struct at24_data *at24; 2815195e509SWolfram Sang 2827274ec8bSKevin Hilman at24 = dev_get_drvdata(container_of(kobj, struct device, kobj)); 2837274ec8bSKevin Hilman return at24_read(at24, buf, off, count); 2847274ec8bSKevin Hilman } 2855195e509SWolfram Sang 2865195e509SWolfram Sang 2875195e509SWolfram Sang /* 2885195e509SWolfram Sang * Note that if the hardware write-protect pin is pulled high, the whole 2895195e509SWolfram Sang * chip is normally write protected. But there are plenty of product 2905195e509SWolfram Sang * variants here, including OTP fuses and partial chip protect. 2915195e509SWolfram Sang * 2925195e509SWolfram Sang * We only use page mode writes; the alternative is sloooow. This routine 2935195e509SWolfram Sang * writes at most one page. 2945195e509SWolfram Sang */ 295280ca299SGeert Uytterhoeven static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf, 2965195e509SWolfram Sang unsigned offset, size_t count) 2975195e509SWolfram Sang { 2985195e509SWolfram Sang struct i2c_client *client; 2995195e509SWolfram Sang struct i2c_msg msg; 3005195e509SWolfram Sang ssize_t status; 3015195e509SWolfram Sang unsigned long timeout, write_time; 3025195e509SWolfram Sang unsigned next_page; 3035195e509SWolfram Sang 3045195e509SWolfram Sang /* Get corresponding I2C address and adjust offset */ 3055195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 3065195e509SWolfram Sang 3075195e509SWolfram Sang /* write_max is at most a page */ 3085195e509SWolfram Sang if (count > at24->write_max) 3095195e509SWolfram Sang count = at24->write_max; 3105195e509SWolfram Sang 3115195e509SWolfram Sang /* Never roll over backwards, to the start of this page */ 3125195e509SWolfram Sang next_page = roundup(offset + 1, at24->chip.page_size); 3135195e509SWolfram Sang if (offset + count > next_page) 3145195e509SWolfram Sang count = next_page - offset; 3155195e509SWolfram Sang 3165195e509SWolfram Sang /* If we'll use I2C calls for I/O, set up the message */ 3175195e509SWolfram Sang if (!at24->use_smbus) { 3185195e509SWolfram Sang int i = 0; 3195195e509SWolfram Sang 3205195e509SWolfram Sang msg.addr = client->addr; 3215195e509SWolfram Sang msg.flags = 0; 3225195e509SWolfram Sang 3235195e509SWolfram Sang /* msg.buf is u8 and casts will mask the values */ 3245195e509SWolfram Sang msg.buf = at24->writebuf; 3255195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 3265195e509SWolfram Sang msg.buf[i++] = offset >> 8; 3275195e509SWolfram Sang 3285195e509SWolfram Sang msg.buf[i++] = offset; 3295195e509SWolfram Sang memcpy(&msg.buf[i], buf, count); 3305195e509SWolfram Sang msg.len = i + count; 3315195e509SWolfram Sang } 3325195e509SWolfram Sang 3335195e509SWolfram Sang /* 3345195e509SWolfram Sang * Writes fail if the previous one didn't complete yet. We may 3355195e509SWolfram Sang * loop a few times until this one succeeds, waiting at least 3365195e509SWolfram Sang * long enough for one entire page write to work. 3375195e509SWolfram Sang */ 3385195e509SWolfram Sang timeout = jiffies + msecs_to_jiffies(write_timeout); 3395195e509SWolfram Sang do { 3405195e509SWolfram Sang write_time = jiffies; 3415195e509SWolfram Sang if (at24->use_smbus) { 3425195e509SWolfram Sang status = i2c_smbus_write_i2c_block_data(client, 3435195e509SWolfram Sang offset, count, buf); 3445195e509SWolfram Sang if (status == 0) 3455195e509SWolfram Sang status = count; 3465195e509SWolfram Sang } else { 3475195e509SWolfram Sang status = i2c_transfer(client->adapter, &msg, 1); 3485195e509SWolfram Sang if (status == 1) 3495195e509SWolfram Sang status = count; 3505195e509SWolfram Sang } 3515195e509SWolfram Sang dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n", 3525195e509SWolfram Sang count, offset, status, jiffies); 3535195e509SWolfram Sang 3545195e509SWolfram Sang if (status == count) 3555195e509SWolfram Sang return count; 3565195e509SWolfram Sang 3575195e509SWolfram Sang /* REVISIT: at HZ=100, this is sloooow */ 3585195e509SWolfram Sang msleep(1); 3595195e509SWolfram Sang } while (time_before(write_time, timeout)); 3605195e509SWolfram Sang 3615195e509SWolfram Sang return -ETIMEDOUT; 3625195e509SWolfram Sang } 3635195e509SWolfram Sang 364280ca299SGeert Uytterhoeven static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off, 365280ca299SGeert Uytterhoeven size_t count) 3665195e509SWolfram Sang { 3675195e509SWolfram Sang ssize_t retval = 0; 3685195e509SWolfram Sang 3695195e509SWolfram Sang if (unlikely(!count)) 3705195e509SWolfram Sang return count; 3715195e509SWolfram Sang 3725195e509SWolfram Sang /* 3735195e509SWolfram Sang * Write data to chip, protecting against concurrent updates 3745195e509SWolfram Sang * from this host, but not from other I2C masters. 3755195e509SWolfram Sang */ 3765195e509SWolfram Sang mutex_lock(&at24->lock); 3775195e509SWolfram Sang 3785195e509SWolfram Sang while (count) { 3795195e509SWolfram Sang ssize_t status; 3805195e509SWolfram Sang 3815195e509SWolfram Sang status = at24_eeprom_write(at24, buf, off, count); 3825195e509SWolfram Sang if (status <= 0) { 3835195e509SWolfram Sang if (retval == 0) 3845195e509SWolfram Sang retval = status; 3855195e509SWolfram Sang break; 3865195e509SWolfram Sang } 3875195e509SWolfram Sang buf += status; 3885195e509SWolfram Sang off += status; 3895195e509SWolfram Sang count -= status; 3905195e509SWolfram Sang retval += status; 3915195e509SWolfram Sang } 3925195e509SWolfram Sang 3935195e509SWolfram Sang mutex_unlock(&at24->lock); 3945195e509SWolfram Sang 3955195e509SWolfram Sang return retval; 3965195e509SWolfram Sang } 3975195e509SWolfram Sang 3987274ec8bSKevin Hilman static ssize_t at24_bin_write(struct kobject *kobj, struct bin_attribute *attr, 3997274ec8bSKevin Hilman char *buf, loff_t off, size_t count) 4007274ec8bSKevin Hilman { 4017274ec8bSKevin Hilman struct at24_data *at24; 4027274ec8bSKevin Hilman 4037274ec8bSKevin Hilman at24 = dev_get_drvdata(container_of(kobj, struct device, kobj)); 4047274ec8bSKevin Hilman return at24_write(at24, buf, off, count); 4057274ec8bSKevin Hilman } 4067274ec8bSKevin Hilman 4077274ec8bSKevin Hilman /*-------------------------------------------------------------------------*/ 4087274ec8bSKevin Hilman 4097274ec8bSKevin Hilman /* 4107274ec8bSKevin Hilman * This lets other kernel code access the eeprom data. For example, it 4117274ec8bSKevin Hilman * might hold a board's Ethernet address, or board-specific calibration 4127274ec8bSKevin Hilman * data generated on the manufacturing floor. 4137274ec8bSKevin Hilman */ 4147274ec8bSKevin Hilman 4157274ec8bSKevin Hilman static ssize_t at24_macc_read(struct memory_accessor *macc, char *buf, 4167274ec8bSKevin Hilman off_t offset, size_t count) 4177274ec8bSKevin Hilman { 4187274ec8bSKevin Hilman struct at24_data *at24 = container_of(macc, struct at24_data, macc); 4197274ec8bSKevin Hilman 4207274ec8bSKevin Hilman return at24_read(at24, buf, offset, count); 4217274ec8bSKevin Hilman } 4227274ec8bSKevin Hilman 423280ca299SGeert Uytterhoeven static ssize_t at24_macc_write(struct memory_accessor *macc, const char *buf, 4247274ec8bSKevin Hilman off_t offset, size_t count) 4257274ec8bSKevin Hilman { 4267274ec8bSKevin Hilman struct at24_data *at24 = container_of(macc, struct at24_data, macc); 4277274ec8bSKevin Hilman 4287274ec8bSKevin Hilman return at24_write(at24, buf, offset, count); 4297274ec8bSKevin Hilman } 4307274ec8bSKevin Hilman 4315195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 4325195e509SWolfram Sang 4335195e509SWolfram Sang static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) 4345195e509SWolfram Sang { 4355195e509SWolfram Sang struct at24_platform_data chip; 4365195e509SWolfram Sang bool writable; 4375195e509SWolfram Sang bool use_smbus = false; 4385195e509SWolfram Sang struct at24_data *at24; 4395195e509SWolfram Sang int err; 4405195e509SWolfram Sang unsigned i, num_addresses; 4415195e509SWolfram Sang kernel_ulong_t magic; 4425195e509SWolfram Sang 4435195e509SWolfram Sang if (client->dev.platform_data) { 4445195e509SWolfram Sang chip = *(struct at24_platform_data *)client->dev.platform_data; 4455195e509SWolfram Sang } else { 4465195e509SWolfram Sang if (!id->driver_data) { 4475195e509SWolfram Sang err = -ENODEV; 4485195e509SWolfram Sang goto err_out; 4495195e509SWolfram Sang } 4505195e509SWolfram Sang magic = id->driver_data; 4515195e509SWolfram Sang chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN)); 4525195e509SWolfram Sang magic >>= AT24_SIZE_BYTELEN; 4535195e509SWolfram Sang chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS); 4545195e509SWolfram Sang /* 4555195e509SWolfram Sang * This is slow, but we can't know all eeproms, so we better 4565195e509SWolfram Sang * play safe. Specifying custom eeprom-types via platform_data 4575195e509SWolfram Sang * is recommended anyhow. 4585195e509SWolfram Sang */ 4595195e509SWolfram Sang chip.page_size = 1; 4607274ec8bSKevin Hilman 4617274ec8bSKevin Hilman chip.setup = NULL; 4627274ec8bSKevin Hilman chip.context = NULL; 4635195e509SWolfram Sang } 4645195e509SWolfram Sang 4655195e509SWolfram Sang if (!is_power_of_2(chip.byte_len)) 4665195e509SWolfram Sang dev_warn(&client->dev, 4675195e509SWolfram Sang "byte_len looks suspicious (no power of 2)!\n"); 4685195e509SWolfram Sang if (!is_power_of_2(chip.page_size)) 4695195e509SWolfram Sang dev_warn(&client->dev, 4705195e509SWolfram Sang "page_size looks suspicious (no power of 2)!\n"); 4715195e509SWolfram Sang 4725195e509SWolfram Sang /* Use I2C operations unless we're stuck with SMBus extensions. */ 4735195e509SWolfram Sang if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 4745195e509SWolfram Sang if (chip.flags & AT24_FLAG_ADDR16) { 4755195e509SWolfram Sang err = -EPFNOSUPPORT; 4765195e509SWolfram Sang goto err_out; 4775195e509SWolfram Sang } 4785195e509SWolfram Sang if (!i2c_check_functionality(client->adapter, 4795195e509SWolfram Sang I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 4805195e509SWolfram Sang err = -EPFNOSUPPORT; 4815195e509SWolfram Sang goto err_out; 4825195e509SWolfram Sang } 4835195e509SWolfram Sang use_smbus = true; 4845195e509SWolfram Sang } 4855195e509SWolfram Sang 4865195e509SWolfram Sang if (chip.flags & AT24_FLAG_TAKE8ADDR) 4875195e509SWolfram Sang num_addresses = 8; 4885195e509SWolfram Sang else 4895195e509SWolfram Sang num_addresses = DIV_ROUND_UP(chip.byte_len, 4905195e509SWolfram Sang (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256); 4915195e509SWolfram Sang 4925195e509SWolfram Sang at24 = kzalloc(sizeof(struct at24_data) + 4935195e509SWolfram Sang num_addresses * sizeof(struct i2c_client *), GFP_KERNEL); 4945195e509SWolfram Sang if (!at24) { 4955195e509SWolfram Sang err = -ENOMEM; 4965195e509SWolfram Sang goto err_out; 4975195e509SWolfram Sang } 4985195e509SWolfram Sang 4995195e509SWolfram Sang mutex_init(&at24->lock); 5005195e509SWolfram Sang at24->use_smbus = use_smbus; 5015195e509SWolfram Sang at24->chip = chip; 5025195e509SWolfram Sang at24->num_addresses = num_addresses; 5035195e509SWolfram Sang 5045195e509SWolfram Sang /* 5055195e509SWolfram Sang * Export the EEPROM bytes through sysfs, since that's convenient. 5065195e509SWolfram Sang * By default, only root should see the data (maybe passwords etc) 5075195e509SWolfram Sang */ 508d07b56b3SWolfram Sang sysfs_bin_attr_init(&at24->bin); 5095195e509SWolfram Sang at24->bin.attr.name = "eeprom"; 5105195e509SWolfram Sang at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR; 5115195e509SWolfram Sang at24->bin.read = at24_bin_read; 5125195e509SWolfram Sang at24->bin.size = chip.byte_len; 5135195e509SWolfram Sang 5147274ec8bSKevin Hilman at24->macc.read = at24_macc_read; 5157274ec8bSKevin Hilman 5165195e509SWolfram Sang writable = !(chip.flags & AT24_FLAG_READONLY); 5175195e509SWolfram Sang if (writable) { 5185195e509SWolfram Sang if (!use_smbus || i2c_check_functionality(client->adapter, 5195195e509SWolfram Sang I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { 5205195e509SWolfram Sang 5215195e509SWolfram Sang unsigned write_max = chip.page_size; 5225195e509SWolfram Sang 5237274ec8bSKevin Hilman at24->macc.write = at24_macc_write; 5247274ec8bSKevin Hilman 5255195e509SWolfram Sang at24->bin.write = at24_bin_write; 5265195e509SWolfram Sang at24->bin.attr.mode |= S_IWUSR; 5275195e509SWolfram Sang 5285195e509SWolfram Sang if (write_max > io_limit) 5295195e509SWolfram Sang write_max = io_limit; 5305195e509SWolfram Sang if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX) 5315195e509SWolfram Sang write_max = I2C_SMBUS_BLOCK_MAX; 5325195e509SWolfram Sang at24->write_max = write_max; 5335195e509SWolfram Sang 5345195e509SWolfram Sang /* buffer (data + address at the beginning) */ 5355195e509SWolfram Sang at24->writebuf = kmalloc(write_max + 2, GFP_KERNEL); 5365195e509SWolfram Sang if (!at24->writebuf) { 5375195e509SWolfram Sang err = -ENOMEM; 5385195e509SWolfram Sang goto err_struct; 5395195e509SWolfram Sang } 5405195e509SWolfram Sang } else { 5415195e509SWolfram Sang dev_warn(&client->dev, 5425195e509SWolfram Sang "cannot write due to controller restrictions."); 5435195e509SWolfram Sang } 5445195e509SWolfram Sang } 5455195e509SWolfram Sang 5465195e509SWolfram Sang at24->client[0] = client; 5475195e509SWolfram Sang 5485195e509SWolfram Sang /* use dummy devices for multiple-address chips */ 5495195e509SWolfram Sang for (i = 1; i < num_addresses; i++) { 5505195e509SWolfram Sang at24->client[i] = i2c_new_dummy(client->adapter, 5515195e509SWolfram Sang client->addr + i); 5525195e509SWolfram Sang if (!at24->client[i]) { 5535195e509SWolfram Sang dev_err(&client->dev, "address 0x%02x unavailable\n", 5545195e509SWolfram Sang client->addr + i); 5555195e509SWolfram Sang err = -EADDRINUSE; 5565195e509SWolfram Sang goto err_clients; 5575195e509SWolfram Sang } 5585195e509SWolfram Sang } 5595195e509SWolfram Sang 5605195e509SWolfram Sang err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin); 5615195e509SWolfram Sang if (err) 5625195e509SWolfram Sang goto err_clients; 5635195e509SWolfram Sang 5645195e509SWolfram Sang i2c_set_clientdata(client, at24); 5655195e509SWolfram Sang 5665195e509SWolfram Sang dev_info(&client->dev, "%zu byte %s EEPROM %s\n", 5675195e509SWolfram Sang at24->bin.size, client->name, 5685195e509SWolfram Sang writable ? "(writable)" : "(read-only)"); 5695195e509SWolfram Sang dev_dbg(&client->dev, 5705195e509SWolfram Sang "page_size %d, num_addresses %d, write_max %d%s\n", 5715195e509SWolfram Sang chip.page_size, num_addresses, 5725195e509SWolfram Sang at24->write_max, 5735195e509SWolfram Sang use_smbus ? ", use_smbus" : ""); 5745195e509SWolfram Sang 5757274ec8bSKevin Hilman /* export data to kernel code */ 5767274ec8bSKevin Hilman if (chip.setup) 5777274ec8bSKevin Hilman chip.setup(&at24->macc, chip.context); 5787274ec8bSKevin Hilman 5795195e509SWolfram Sang return 0; 5805195e509SWolfram Sang 5815195e509SWolfram Sang err_clients: 5825195e509SWolfram Sang for (i = 1; i < num_addresses; i++) 5835195e509SWolfram Sang if (at24->client[i]) 5845195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 5855195e509SWolfram Sang 5865195e509SWolfram Sang kfree(at24->writebuf); 5875195e509SWolfram Sang err_struct: 5885195e509SWolfram Sang kfree(at24); 5895195e509SWolfram Sang err_out: 5905195e509SWolfram Sang dev_dbg(&client->dev, "probe error %d\n", err); 5915195e509SWolfram Sang return err; 5925195e509SWolfram Sang } 5935195e509SWolfram Sang 5945195e509SWolfram Sang static int __devexit at24_remove(struct i2c_client *client) 5955195e509SWolfram Sang { 5965195e509SWolfram Sang struct at24_data *at24; 5975195e509SWolfram Sang int i; 5985195e509SWolfram Sang 5995195e509SWolfram Sang at24 = i2c_get_clientdata(client); 6005195e509SWolfram Sang sysfs_remove_bin_file(&client->dev.kobj, &at24->bin); 6015195e509SWolfram Sang 6025195e509SWolfram Sang for (i = 1; i < at24->num_addresses; i++) 6035195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 6045195e509SWolfram Sang 6055195e509SWolfram Sang kfree(at24->writebuf); 6065195e509SWolfram Sang kfree(at24); 6075195e509SWolfram Sang i2c_set_clientdata(client, NULL); 6085195e509SWolfram Sang return 0; 6095195e509SWolfram Sang } 6105195e509SWolfram Sang 6115195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 6125195e509SWolfram Sang 6135195e509SWolfram Sang static struct i2c_driver at24_driver = { 6145195e509SWolfram Sang .driver = { 6155195e509SWolfram Sang .name = "at24", 6165195e509SWolfram Sang .owner = THIS_MODULE, 6175195e509SWolfram Sang }, 6185195e509SWolfram Sang .probe = at24_probe, 6195195e509SWolfram Sang .remove = __devexit_p(at24_remove), 6205195e509SWolfram Sang .id_table = at24_ids, 6215195e509SWolfram Sang }; 6225195e509SWolfram Sang 6235195e509SWolfram Sang static int __init at24_init(void) 6245195e509SWolfram Sang { 6255195e509SWolfram Sang io_limit = rounddown_pow_of_two(io_limit); 6265195e509SWolfram Sang return i2c_add_driver(&at24_driver); 6275195e509SWolfram Sang } 6285195e509SWolfram Sang module_init(at24_init); 6295195e509SWolfram Sang 6305195e509SWolfram Sang static void __exit at24_exit(void) 6315195e509SWolfram Sang { 6325195e509SWolfram Sang i2c_del_driver(&at24_driver); 6335195e509SWolfram Sang } 6345195e509SWolfram Sang module_exit(at24_exit); 6355195e509SWolfram Sang 6365195e509SWolfram Sang MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); 6375195e509SWolfram Sang MODULE_AUTHOR("David Brownell and Wolfram Sang"); 6385195e509SWolfram Sang MODULE_LICENSE("GPL"); 639