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> 239ed030d7SWolfram Sang #include <linux/of.h> 245195e509SWolfram Sang #include <linux/i2c.h> 255195e509SWolfram Sang #include <linux/i2c/at24.h> 265195e509SWolfram Sang 275195e509SWolfram Sang /* 285195e509SWolfram Sang * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable. 295195e509SWolfram Sang * Differences between different vendor product lines (like Atmel AT24C or 305195e509SWolfram Sang * MicroChip 24LC, etc) won't much matter for typical read/write access. 315195e509SWolfram Sang * There are also I2C RAM chips, likewise interchangeable. One example 325195e509SWolfram Sang * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes). 335195e509SWolfram Sang * 345195e509SWolfram Sang * However, misconfiguration can lose data. "Set 16-bit memory address" 355195e509SWolfram Sang * to a part with 8-bit addressing will overwrite data. Writing with too 365195e509SWolfram Sang * big a page size also loses data. And it's not safe to assume that the 375195e509SWolfram Sang * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC 385195e509SWolfram Sang * uses 0x51, for just one example. 395195e509SWolfram Sang * 405195e509SWolfram Sang * Accordingly, explicit board-specific configuration data should be used 415195e509SWolfram Sang * in almost all cases. (One partial exception is an SMBus used to access 425195e509SWolfram Sang * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.) 435195e509SWolfram Sang * 445195e509SWolfram Sang * So this driver uses "new style" I2C driver binding, expecting to be 455195e509SWolfram Sang * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or 465195e509SWolfram Sang * similar kernel-resident tables; or, configuration data coming from 475195e509SWolfram Sang * a bootloader. 485195e509SWolfram Sang * 495195e509SWolfram Sang * Other than binding model, current differences from "eeprom" driver are 505195e509SWolfram Sang * that this one handles write access and isn't restricted to 24c02 devices. 515195e509SWolfram Sang * It also handles larger devices (32 kbit and up) with two-byte addresses, 525195e509SWolfram Sang * which won't work on pure SMBus systems. 535195e509SWolfram Sang */ 545195e509SWolfram Sang 555195e509SWolfram Sang struct at24_data { 565195e509SWolfram Sang struct at24_platform_data chip; 577274ec8bSKevin Hilman struct memory_accessor macc; 587aeb9664SJean Delvare int use_smbus; 595195e509SWolfram Sang 605195e509SWolfram Sang /* 615195e509SWolfram Sang * Lock protects against activities from other Linux tasks, 625195e509SWolfram Sang * but not from changes by other I2C masters. 635195e509SWolfram Sang */ 645195e509SWolfram Sang struct mutex lock; 655195e509SWolfram Sang struct bin_attribute bin; 665195e509SWolfram Sang 675195e509SWolfram Sang u8 *writebuf; 685195e509SWolfram Sang unsigned write_max; 695195e509SWolfram Sang unsigned num_addresses; 705195e509SWolfram Sang 715195e509SWolfram Sang /* 725195e509SWolfram Sang * Some chips tie up multiple I2C addresses; dummy devices reserve 735195e509SWolfram Sang * them for us, and we'll use them with SMBus calls. 745195e509SWolfram Sang */ 755195e509SWolfram Sang struct i2c_client *client[]; 765195e509SWolfram Sang }; 775195e509SWolfram Sang 785195e509SWolfram Sang /* 795195e509SWolfram Sang * This parameter is to help this driver avoid blocking other drivers out 805195e509SWolfram Sang * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C 815195e509SWolfram Sang * clock, one 256 byte read takes about 1/43 second which is excessive; 825195e509SWolfram Sang * but the 1/170 second it takes at 400 kHz may be quite reasonable; and 835195e509SWolfram Sang * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible. 845195e509SWolfram Sang * 855195e509SWolfram Sang * This value is forced to be a power of two so that writes align on pages. 865195e509SWolfram Sang */ 875195e509SWolfram Sang static unsigned io_limit = 128; 885195e509SWolfram Sang module_param(io_limit, uint, 0); 895195e509SWolfram Sang MODULE_PARM_DESC(io_limit, "Maximum bytes per I/O (default 128)"); 905195e509SWolfram Sang 915195e509SWolfram Sang /* 925195e509SWolfram Sang * Specs often allow 5 msec for a page write, sometimes 20 msec; 935195e509SWolfram Sang * it's important to recover from write timeouts. 945195e509SWolfram Sang */ 955195e509SWolfram Sang static unsigned write_timeout = 25; 965195e509SWolfram Sang module_param(write_timeout, uint, 0); 975195e509SWolfram Sang MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)"); 985195e509SWolfram Sang 995195e509SWolfram Sang #define AT24_SIZE_BYTELEN 5 1005195e509SWolfram Sang #define AT24_SIZE_FLAGS 8 1015195e509SWolfram Sang 1025195e509SWolfram Sang #define AT24_BITMASK(x) (BIT(x) - 1) 1035195e509SWolfram Sang 1045195e509SWolfram Sang /* create non-zero magic value for given eeprom parameters */ 1055195e509SWolfram Sang #define AT24_DEVICE_MAGIC(_len, _flags) \ 1065195e509SWolfram Sang ((1 << AT24_SIZE_FLAGS | (_flags)) \ 1075195e509SWolfram Sang << AT24_SIZE_BYTELEN | ilog2(_len)) 1085195e509SWolfram Sang 1095195e509SWolfram Sang static const struct i2c_device_id at24_ids[] = { 1105195e509SWolfram Sang /* needs 8 addresses as A0-A2 are ignored */ 1115195e509SWolfram Sang { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) }, 1125195e509SWolfram Sang /* old variants can't be handled with this generic entry! */ 1135195e509SWolfram Sang { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) }, 1145195e509SWolfram Sang { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) }, 1155195e509SWolfram Sang /* spd is a 24c02 in memory DIMMs */ 1165195e509SWolfram Sang { "spd", AT24_DEVICE_MAGIC(2048 / 8, 1175195e509SWolfram Sang AT24_FLAG_READONLY | AT24_FLAG_IRUGO) }, 1185195e509SWolfram Sang { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) }, 1195195e509SWolfram Sang /* 24rf08 quirk is handled at i2c-core */ 1205195e509SWolfram Sang { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 1215195e509SWolfram Sang { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) }, 1225195e509SWolfram Sang { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) }, 1235195e509SWolfram Sang { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) }, 1245195e509SWolfram Sang { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) }, 1255195e509SWolfram Sang { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) }, 1265195e509SWolfram Sang { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) }, 1275195e509SWolfram Sang { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) }, 1285195e509SWolfram Sang { "at24", 0 }, 1295195e509SWolfram Sang { /* END OF LIST */ } 1305195e509SWolfram Sang }; 1315195e509SWolfram Sang MODULE_DEVICE_TABLE(i2c, at24_ids); 1325195e509SWolfram Sang 1335195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 1345195e509SWolfram Sang 1355195e509SWolfram Sang /* 1365195e509SWolfram Sang * This routine supports chips which consume multiple I2C addresses. It 1375195e509SWolfram Sang * computes the addressing information to be used for a given r/w request. 1385195e509SWolfram Sang * Assumes that sanity checks for offset happened at sysfs-layer. 1395195e509SWolfram Sang */ 1405195e509SWolfram Sang static struct i2c_client *at24_translate_offset(struct at24_data *at24, 1415195e509SWolfram Sang unsigned *offset) 1425195e509SWolfram Sang { 1435195e509SWolfram Sang unsigned i; 1445195e509SWolfram Sang 1455195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) { 1465195e509SWolfram Sang i = *offset >> 16; 1475195e509SWolfram Sang *offset &= 0xffff; 1485195e509SWolfram Sang } else { 1495195e509SWolfram Sang i = *offset >> 8; 1505195e509SWolfram Sang *offset &= 0xff; 1515195e509SWolfram Sang } 1525195e509SWolfram Sang 1535195e509SWolfram Sang return at24->client[i]; 1545195e509SWolfram Sang } 1555195e509SWolfram Sang 1565195e509SWolfram Sang static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf, 1575195e509SWolfram Sang unsigned offset, size_t count) 1585195e509SWolfram Sang { 1595195e509SWolfram Sang struct i2c_msg msg[2]; 1605195e509SWolfram Sang u8 msgbuf[2]; 1615195e509SWolfram Sang struct i2c_client *client; 1624d29196cSWolfram Sang unsigned long timeout, read_time; 1635195e509SWolfram Sang int status, i; 1645195e509SWolfram Sang 1655195e509SWolfram Sang memset(msg, 0, sizeof(msg)); 1665195e509SWolfram Sang 1675195e509SWolfram Sang /* 1685195e509SWolfram Sang * REVISIT some multi-address chips don't rollover page reads to 1695195e509SWolfram Sang * the next slave address, so we may need to truncate the count. 1705195e509SWolfram Sang * Those chips might need another quirk flag. 1715195e509SWolfram Sang * 1725195e509SWolfram Sang * If the real hardware used four adjacent 24c02 chips and that 1735195e509SWolfram Sang * were misconfigured as one 24c08, that would be a similar effect: 1745195e509SWolfram Sang * one "eeprom" file not four, but larger reads would fail when 1755195e509SWolfram Sang * they crossed certain pages. 1765195e509SWolfram Sang */ 1775195e509SWolfram Sang 1785195e509SWolfram Sang /* 1795195e509SWolfram Sang * Slave address and byte offset derive from the offset. Always 1805195e509SWolfram Sang * set the byte address; on a multi-master board, another master 1815195e509SWolfram Sang * may have changed the chip's "current" address pointer. 1825195e509SWolfram Sang */ 1835195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 1845195e509SWolfram Sang 1855195e509SWolfram Sang if (count > io_limit) 1865195e509SWolfram Sang count = io_limit; 1875195e509SWolfram Sang 1887aeb9664SJean Delvare switch (at24->use_smbus) { 1897aeb9664SJean Delvare case I2C_SMBUS_I2C_BLOCK_DATA: 1904d29196cSWolfram Sang /* Smaller eeproms can work given some SMBus extension calls */ 1915195e509SWolfram Sang if (count > I2C_SMBUS_BLOCK_MAX) 1925195e509SWolfram Sang count = I2C_SMBUS_BLOCK_MAX; 1937aeb9664SJean Delvare break; 1947aeb9664SJean Delvare case I2C_SMBUS_WORD_DATA: 1957aeb9664SJean Delvare count = 2; 1967aeb9664SJean Delvare break; 1977aeb9664SJean Delvare case I2C_SMBUS_BYTE_DATA: 1987aeb9664SJean Delvare count = 1; 1997aeb9664SJean Delvare break; 2007aeb9664SJean Delvare default: 2015195e509SWolfram Sang /* 2024d29196cSWolfram Sang * When we have a better choice than SMBus calls, use a 2034d29196cSWolfram Sang * combined I2C message. Write address; then read up to 2044d29196cSWolfram Sang * io_limit data bytes. Note that read page rollover helps us 2054d29196cSWolfram Sang * here (unlike writes). msgbuf is u8 and will cast to our 2064d29196cSWolfram Sang * needs. 2075195e509SWolfram Sang */ 2085195e509SWolfram Sang i = 0; 2095195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 2105195e509SWolfram Sang msgbuf[i++] = offset >> 8; 2115195e509SWolfram Sang msgbuf[i++] = offset; 2125195e509SWolfram Sang 2135195e509SWolfram Sang msg[0].addr = client->addr; 2145195e509SWolfram Sang msg[0].buf = msgbuf; 2155195e509SWolfram Sang msg[0].len = i; 2165195e509SWolfram Sang 2175195e509SWolfram Sang msg[1].addr = client->addr; 2185195e509SWolfram Sang msg[1].flags = I2C_M_RD; 2195195e509SWolfram Sang msg[1].buf = buf; 2205195e509SWolfram Sang msg[1].len = count; 2214d29196cSWolfram Sang } 2225195e509SWolfram Sang 2234d29196cSWolfram Sang /* 2244d29196cSWolfram Sang * Reads fail if the previous write didn't complete yet. We may 2254d29196cSWolfram Sang * loop a few times until this one succeeds, waiting at least 2264d29196cSWolfram Sang * long enough for one entire page write to work. 2274d29196cSWolfram Sang */ 2284d29196cSWolfram Sang timeout = jiffies + msecs_to_jiffies(write_timeout); 2294d29196cSWolfram Sang do { 2304d29196cSWolfram Sang read_time = jiffies; 2317aeb9664SJean Delvare switch (at24->use_smbus) { 2327aeb9664SJean Delvare case I2C_SMBUS_I2C_BLOCK_DATA: 2334d29196cSWolfram Sang status = i2c_smbus_read_i2c_block_data(client, offset, 2344d29196cSWolfram Sang count, buf); 2357aeb9664SJean Delvare break; 2367aeb9664SJean Delvare case I2C_SMBUS_WORD_DATA: 2377aeb9664SJean Delvare status = i2c_smbus_read_word_data(client, offset); 2387aeb9664SJean Delvare if (status >= 0) { 2397aeb9664SJean Delvare buf[0] = status & 0xff; 2407aeb9664SJean Delvare buf[1] = status >> 8; 2417aeb9664SJean Delvare status = count; 2427aeb9664SJean Delvare } 2437aeb9664SJean Delvare break; 2447aeb9664SJean Delvare case I2C_SMBUS_BYTE_DATA: 2457aeb9664SJean Delvare status = i2c_smbus_read_byte_data(client, offset); 2467aeb9664SJean Delvare if (status >= 0) { 2477aeb9664SJean Delvare buf[0] = status; 2487aeb9664SJean Delvare status = count; 2497aeb9664SJean Delvare } 2507aeb9664SJean Delvare break; 2517aeb9664SJean Delvare default: 2525195e509SWolfram Sang status = i2c_transfer(client->adapter, msg, 2); 2535195e509SWolfram Sang if (status == 2) 2544d29196cSWolfram Sang status = count; 2554d29196cSWolfram Sang } 2564d29196cSWolfram Sang dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 2574d29196cSWolfram Sang count, offset, status, jiffies); 2584d29196cSWolfram Sang 2594d29196cSWolfram Sang if (status == count) 2605195e509SWolfram Sang return count; 2614d29196cSWolfram Sang 2624d29196cSWolfram Sang /* REVISIT: at HZ=100, this is sloooow */ 2634d29196cSWolfram Sang msleep(1); 2644d29196cSWolfram Sang } while (time_before(read_time, timeout)); 2654d29196cSWolfram Sang 2664d29196cSWolfram Sang return -ETIMEDOUT; 2675195e509SWolfram Sang } 2685195e509SWolfram Sang 2697274ec8bSKevin Hilman static ssize_t at24_read(struct at24_data *at24, 2705195e509SWolfram Sang char *buf, loff_t off, size_t count) 2715195e509SWolfram Sang { 2725195e509SWolfram Sang ssize_t retval = 0; 2735195e509SWolfram Sang 2745195e509SWolfram Sang if (unlikely(!count)) 2755195e509SWolfram Sang return count; 2765195e509SWolfram Sang 2775195e509SWolfram Sang /* 2785195e509SWolfram Sang * Read data from chip, protecting against concurrent updates 2795195e509SWolfram Sang * from this host, but not from other I2C masters. 2805195e509SWolfram Sang */ 2815195e509SWolfram Sang mutex_lock(&at24->lock); 2825195e509SWolfram Sang 2835195e509SWolfram Sang while (count) { 2845195e509SWolfram Sang ssize_t status; 2855195e509SWolfram Sang 2865195e509SWolfram Sang status = at24_eeprom_read(at24, buf, off, count); 2875195e509SWolfram Sang if (status <= 0) { 2885195e509SWolfram Sang if (retval == 0) 2895195e509SWolfram Sang retval = status; 2905195e509SWolfram Sang break; 2915195e509SWolfram Sang } 2925195e509SWolfram Sang buf += status; 2935195e509SWolfram Sang off += status; 2945195e509SWolfram Sang count -= status; 2955195e509SWolfram Sang retval += status; 2965195e509SWolfram Sang } 2975195e509SWolfram Sang 2985195e509SWolfram Sang mutex_unlock(&at24->lock); 2995195e509SWolfram Sang 3005195e509SWolfram Sang return retval; 3015195e509SWolfram Sang } 3025195e509SWolfram Sang 3032c3c8beaSChris Wright static ssize_t at24_bin_read(struct file *filp, struct kobject *kobj, 3042c3c8beaSChris Wright struct bin_attribute *attr, 3057274ec8bSKevin Hilman char *buf, loff_t off, size_t count) 3067274ec8bSKevin Hilman { 3077274ec8bSKevin Hilman struct at24_data *at24; 3085195e509SWolfram Sang 3097274ec8bSKevin Hilman at24 = dev_get_drvdata(container_of(kobj, struct device, kobj)); 3107274ec8bSKevin Hilman return at24_read(at24, buf, off, count); 3117274ec8bSKevin Hilman } 3125195e509SWolfram Sang 3135195e509SWolfram Sang 3145195e509SWolfram Sang /* 3155195e509SWolfram Sang * Note that if the hardware write-protect pin is pulled high, the whole 3165195e509SWolfram Sang * chip is normally write protected. But there are plenty of product 3175195e509SWolfram Sang * variants here, including OTP fuses and partial chip protect. 3185195e509SWolfram Sang * 3195195e509SWolfram Sang * We only use page mode writes; the alternative is sloooow. This routine 3205195e509SWolfram Sang * writes at most one page. 3215195e509SWolfram Sang */ 322280ca299SGeert Uytterhoeven static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf, 3235195e509SWolfram Sang unsigned offset, size_t count) 3245195e509SWolfram Sang { 3255195e509SWolfram Sang struct i2c_client *client; 3265195e509SWolfram Sang struct i2c_msg msg; 3275195e509SWolfram Sang ssize_t status; 3285195e509SWolfram Sang unsigned long timeout, write_time; 3295195e509SWolfram Sang unsigned next_page; 3305195e509SWolfram Sang 3315195e509SWolfram Sang /* Get corresponding I2C address and adjust offset */ 3325195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 3335195e509SWolfram Sang 3345195e509SWolfram Sang /* write_max is at most a page */ 3355195e509SWolfram Sang if (count > at24->write_max) 3365195e509SWolfram Sang count = at24->write_max; 3375195e509SWolfram Sang 3385195e509SWolfram Sang /* Never roll over backwards, to the start of this page */ 3395195e509SWolfram Sang next_page = roundup(offset + 1, at24->chip.page_size); 3405195e509SWolfram Sang if (offset + count > next_page) 3415195e509SWolfram Sang count = next_page - offset; 3425195e509SWolfram Sang 3435195e509SWolfram Sang /* If we'll use I2C calls for I/O, set up the message */ 3445195e509SWolfram Sang if (!at24->use_smbus) { 3455195e509SWolfram Sang int i = 0; 3465195e509SWolfram Sang 3475195e509SWolfram Sang msg.addr = client->addr; 3485195e509SWolfram Sang msg.flags = 0; 3495195e509SWolfram Sang 3505195e509SWolfram Sang /* msg.buf is u8 and casts will mask the values */ 3515195e509SWolfram Sang msg.buf = at24->writebuf; 3525195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 3535195e509SWolfram Sang msg.buf[i++] = offset >> 8; 3545195e509SWolfram Sang 3555195e509SWolfram Sang msg.buf[i++] = offset; 3565195e509SWolfram Sang memcpy(&msg.buf[i], buf, count); 3575195e509SWolfram Sang msg.len = i + count; 3585195e509SWolfram Sang } 3595195e509SWolfram Sang 3605195e509SWolfram Sang /* 3615195e509SWolfram Sang * Writes fail if the previous one didn't complete yet. We may 3625195e509SWolfram Sang * loop a few times until this one succeeds, waiting at least 3635195e509SWolfram Sang * long enough for one entire page write to work. 3645195e509SWolfram Sang */ 3655195e509SWolfram Sang timeout = jiffies + msecs_to_jiffies(write_timeout); 3665195e509SWolfram Sang do { 3675195e509SWolfram Sang write_time = jiffies; 3685195e509SWolfram Sang if (at24->use_smbus) { 3695195e509SWolfram Sang status = i2c_smbus_write_i2c_block_data(client, 3705195e509SWolfram Sang offset, count, buf); 3715195e509SWolfram Sang if (status == 0) 3725195e509SWolfram Sang status = count; 3735195e509SWolfram Sang } else { 3745195e509SWolfram Sang status = i2c_transfer(client->adapter, &msg, 1); 3755195e509SWolfram Sang if (status == 1) 3765195e509SWolfram Sang status = count; 3775195e509SWolfram Sang } 3785195e509SWolfram Sang dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n", 3795195e509SWolfram Sang count, offset, status, jiffies); 3805195e509SWolfram Sang 3815195e509SWolfram Sang if (status == count) 3825195e509SWolfram Sang return count; 3835195e509SWolfram Sang 3845195e509SWolfram Sang /* REVISIT: at HZ=100, this is sloooow */ 3855195e509SWolfram Sang msleep(1); 3865195e509SWolfram Sang } while (time_before(write_time, timeout)); 3875195e509SWolfram Sang 3885195e509SWolfram Sang return -ETIMEDOUT; 3895195e509SWolfram Sang } 3905195e509SWolfram Sang 391280ca299SGeert Uytterhoeven static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off, 392280ca299SGeert Uytterhoeven size_t count) 3935195e509SWolfram Sang { 3945195e509SWolfram Sang ssize_t retval = 0; 3955195e509SWolfram Sang 3965195e509SWolfram Sang if (unlikely(!count)) 3975195e509SWolfram Sang return count; 3985195e509SWolfram Sang 3995195e509SWolfram Sang /* 4005195e509SWolfram Sang * Write data to chip, protecting against concurrent updates 4015195e509SWolfram Sang * from this host, but not from other I2C masters. 4025195e509SWolfram Sang */ 4035195e509SWolfram Sang mutex_lock(&at24->lock); 4045195e509SWolfram Sang 4055195e509SWolfram Sang while (count) { 4065195e509SWolfram Sang ssize_t status; 4075195e509SWolfram Sang 4085195e509SWolfram Sang status = at24_eeprom_write(at24, buf, off, count); 4095195e509SWolfram Sang if (status <= 0) { 4105195e509SWolfram Sang if (retval == 0) 4115195e509SWolfram Sang retval = status; 4125195e509SWolfram Sang break; 4135195e509SWolfram Sang } 4145195e509SWolfram Sang buf += status; 4155195e509SWolfram Sang off += status; 4165195e509SWolfram Sang count -= status; 4175195e509SWolfram Sang retval += status; 4185195e509SWolfram Sang } 4195195e509SWolfram Sang 4205195e509SWolfram Sang mutex_unlock(&at24->lock); 4215195e509SWolfram Sang 4225195e509SWolfram Sang return retval; 4235195e509SWolfram Sang } 4245195e509SWolfram Sang 4252c3c8beaSChris Wright static ssize_t at24_bin_write(struct file *filp, struct kobject *kobj, 4262c3c8beaSChris Wright struct bin_attribute *attr, 4277274ec8bSKevin Hilman char *buf, loff_t off, size_t count) 4287274ec8bSKevin Hilman { 4297274ec8bSKevin Hilman struct at24_data *at24; 4307274ec8bSKevin Hilman 4317274ec8bSKevin Hilman at24 = dev_get_drvdata(container_of(kobj, struct device, kobj)); 4327274ec8bSKevin Hilman return at24_write(at24, buf, off, count); 4337274ec8bSKevin Hilman } 4347274ec8bSKevin Hilman 4357274ec8bSKevin Hilman /*-------------------------------------------------------------------------*/ 4367274ec8bSKevin Hilman 4377274ec8bSKevin Hilman /* 4387274ec8bSKevin Hilman * This lets other kernel code access the eeprom data. For example, it 4397274ec8bSKevin Hilman * might hold a board's Ethernet address, or board-specific calibration 4407274ec8bSKevin Hilman * data generated on the manufacturing floor. 4417274ec8bSKevin Hilman */ 4427274ec8bSKevin Hilman 4437274ec8bSKevin Hilman static ssize_t at24_macc_read(struct memory_accessor *macc, char *buf, 4447274ec8bSKevin Hilman off_t offset, size_t count) 4457274ec8bSKevin Hilman { 4467274ec8bSKevin Hilman struct at24_data *at24 = container_of(macc, struct at24_data, macc); 4477274ec8bSKevin Hilman 4487274ec8bSKevin Hilman return at24_read(at24, buf, offset, count); 4497274ec8bSKevin Hilman } 4507274ec8bSKevin Hilman 451280ca299SGeert Uytterhoeven static ssize_t at24_macc_write(struct memory_accessor *macc, const char *buf, 4527274ec8bSKevin Hilman off_t offset, size_t count) 4537274ec8bSKevin Hilman { 4547274ec8bSKevin Hilman struct at24_data *at24 = container_of(macc, struct at24_data, macc); 4557274ec8bSKevin Hilman 4567274ec8bSKevin Hilman return at24_write(at24, buf, offset, count); 4577274ec8bSKevin Hilman } 4587274ec8bSKevin Hilman 4595195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 4605195e509SWolfram Sang 4619ed030d7SWolfram Sang #ifdef CONFIG_OF 4629ed030d7SWolfram Sang static void at24_get_ofdata(struct i2c_client *client, 4639ed030d7SWolfram Sang struct at24_platform_data *chip) 4649ed030d7SWolfram Sang { 4659ed030d7SWolfram Sang const __be32 *val; 4669ed030d7SWolfram Sang struct device_node *node = client->dev.of_node; 4679ed030d7SWolfram Sang 4689ed030d7SWolfram Sang if (node) { 4699ed030d7SWolfram Sang if (of_get_property(node, "read-only", NULL)) 4709ed030d7SWolfram Sang chip->flags |= AT24_FLAG_READONLY; 4719ed030d7SWolfram Sang val = of_get_property(node, "pagesize", NULL); 4729ed030d7SWolfram Sang if (val) 4739ed030d7SWolfram Sang chip->page_size = be32_to_cpup(val); 4749ed030d7SWolfram Sang } 4759ed030d7SWolfram Sang } 4769ed030d7SWolfram Sang #else 4779ed030d7SWolfram Sang static void at24_get_ofdata(struct i2c_client *client, 4789ed030d7SWolfram Sang struct at24_platform_data *chip) 4799ed030d7SWolfram Sang { } 4809ed030d7SWolfram Sang #endif /* CONFIG_OF */ 4819ed030d7SWolfram Sang 4825195e509SWolfram Sang static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) 4835195e509SWolfram Sang { 4845195e509SWolfram Sang struct at24_platform_data chip; 4855195e509SWolfram Sang bool writable; 4867aeb9664SJean Delvare int use_smbus = 0; 4875195e509SWolfram Sang struct at24_data *at24; 4885195e509SWolfram Sang int err; 4895195e509SWolfram Sang unsigned i, num_addresses; 4905195e509SWolfram Sang kernel_ulong_t magic; 4915195e509SWolfram Sang 4925195e509SWolfram Sang if (client->dev.platform_data) { 4935195e509SWolfram Sang chip = *(struct at24_platform_data *)client->dev.platform_data; 4945195e509SWolfram Sang } else { 4955195e509SWolfram Sang if (!id->driver_data) { 4965195e509SWolfram Sang err = -ENODEV; 4975195e509SWolfram Sang goto err_out; 4985195e509SWolfram Sang } 4995195e509SWolfram Sang magic = id->driver_data; 5005195e509SWolfram Sang chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN)); 5015195e509SWolfram Sang magic >>= AT24_SIZE_BYTELEN; 5025195e509SWolfram Sang chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS); 5035195e509SWolfram Sang /* 5045195e509SWolfram Sang * This is slow, but we can't know all eeproms, so we better 5055195e509SWolfram Sang * play safe. Specifying custom eeprom-types via platform_data 5065195e509SWolfram Sang * is recommended anyhow. 5075195e509SWolfram Sang */ 5085195e509SWolfram Sang chip.page_size = 1; 5097274ec8bSKevin Hilman 5109ed030d7SWolfram Sang /* update chipdata if OF is present */ 5119ed030d7SWolfram Sang at24_get_ofdata(client, &chip); 5129ed030d7SWolfram Sang 5137274ec8bSKevin Hilman chip.setup = NULL; 5147274ec8bSKevin Hilman chip.context = NULL; 5155195e509SWolfram Sang } 5165195e509SWolfram Sang 5175195e509SWolfram Sang if (!is_power_of_2(chip.byte_len)) 5185195e509SWolfram Sang dev_warn(&client->dev, 5195195e509SWolfram Sang "byte_len looks suspicious (no power of 2)!\n"); 52045efe847SWolfram Sang if (!chip.page_size) { 52145efe847SWolfram Sang dev_err(&client->dev, "page_size must not be 0!\n"); 52245efe847SWolfram Sang err = -EINVAL; 52345efe847SWolfram Sang goto err_out; 52445efe847SWolfram Sang } 5255195e509SWolfram Sang if (!is_power_of_2(chip.page_size)) 5265195e509SWolfram Sang dev_warn(&client->dev, 5275195e509SWolfram Sang "page_size looks suspicious (no power of 2)!\n"); 5285195e509SWolfram Sang 5295195e509SWolfram Sang /* Use I2C operations unless we're stuck with SMBus extensions. */ 5305195e509SWolfram Sang if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 5315195e509SWolfram Sang if (chip.flags & AT24_FLAG_ADDR16) { 5325195e509SWolfram Sang err = -EPFNOSUPPORT; 5335195e509SWolfram Sang goto err_out; 5345195e509SWolfram Sang } 5357aeb9664SJean Delvare if (i2c_check_functionality(client->adapter, 5365195e509SWolfram Sang I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 5377aeb9664SJean Delvare use_smbus = I2C_SMBUS_I2C_BLOCK_DATA; 5387aeb9664SJean Delvare } else if (i2c_check_functionality(client->adapter, 5397aeb9664SJean Delvare I2C_FUNC_SMBUS_READ_WORD_DATA)) { 5407aeb9664SJean Delvare use_smbus = I2C_SMBUS_WORD_DATA; 5417aeb9664SJean Delvare } else if (i2c_check_functionality(client->adapter, 5427aeb9664SJean Delvare I2C_FUNC_SMBUS_READ_BYTE_DATA)) { 5437aeb9664SJean Delvare use_smbus = I2C_SMBUS_BYTE_DATA; 5447aeb9664SJean Delvare } else { 5455195e509SWolfram Sang err = -EPFNOSUPPORT; 5465195e509SWolfram Sang goto err_out; 5475195e509SWolfram Sang } 5485195e509SWolfram Sang } 5495195e509SWolfram Sang 5505195e509SWolfram Sang if (chip.flags & AT24_FLAG_TAKE8ADDR) 5515195e509SWolfram Sang num_addresses = 8; 5525195e509SWolfram Sang else 5535195e509SWolfram Sang num_addresses = DIV_ROUND_UP(chip.byte_len, 5545195e509SWolfram Sang (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256); 5555195e509SWolfram Sang 5565195e509SWolfram Sang at24 = kzalloc(sizeof(struct at24_data) + 5575195e509SWolfram Sang num_addresses * sizeof(struct i2c_client *), GFP_KERNEL); 5585195e509SWolfram Sang if (!at24) { 5595195e509SWolfram Sang err = -ENOMEM; 5605195e509SWolfram Sang goto err_out; 5615195e509SWolfram Sang } 5625195e509SWolfram Sang 5635195e509SWolfram Sang mutex_init(&at24->lock); 5645195e509SWolfram Sang at24->use_smbus = use_smbus; 5655195e509SWolfram Sang at24->chip = chip; 5665195e509SWolfram Sang at24->num_addresses = num_addresses; 5675195e509SWolfram Sang 5685195e509SWolfram Sang /* 5695195e509SWolfram Sang * Export the EEPROM bytes through sysfs, since that's convenient. 5705195e509SWolfram Sang * By default, only root should see the data (maybe passwords etc) 5715195e509SWolfram Sang */ 572d07b56b3SWolfram Sang sysfs_bin_attr_init(&at24->bin); 5735195e509SWolfram Sang at24->bin.attr.name = "eeprom"; 5745195e509SWolfram Sang at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR; 5755195e509SWolfram Sang at24->bin.read = at24_bin_read; 5765195e509SWolfram Sang at24->bin.size = chip.byte_len; 5775195e509SWolfram Sang 5787274ec8bSKevin Hilman at24->macc.read = at24_macc_read; 5797274ec8bSKevin Hilman 5805195e509SWolfram Sang writable = !(chip.flags & AT24_FLAG_READONLY); 5815195e509SWolfram Sang if (writable) { 5825195e509SWolfram Sang if (!use_smbus || i2c_check_functionality(client->adapter, 5835195e509SWolfram Sang I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { 5845195e509SWolfram Sang 5855195e509SWolfram Sang unsigned write_max = chip.page_size; 5865195e509SWolfram Sang 5877274ec8bSKevin Hilman at24->macc.write = at24_macc_write; 5887274ec8bSKevin Hilman 5895195e509SWolfram Sang at24->bin.write = at24_bin_write; 5905195e509SWolfram Sang at24->bin.attr.mode |= S_IWUSR; 5915195e509SWolfram Sang 5925195e509SWolfram Sang if (write_max > io_limit) 5935195e509SWolfram Sang write_max = io_limit; 5945195e509SWolfram Sang if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX) 5955195e509SWolfram Sang write_max = I2C_SMBUS_BLOCK_MAX; 5965195e509SWolfram Sang at24->write_max = write_max; 5975195e509SWolfram Sang 5985195e509SWolfram Sang /* buffer (data + address at the beginning) */ 5995195e509SWolfram Sang at24->writebuf = kmalloc(write_max + 2, GFP_KERNEL); 6005195e509SWolfram Sang if (!at24->writebuf) { 6015195e509SWolfram Sang err = -ENOMEM; 6025195e509SWolfram Sang goto err_struct; 6035195e509SWolfram Sang } 6045195e509SWolfram Sang } else { 6055195e509SWolfram Sang dev_warn(&client->dev, 6065195e509SWolfram Sang "cannot write due to controller restrictions."); 6075195e509SWolfram Sang } 6085195e509SWolfram Sang } 6095195e509SWolfram Sang 6105195e509SWolfram Sang at24->client[0] = client; 6115195e509SWolfram Sang 6125195e509SWolfram Sang /* use dummy devices for multiple-address chips */ 6135195e509SWolfram Sang for (i = 1; i < num_addresses; i++) { 6145195e509SWolfram Sang at24->client[i] = i2c_new_dummy(client->adapter, 6155195e509SWolfram Sang client->addr + i); 6165195e509SWolfram Sang if (!at24->client[i]) { 6175195e509SWolfram Sang dev_err(&client->dev, "address 0x%02x unavailable\n", 6185195e509SWolfram Sang client->addr + i); 6195195e509SWolfram Sang err = -EADDRINUSE; 6205195e509SWolfram Sang goto err_clients; 6215195e509SWolfram Sang } 6225195e509SWolfram Sang } 6235195e509SWolfram Sang 6245195e509SWolfram Sang err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin); 6255195e509SWolfram Sang if (err) 6265195e509SWolfram Sang goto err_clients; 6275195e509SWolfram Sang 6285195e509SWolfram Sang i2c_set_clientdata(client, at24); 6295195e509SWolfram Sang 6309ed030d7SWolfram Sang dev_info(&client->dev, "%zu byte %s EEPROM, %s, %u bytes/write\n", 6315195e509SWolfram Sang at24->bin.size, client->name, 6329ed030d7SWolfram Sang writable ? "writable" : "read-only", at24->write_max); 6337aeb9664SJean Delvare if (use_smbus == I2C_SMBUS_WORD_DATA || 6347aeb9664SJean Delvare use_smbus == I2C_SMBUS_BYTE_DATA) { 6357aeb9664SJean Delvare dev_notice(&client->dev, "Falling back to %s reads, " 6367aeb9664SJean Delvare "performance will suffer\n", use_smbus == 6377aeb9664SJean Delvare I2C_SMBUS_WORD_DATA ? "word" : "byte"); 6387aeb9664SJean Delvare } 6395195e509SWolfram Sang 6407274ec8bSKevin Hilman /* export data to kernel code */ 6417274ec8bSKevin Hilman if (chip.setup) 6427274ec8bSKevin Hilman chip.setup(&at24->macc, chip.context); 6437274ec8bSKevin Hilman 6445195e509SWolfram Sang return 0; 6455195e509SWolfram Sang 6465195e509SWolfram Sang err_clients: 6475195e509SWolfram Sang for (i = 1; i < num_addresses; i++) 6485195e509SWolfram Sang if (at24->client[i]) 6495195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 6505195e509SWolfram Sang 6515195e509SWolfram Sang kfree(at24->writebuf); 6525195e509SWolfram Sang err_struct: 6535195e509SWolfram Sang kfree(at24); 6545195e509SWolfram Sang err_out: 6555195e509SWolfram Sang dev_dbg(&client->dev, "probe error %d\n", err); 6565195e509SWolfram Sang return err; 6575195e509SWolfram Sang } 6585195e509SWolfram Sang 659486a5c28SBill Pemberton static int at24_remove(struct i2c_client *client) 6605195e509SWolfram Sang { 6615195e509SWolfram Sang struct at24_data *at24; 6625195e509SWolfram Sang int i; 6635195e509SWolfram Sang 6645195e509SWolfram Sang at24 = i2c_get_clientdata(client); 6655195e509SWolfram Sang sysfs_remove_bin_file(&client->dev.kobj, &at24->bin); 6665195e509SWolfram Sang 6675195e509SWolfram Sang for (i = 1; i < at24->num_addresses; i++) 6685195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 6695195e509SWolfram Sang 6705195e509SWolfram Sang kfree(at24->writebuf); 6715195e509SWolfram Sang kfree(at24); 6725195e509SWolfram Sang return 0; 6735195e509SWolfram Sang } 6745195e509SWolfram Sang 6755195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 6765195e509SWolfram Sang 6775195e509SWolfram Sang static struct i2c_driver at24_driver = { 6785195e509SWolfram Sang .driver = { 6795195e509SWolfram Sang .name = "at24", 6805195e509SWolfram Sang .owner = THIS_MODULE, 6815195e509SWolfram Sang }, 6825195e509SWolfram Sang .probe = at24_probe, 6832d6bed9cSBill Pemberton .remove = at24_remove, 6845195e509SWolfram Sang .id_table = at24_ids, 6855195e509SWolfram Sang }; 6865195e509SWolfram Sang 6875195e509SWolfram Sang static int __init at24_init(void) 6885195e509SWolfram Sang { 68945efe847SWolfram Sang if (!io_limit) { 69045efe847SWolfram Sang pr_err("at24: io_limit must not be 0!\n"); 69145efe847SWolfram Sang return -EINVAL; 69245efe847SWolfram Sang } 69345efe847SWolfram Sang 6945195e509SWolfram Sang io_limit = rounddown_pow_of_two(io_limit); 6955195e509SWolfram Sang return i2c_add_driver(&at24_driver); 6965195e509SWolfram Sang } 6975195e509SWolfram Sang module_init(at24_init); 6985195e509SWolfram Sang 6995195e509SWolfram Sang static void __exit at24_exit(void) 7005195e509SWolfram Sang { 7015195e509SWolfram Sang i2c_del_driver(&at24_driver); 7025195e509SWolfram Sang } 7035195e509SWolfram Sang module_exit(at24_exit); 7045195e509SWolfram Sang 7055195e509SWolfram Sang MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); 7065195e509SWolfram Sang MODULE_AUTHOR("David Brownell and Wolfram Sang"); 7075195e509SWolfram Sang MODULE_LICENSE("GPL"); 708