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/mod_devicetable.h> 195195e509SWolfram Sang #include <linux/log2.h> 205195e509SWolfram Sang #include <linux/bitops.h> 215195e509SWolfram Sang #include <linux/jiffies.h> 229ed030d7SWolfram Sang #include <linux/of.h> 2340d8edc9SAndy Shevchenko #include <linux/acpi.h> 245195e509SWolfram Sang #include <linux/i2c.h> 2557d15550SAndrew Lunn #include <linux/nvmem-provider.h> 2625f73ed5SVivien Didelot #include <linux/platform_data/at24.h> 275195e509SWolfram Sang 285195e509SWolfram Sang /* 295195e509SWolfram Sang * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable. 305195e509SWolfram Sang * Differences between different vendor product lines (like Atmel AT24C or 315195e509SWolfram Sang * MicroChip 24LC, etc) won't much matter for typical read/write access. 325195e509SWolfram Sang * There are also I2C RAM chips, likewise interchangeable. One example 335195e509SWolfram Sang * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes). 345195e509SWolfram Sang * 355195e509SWolfram Sang * However, misconfiguration can lose data. "Set 16-bit memory address" 365195e509SWolfram Sang * to a part with 8-bit addressing will overwrite data. Writing with too 375195e509SWolfram Sang * big a page size also loses data. And it's not safe to assume that the 385195e509SWolfram Sang * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC 395195e509SWolfram Sang * uses 0x51, for just one example. 405195e509SWolfram Sang * 415195e509SWolfram Sang * Accordingly, explicit board-specific configuration data should be used 425195e509SWolfram Sang * in almost all cases. (One partial exception is an SMBus used to access 435195e509SWolfram Sang * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.) 445195e509SWolfram Sang * 455195e509SWolfram Sang * So this driver uses "new style" I2C driver binding, expecting to be 465195e509SWolfram Sang * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or 475195e509SWolfram Sang * similar kernel-resident tables; or, configuration data coming from 485195e509SWolfram Sang * a bootloader. 495195e509SWolfram Sang * 505195e509SWolfram Sang * Other than binding model, current differences from "eeprom" driver are 515195e509SWolfram Sang * that this one handles write access and isn't restricted to 24c02 devices. 525195e509SWolfram Sang * It also handles larger devices (32 kbit and up) with two-byte addresses, 535195e509SWolfram Sang * which won't work on pure SMBus systems. 545195e509SWolfram Sang */ 555195e509SWolfram Sang 565195e509SWolfram Sang struct at24_data { 575195e509SWolfram Sang struct at24_platform_data chip; 587aeb9664SJean Delvare int use_smbus; 59a839ce66SChristian Gmeiner int use_smbus_write; 605195e509SWolfram Sang 61318aa9c6SBartosz Golaszewski ssize_t (*read_func)(struct at24_data *, char *, unsigned int, size_t); 62318aa9c6SBartosz Golaszewski ssize_t (*write_func)(struct at24_data *, 63318aa9c6SBartosz Golaszewski const char *, unsigned int, size_t); 64318aa9c6SBartosz Golaszewski 655195e509SWolfram Sang /* 665195e509SWolfram Sang * Lock protects against activities from other Linux tasks, 675195e509SWolfram Sang * but not from changes by other I2C masters. 685195e509SWolfram Sang */ 695195e509SWolfram Sang struct mutex lock; 705195e509SWolfram Sang 715195e509SWolfram Sang u8 *writebuf; 725195e509SWolfram Sang unsigned write_max; 735195e509SWolfram Sang unsigned num_addresses; 745195e509SWolfram Sang 7557d15550SAndrew Lunn struct nvmem_config nvmem_config; 7657d15550SAndrew Lunn struct nvmem_device *nvmem; 7757d15550SAndrew Lunn 785195e509SWolfram Sang /* 795195e509SWolfram Sang * Some chips tie up multiple I2C addresses; dummy devices reserve 805195e509SWolfram Sang * them for us, and we'll use them with SMBus calls. 815195e509SWolfram Sang */ 825195e509SWolfram Sang struct i2c_client *client[]; 835195e509SWolfram Sang }; 845195e509SWolfram Sang 855195e509SWolfram Sang /* 865195e509SWolfram Sang * This parameter is to help this driver avoid blocking other drivers out 875195e509SWolfram Sang * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C 885195e509SWolfram Sang * clock, one 256 byte read takes about 1/43 second which is excessive; 895195e509SWolfram Sang * but the 1/170 second it takes at 400 kHz may be quite reasonable; and 905195e509SWolfram Sang * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible. 915195e509SWolfram Sang * 925195e509SWolfram Sang * This value is forced to be a power of two so that writes align on pages. 935195e509SWolfram Sang */ 945195e509SWolfram Sang static unsigned io_limit = 128; 955195e509SWolfram Sang module_param(io_limit, uint, 0); 965195e509SWolfram Sang MODULE_PARM_DESC(io_limit, "Maximum bytes per I/O (default 128)"); 975195e509SWolfram Sang 985195e509SWolfram Sang /* 995195e509SWolfram Sang * Specs often allow 5 msec for a page write, sometimes 20 msec; 1005195e509SWolfram Sang * it's important to recover from write timeouts. 1015195e509SWolfram Sang */ 1025195e509SWolfram Sang static unsigned write_timeout = 25; 1035195e509SWolfram Sang module_param(write_timeout, uint, 0); 1045195e509SWolfram Sang MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)"); 1055195e509SWolfram Sang 1065195e509SWolfram Sang #define AT24_SIZE_BYTELEN 5 1075195e509SWolfram Sang #define AT24_SIZE_FLAGS 8 1085195e509SWolfram Sang 1095195e509SWolfram Sang #define AT24_BITMASK(x) (BIT(x) - 1) 1105195e509SWolfram Sang 1115195e509SWolfram Sang /* create non-zero magic value for given eeprom parameters */ 1125195e509SWolfram Sang #define AT24_DEVICE_MAGIC(_len, _flags) \ 1135195e509SWolfram Sang ((1 << AT24_SIZE_FLAGS | (_flags)) \ 1145195e509SWolfram Sang << AT24_SIZE_BYTELEN | ilog2(_len)) 1155195e509SWolfram Sang 1169344a81eSBartosz Golaszewski /* 1179344a81eSBartosz Golaszewski * Both reads and writes fail if the previous write didn't complete yet. This 1189344a81eSBartosz Golaszewski * macro loops a few times waiting at least long enough for one entire page 1199344a81eSBartosz Golaszewski * write to work. 1209344a81eSBartosz Golaszewski * 1219344a81eSBartosz Golaszewski * It takes two parameters: a variable in which the future timeout in jiffies 1229344a81eSBartosz Golaszewski * will be stored and a temporary variable holding the time of the last 1239344a81eSBartosz Golaszewski * iteration of processing the request. Both should be unsigned integers 1249344a81eSBartosz Golaszewski * holding at least 32 bits. 1259344a81eSBartosz Golaszewski */ 1269344a81eSBartosz Golaszewski #define loop_until_timeout(tout, op_time) \ 1279344a81eSBartosz Golaszewski for (tout = jiffies + msecs_to_jiffies(write_timeout), \ 1289344a81eSBartosz Golaszewski op_time = jiffies; \ 1299344a81eSBartosz Golaszewski time_before(op_time, tout); \ 1309344a81eSBartosz Golaszewski usleep_range(1000, 1500), op_time = jiffies) 1319344a81eSBartosz Golaszewski 1325195e509SWolfram Sang static const struct i2c_device_id at24_ids[] = { 1335195e509SWolfram Sang /* needs 8 addresses as A0-A2 are ignored */ 1345195e509SWolfram Sang { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) }, 1355195e509SWolfram Sang /* old variants can't be handled with this generic entry! */ 1365195e509SWolfram Sang { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) }, 1375195e509SWolfram Sang { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) }, 1385195e509SWolfram Sang /* spd is a 24c02 in memory DIMMs */ 1395195e509SWolfram Sang { "spd", AT24_DEVICE_MAGIC(2048 / 8, 1405195e509SWolfram Sang AT24_FLAG_READONLY | AT24_FLAG_IRUGO) }, 1415195e509SWolfram Sang { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) }, 1425195e509SWolfram Sang /* 24rf08 quirk is handled at i2c-core */ 1435195e509SWolfram Sang { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 1445195e509SWolfram Sang { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) }, 1455195e509SWolfram Sang { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) }, 1465195e509SWolfram Sang { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) }, 1475195e509SWolfram Sang { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) }, 1485195e509SWolfram Sang { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) }, 1495195e509SWolfram Sang { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) }, 1505195e509SWolfram Sang { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) }, 1515195e509SWolfram Sang { "at24", 0 }, 1525195e509SWolfram Sang { /* END OF LIST */ } 1535195e509SWolfram Sang }; 1545195e509SWolfram Sang MODULE_DEVICE_TABLE(i2c, at24_ids); 1555195e509SWolfram Sang 15640d8edc9SAndy Shevchenko static const struct acpi_device_id at24_acpi_ids[] = { 15740d8edc9SAndy Shevchenko { "INT3499", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 15840d8edc9SAndy Shevchenko { } 15940d8edc9SAndy Shevchenko }; 16040d8edc9SAndy Shevchenko MODULE_DEVICE_TABLE(acpi, at24_acpi_ids); 16140d8edc9SAndy Shevchenko 1625195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 1635195e509SWolfram Sang 1645195e509SWolfram Sang /* 1655195e509SWolfram Sang * This routine supports chips which consume multiple I2C addresses. It 1665195e509SWolfram Sang * computes the addressing information to be used for a given r/w request. 1675195e509SWolfram Sang * Assumes that sanity checks for offset happened at sysfs-layer. 1685195e509SWolfram Sang */ 1695195e509SWolfram Sang static struct i2c_client *at24_translate_offset(struct at24_data *at24, 1702da78ac3SBartosz Golaszewski unsigned int *offset) 1715195e509SWolfram Sang { 1725195e509SWolfram Sang unsigned i; 1735195e509SWolfram Sang 1745195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) { 1755195e509SWolfram Sang i = *offset >> 16; 1765195e509SWolfram Sang *offset &= 0xffff; 1775195e509SWolfram Sang } else { 1785195e509SWolfram Sang i = *offset >> 8; 1795195e509SWolfram Sang *offset &= 0xff; 1805195e509SWolfram Sang } 1815195e509SWolfram Sang 1825195e509SWolfram Sang return at24->client[i]; 1835195e509SWolfram Sang } 1845195e509SWolfram Sang 1855195e509SWolfram Sang static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf, 1862da78ac3SBartosz Golaszewski unsigned int offset, size_t count) 1875195e509SWolfram Sang { 1885195e509SWolfram Sang struct i2c_msg msg[2]; 1895195e509SWolfram Sang u8 msgbuf[2]; 1905195e509SWolfram Sang struct i2c_client *client; 1914d29196cSWolfram Sang unsigned long timeout, read_time; 1925195e509SWolfram Sang int status, i; 1935195e509SWolfram Sang 1945195e509SWolfram Sang memset(msg, 0, sizeof(msg)); 1955195e509SWolfram Sang 1965195e509SWolfram Sang /* 1975195e509SWolfram Sang * REVISIT some multi-address chips don't rollover page reads to 1985195e509SWolfram Sang * the next slave address, so we may need to truncate the count. 1995195e509SWolfram Sang * Those chips might need another quirk flag. 2005195e509SWolfram Sang * 2015195e509SWolfram Sang * If the real hardware used four adjacent 24c02 chips and that 2025195e509SWolfram Sang * were misconfigured as one 24c08, that would be a similar effect: 2035195e509SWolfram Sang * one "eeprom" file not four, but larger reads would fail when 2045195e509SWolfram Sang * they crossed certain pages. 2055195e509SWolfram Sang */ 2065195e509SWolfram Sang 2075195e509SWolfram Sang /* 2085195e509SWolfram Sang * Slave address and byte offset derive from the offset. Always 2095195e509SWolfram Sang * set the byte address; on a multi-master board, another master 2105195e509SWolfram Sang * may have changed the chip's "current" address pointer. 2115195e509SWolfram Sang */ 2125195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 2135195e509SWolfram Sang 2145195e509SWolfram Sang if (count > io_limit) 2155195e509SWolfram Sang count = io_limit; 2165195e509SWolfram Sang 2172cd9fbd0SIrina Tirdea if (at24->use_smbus) { 2184d29196cSWolfram Sang /* Smaller eeproms can work given some SMBus extension calls */ 2195195e509SWolfram Sang if (count > I2C_SMBUS_BLOCK_MAX) 2205195e509SWolfram Sang count = I2C_SMBUS_BLOCK_MAX; 2212cd9fbd0SIrina Tirdea } else { 2225195e509SWolfram Sang /* 2234d29196cSWolfram Sang * When we have a better choice than SMBus calls, use a 2244d29196cSWolfram Sang * combined I2C message. Write address; then read up to 2254d29196cSWolfram Sang * io_limit data bytes. Note that read page rollover helps us 2264d29196cSWolfram Sang * here (unlike writes). msgbuf is u8 and will cast to our 2274d29196cSWolfram Sang * needs. 2285195e509SWolfram Sang */ 2295195e509SWolfram Sang i = 0; 2305195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 2315195e509SWolfram Sang msgbuf[i++] = offset >> 8; 2325195e509SWolfram Sang msgbuf[i++] = offset; 2335195e509SWolfram Sang 2345195e509SWolfram Sang msg[0].addr = client->addr; 2355195e509SWolfram Sang msg[0].buf = msgbuf; 2365195e509SWolfram Sang msg[0].len = i; 2375195e509SWolfram Sang 2385195e509SWolfram Sang msg[1].addr = client->addr; 2395195e509SWolfram Sang msg[1].flags = I2C_M_RD; 2405195e509SWolfram Sang msg[1].buf = buf; 2415195e509SWolfram Sang msg[1].len = count; 2424d29196cSWolfram Sang } 2435195e509SWolfram Sang 2449344a81eSBartosz Golaszewski loop_until_timeout(timeout, read_time) { 2452cd9fbd0SIrina Tirdea if (at24->use_smbus) { 2462cd9fbd0SIrina Tirdea status = i2c_smbus_read_i2c_block_data_or_emulated(client, offset, 2474d29196cSWolfram Sang count, buf); 2482cd9fbd0SIrina Tirdea } else { 2495195e509SWolfram Sang status = i2c_transfer(client->adapter, msg, 2); 2505195e509SWolfram Sang if (status == 2) 2514d29196cSWolfram Sang status = count; 2524d29196cSWolfram Sang } 2534d29196cSWolfram Sang dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 2544d29196cSWolfram Sang count, offset, status, jiffies); 2554d29196cSWolfram Sang 2564d29196cSWolfram Sang if (status == count) 2575195e509SWolfram Sang return count; 2589344a81eSBartosz Golaszewski } 2594d29196cSWolfram Sang 2604d29196cSWolfram Sang return -ETIMEDOUT; 2615195e509SWolfram Sang } 2625195e509SWolfram Sang 2635195e509SWolfram Sang /* 2645195e509SWolfram Sang * Note that if the hardware write-protect pin is pulled high, the whole 2655195e509SWolfram Sang * chip is normally write protected. But there are plenty of product 2665195e509SWolfram Sang * variants here, including OTP fuses and partial chip protect. 2675195e509SWolfram Sang * 2685195e509SWolfram Sang * We only use page mode writes; the alternative is sloooow. This routine 2695195e509SWolfram Sang * writes at most one page. 2705195e509SWolfram Sang */ 271280ca299SGeert Uytterhoeven static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf, 2722da78ac3SBartosz Golaszewski unsigned int offset, size_t count) 2735195e509SWolfram Sang { 2745195e509SWolfram Sang struct i2c_client *client; 2755195e509SWolfram Sang struct i2c_msg msg; 276a839ce66SChristian Gmeiner ssize_t status = 0; 2775195e509SWolfram Sang unsigned long timeout, write_time; 2785195e509SWolfram Sang unsigned next_page; 2795195e509SWolfram Sang 2805195e509SWolfram Sang /* Get corresponding I2C address and adjust offset */ 2815195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 2825195e509SWolfram Sang 2835195e509SWolfram Sang /* write_max is at most a page */ 2845195e509SWolfram Sang if (count > at24->write_max) 2855195e509SWolfram Sang count = at24->write_max; 2865195e509SWolfram Sang 2875195e509SWolfram Sang /* Never roll over backwards, to the start of this page */ 2885195e509SWolfram Sang next_page = roundup(offset + 1, at24->chip.page_size); 2895195e509SWolfram Sang if (offset + count > next_page) 2905195e509SWolfram Sang count = next_page - offset; 2915195e509SWolfram Sang 2925195e509SWolfram Sang /* If we'll use I2C calls for I/O, set up the message */ 2935195e509SWolfram Sang if (!at24->use_smbus) { 2945195e509SWolfram Sang int i = 0; 2955195e509SWolfram Sang 2965195e509SWolfram Sang msg.addr = client->addr; 2975195e509SWolfram Sang msg.flags = 0; 2985195e509SWolfram Sang 2995195e509SWolfram Sang /* msg.buf is u8 and casts will mask the values */ 3005195e509SWolfram Sang msg.buf = at24->writebuf; 3015195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 3025195e509SWolfram Sang msg.buf[i++] = offset >> 8; 3035195e509SWolfram Sang 3045195e509SWolfram Sang msg.buf[i++] = offset; 3055195e509SWolfram Sang memcpy(&msg.buf[i], buf, count); 3065195e509SWolfram Sang msg.len = i + count; 3075195e509SWolfram Sang } 3085195e509SWolfram Sang 3099344a81eSBartosz Golaszewski loop_until_timeout(timeout, write_time) { 310a839ce66SChristian Gmeiner if (at24->use_smbus_write) { 311a839ce66SChristian Gmeiner switch (at24->use_smbus_write) { 312a839ce66SChristian Gmeiner case I2C_SMBUS_I2C_BLOCK_DATA: 3135195e509SWolfram Sang status = i2c_smbus_write_i2c_block_data(client, 3145195e509SWolfram Sang offset, count, buf); 315a839ce66SChristian Gmeiner break; 316a839ce66SChristian Gmeiner case I2C_SMBUS_BYTE_DATA: 317a839ce66SChristian Gmeiner status = i2c_smbus_write_byte_data(client, 318a839ce66SChristian Gmeiner offset, buf[0]); 319a839ce66SChristian Gmeiner break; 320a839ce66SChristian Gmeiner } 321a839ce66SChristian Gmeiner 3225195e509SWolfram Sang if (status == 0) 3235195e509SWolfram Sang status = count; 3245195e509SWolfram Sang } else { 3255195e509SWolfram Sang status = i2c_transfer(client->adapter, &msg, 1); 3265195e509SWolfram Sang if (status == 1) 3275195e509SWolfram Sang status = count; 3285195e509SWolfram Sang } 3295195e509SWolfram Sang dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n", 3305195e509SWolfram Sang count, offset, status, jiffies); 3315195e509SWolfram Sang 3325195e509SWolfram Sang if (status == count) 3335195e509SWolfram Sang return count; 3349344a81eSBartosz Golaszewski } 3355195e509SWolfram Sang 3365195e509SWolfram Sang return -ETIMEDOUT; 3375195e509SWolfram Sang } 3385195e509SWolfram Sang 339d5bc0047SBartosz Golaszewski static int at24_read(void *priv, unsigned int off, void *val, size_t count) 340d5bc0047SBartosz Golaszewski { 341d5bc0047SBartosz Golaszewski struct at24_data *at24 = priv; 342d5bc0047SBartosz Golaszewski char *buf = val; 343d5bc0047SBartosz Golaszewski 344d5bc0047SBartosz Golaszewski if (unlikely(!count)) 345d5bc0047SBartosz Golaszewski return count; 346d5bc0047SBartosz Golaszewski 347d5bc0047SBartosz Golaszewski /* 348d5bc0047SBartosz Golaszewski * Read data from chip, protecting against concurrent updates 349d5bc0047SBartosz Golaszewski * from this host, but not from other I2C masters. 350d5bc0047SBartosz Golaszewski */ 351d5bc0047SBartosz Golaszewski mutex_lock(&at24->lock); 352d5bc0047SBartosz Golaszewski 353d5bc0047SBartosz Golaszewski while (count) { 354d5bc0047SBartosz Golaszewski int status; 355d5bc0047SBartosz Golaszewski 356318aa9c6SBartosz Golaszewski status = at24->read_func(at24, buf, off, count); 357d5bc0047SBartosz Golaszewski if (status < 0) { 358d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 359d5bc0047SBartosz Golaszewski return status; 360d5bc0047SBartosz Golaszewski } 361d5bc0047SBartosz Golaszewski buf += status; 362d5bc0047SBartosz Golaszewski off += status; 363d5bc0047SBartosz Golaszewski count -= status; 364d5bc0047SBartosz Golaszewski } 365d5bc0047SBartosz Golaszewski 366d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 367d5bc0047SBartosz Golaszewski 368d5bc0047SBartosz Golaszewski return 0; 369d5bc0047SBartosz Golaszewski } 370d5bc0047SBartosz Golaszewski 371cf0361a2SSrinivas Kandagatla static int at24_write(void *priv, unsigned int off, void *val, size_t count) 3725195e509SWolfram Sang { 373cf0361a2SSrinivas Kandagatla struct at24_data *at24 = priv; 374cf0361a2SSrinivas Kandagatla char *buf = val; 3755195e509SWolfram Sang 3765195e509SWolfram Sang if (unlikely(!count)) 377cf0361a2SSrinivas Kandagatla return -EINVAL; 3785195e509SWolfram Sang 3795195e509SWolfram Sang /* 3805195e509SWolfram Sang * Write data to chip, protecting against concurrent updates 3815195e509SWolfram Sang * from this host, but not from other I2C masters. 3825195e509SWolfram Sang */ 3835195e509SWolfram Sang mutex_lock(&at24->lock); 3845195e509SWolfram Sang 3855195e509SWolfram Sang while (count) { 386cf0361a2SSrinivas Kandagatla int status; 3875195e509SWolfram Sang 388318aa9c6SBartosz Golaszewski status = at24->write_func(at24, buf, off, count); 389cf0361a2SSrinivas Kandagatla if (status < 0) { 390cf0361a2SSrinivas Kandagatla mutex_unlock(&at24->lock); 391cf0361a2SSrinivas Kandagatla return status; 3925195e509SWolfram Sang } 3935195e509SWolfram Sang buf += status; 3945195e509SWolfram Sang off += status; 3955195e509SWolfram Sang count -= status; 3965195e509SWolfram Sang } 3975195e509SWolfram Sang 3985195e509SWolfram Sang mutex_unlock(&at24->lock); 3995195e509SWolfram Sang 40057d15550SAndrew Lunn return 0; 40157d15550SAndrew Lunn } 40257d15550SAndrew Lunn 4039ed030d7SWolfram Sang #ifdef CONFIG_OF 4049ed030d7SWolfram Sang static void at24_get_ofdata(struct i2c_client *client, 4059ed030d7SWolfram Sang struct at24_platform_data *chip) 4069ed030d7SWolfram Sang { 4079ed030d7SWolfram Sang const __be32 *val; 4089ed030d7SWolfram Sang struct device_node *node = client->dev.of_node; 4099ed030d7SWolfram Sang 4109ed030d7SWolfram Sang if (node) { 4119ed030d7SWolfram Sang if (of_get_property(node, "read-only", NULL)) 4129ed030d7SWolfram Sang chip->flags |= AT24_FLAG_READONLY; 4139ed030d7SWolfram Sang val = of_get_property(node, "pagesize", NULL); 4149ed030d7SWolfram Sang if (val) 4159ed030d7SWolfram Sang chip->page_size = be32_to_cpup(val); 4169ed030d7SWolfram Sang } 4179ed030d7SWolfram Sang } 4189ed030d7SWolfram Sang #else 4199ed030d7SWolfram Sang static void at24_get_ofdata(struct i2c_client *client, 4209ed030d7SWolfram Sang struct at24_platform_data *chip) 4219ed030d7SWolfram Sang { } 4229ed030d7SWolfram Sang #endif /* CONFIG_OF */ 4239ed030d7SWolfram Sang 4245195e509SWolfram Sang static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) 4255195e509SWolfram Sang { 4265195e509SWolfram Sang struct at24_platform_data chip; 42740d8edc9SAndy Shevchenko kernel_ulong_t magic = 0; 4285195e509SWolfram Sang bool writable; 4297aeb9664SJean Delvare int use_smbus = 0; 430a839ce66SChristian Gmeiner int use_smbus_write = 0; 4315195e509SWolfram Sang struct at24_data *at24; 4325195e509SWolfram Sang int err; 4335195e509SWolfram Sang unsigned i, num_addresses; 4345195e509SWolfram Sang 4355195e509SWolfram Sang if (client->dev.platform_data) { 4365195e509SWolfram Sang chip = *(struct at24_platform_data *)client->dev.platform_data; 4375195e509SWolfram Sang } else { 43840d8edc9SAndy Shevchenko if (id) { 43940d8edc9SAndy Shevchenko magic = id->driver_data; 44040d8edc9SAndy Shevchenko } else { 44140d8edc9SAndy Shevchenko const struct acpi_device_id *aid; 44240d8edc9SAndy Shevchenko 44340d8edc9SAndy Shevchenko aid = acpi_match_device(at24_acpi_ids, &client->dev); 44440d8edc9SAndy Shevchenko if (aid) 44540d8edc9SAndy Shevchenko magic = aid->driver_data; 44640d8edc9SAndy Shevchenko } 44740d8edc9SAndy Shevchenko if (!magic) 448f0ac2363SNikolay Balandin return -ENODEV; 449f0ac2363SNikolay Balandin 4505195e509SWolfram Sang chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN)); 4515195e509SWolfram Sang magic >>= AT24_SIZE_BYTELEN; 4525195e509SWolfram Sang chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS); 4535195e509SWolfram Sang /* 4545195e509SWolfram Sang * This is slow, but we can't know all eeproms, so we better 4555195e509SWolfram Sang * play safe. Specifying custom eeprom-types via platform_data 4565195e509SWolfram Sang * is recommended anyhow. 4575195e509SWolfram Sang */ 4585195e509SWolfram Sang chip.page_size = 1; 4597274ec8bSKevin Hilman 4609ed030d7SWolfram Sang /* update chipdata if OF is present */ 4619ed030d7SWolfram Sang at24_get_ofdata(client, &chip); 4629ed030d7SWolfram Sang 4637274ec8bSKevin Hilman chip.setup = NULL; 4647274ec8bSKevin Hilman chip.context = NULL; 4655195e509SWolfram Sang } 4665195e509SWolfram Sang 4675195e509SWolfram Sang if (!is_power_of_2(chip.byte_len)) 4685195e509SWolfram Sang dev_warn(&client->dev, 4695195e509SWolfram Sang "byte_len looks suspicious (no power of 2)!\n"); 47045efe847SWolfram Sang if (!chip.page_size) { 47145efe847SWolfram Sang dev_err(&client->dev, "page_size must not be 0!\n"); 472f0ac2363SNikolay Balandin return -EINVAL; 47345efe847SWolfram Sang } 4745195e509SWolfram Sang if (!is_power_of_2(chip.page_size)) 4755195e509SWolfram Sang dev_warn(&client->dev, 4765195e509SWolfram Sang "page_size looks suspicious (no power of 2)!\n"); 4775195e509SWolfram Sang 4785195e509SWolfram Sang /* Use I2C operations unless we're stuck with SMBus extensions. */ 4795195e509SWolfram Sang if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 480f0ac2363SNikolay Balandin if (chip.flags & AT24_FLAG_ADDR16) 481f0ac2363SNikolay Balandin return -EPFNOSUPPORT; 482f0ac2363SNikolay Balandin 4837aeb9664SJean Delvare if (i2c_check_functionality(client->adapter, 4845195e509SWolfram Sang I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 4857aeb9664SJean Delvare use_smbus = I2C_SMBUS_I2C_BLOCK_DATA; 4867aeb9664SJean Delvare } else if (i2c_check_functionality(client->adapter, 4877aeb9664SJean Delvare I2C_FUNC_SMBUS_READ_WORD_DATA)) { 4887aeb9664SJean Delvare use_smbus = I2C_SMBUS_WORD_DATA; 4897aeb9664SJean Delvare } else if (i2c_check_functionality(client->adapter, 4907aeb9664SJean Delvare I2C_FUNC_SMBUS_READ_BYTE_DATA)) { 4917aeb9664SJean Delvare use_smbus = I2C_SMBUS_BYTE_DATA; 4927aeb9664SJean Delvare } else { 493f0ac2363SNikolay Balandin return -EPFNOSUPPORT; 4945195e509SWolfram Sang } 4955195e509SWolfram Sang 496a839ce66SChristian Gmeiner if (i2c_check_functionality(client->adapter, 497a839ce66SChristian Gmeiner I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { 498a839ce66SChristian Gmeiner use_smbus_write = I2C_SMBUS_I2C_BLOCK_DATA; 499a839ce66SChristian Gmeiner } else if (i2c_check_functionality(client->adapter, 500a839ce66SChristian Gmeiner I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) { 501a839ce66SChristian Gmeiner use_smbus_write = I2C_SMBUS_BYTE_DATA; 502a839ce66SChristian Gmeiner chip.page_size = 1; 503a839ce66SChristian Gmeiner } 504a839ce66SChristian Gmeiner } 505a839ce66SChristian Gmeiner 5065195e509SWolfram Sang if (chip.flags & AT24_FLAG_TAKE8ADDR) 5075195e509SWolfram Sang num_addresses = 8; 5085195e509SWolfram Sang else 5095195e509SWolfram Sang num_addresses = DIV_ROUND_UP(chip.byte_len, 5105195e509SWolfram Sang (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256); 5115195e509SWolfram Sang 512f0ac2363SNikolay Balandin at24 = devm_kzalloc(&client->dev, sizeof(struct at24_data) + 5135195e509SWolfram Sang num_addresses * sizeof(struct i2c_client *), GFP_KERNEL); 514f0ac2363SNikolay Balandin if (!at24) 515f0ac2363SNikolay Balandin return -ENOMEM; 5165195e509SWolfram Sang 5175195e509SWolfram Sang mutex_init(&at24->lock); 5185195e509SWolfram Sang at24->use_smbus = use_smbus; 519a839ce66SChristian Gmeiner at24->use_smbus_write = use_smbus_write; 5205195e509SWolfram Sang at24->chip = chip; 5215195e509SWolfram Sang at24->num_addresses = num_addresses; 5225195e509SWolfram Sang 523318aa9c6SBartosz Golaszewski at24->read_func = at24_eeprom_read; 524318aa9c6SBartosz Golaszewski at24->write_func = at24_eeprom_write; 525318aa9c6SBartosz Golaszewski 5265195e509SWolfram Sang writable = !(chip.flags & AT24_FLAG_READONLY); 5275195e509SWolfram Sang if (writable) { 528a839ce66SChristian Gmeiner if (!use_smbus || use_smbus_write) { 5295195e509SWolfram Sang 5305195e509SWolfram Sang unsigned write_max = chip.page_size; 5315195e509SWolfram Sang 5325195e509SWolfram Sang if (write_max > io_limit) 5335195e509SWolfram Sang write_max = io_limit; 5345195e509SWolfram Sang if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX) 5355195e509SWolfram Sang write_max = I2C_SMBUS_BLOCK_MAX; 5365195e509SWolfram Sang at24->write_max = write_max; 5375195e509SWolfram Sang 5385195e509SWolfram Sang /* buffer (data + address at the beginning) */ 539f0ac2363SNikolay Balandin at24->writebuf = devm_kzalloc(&client->dev, 540f0ac2363SNikolay Balandin write_max + 2, GFP_KERNEL); 541f0ac2363SNikolay Balandin if (!at24->writebuf) 542f0ac2363SNikolay Balandin return -ENOMEM; 5435195e509SWolfram Sang } else { 5445195e509SWolfram Sang dev_warn(&client->dev, 5455195e509SWolfram Sang "cannot write due to controller restrictions."); 5465195e509SWolfram Sang } 5475195e509SWolfram Sang } 5485195e509SWolfram Sang 5495195e509SWolfram Sang at24->client[0] = client; 5505195e509SWolfram Sang 5515195e509SWolfram Sang /* use dummy devices for multiple-address chips */ 5525195e509SWolfram Sang for (i = 1; i < num_addresses; i++) { 5535195e509SWolfram Sang at24->client[i] = i2c_new_dummy(client->adapter, 5545195e509SWolfram Sang client->addr + i); 5555195e509SWolfram Sang if (!at24->client[i]) { 5565195e509SWolfram Sang dev_err(&client->dev, "address 0x%02x unavailable\n", 5575195e509SWolfram Sang client->addr + i); 5585195e509SWolfram Sang err = -EADDRINUSE; 5595195e509SWolfram Sang goto err_clients; 5605195e509SWolfram Sang } 5615195e509SWolfram Sang } 5625195e509SWolfram Sang 56357d15550SAndrew Lunn at24->nvmem_config.name = dev_name(&client->dev); 56457d15550SAndrew Lunn at24->nvmem_config.dev = &client->dev; 56557d15550SAndrew Lunn at24->nvmem_config.read_only = !writable; 56657d15550SAndrew Lunn at24->nvmem_config.root_only = true; 56757d15550SAndrew Lunn at24->nvmem_config.owner = THIS_MODULE; 56857d15550SAndrew Lunn at24->nvmem_config.compat = true; 56957d15550SAndrew Lunn at24->nvmem_config.base_dev = &client->dev; 570cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_read = at24_read; 571cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_write = at24_write; 572cf0361a2SSrinivas Kandagatla at24->nvmem_config.priv = at24; 573cf0361a2SSrinivas Kandagatla at24->nvmem_config.stride = 4; 574cf0361a2SSrinivas Kandagatla at24->nvmem_config.word_size = 1; 575cf0361a2SSrinivas Kandagatla at24->nvmem_config.size = chip.byte_len; 57657d15550SAndrew Lunn 57757d15550SAndrew Lunn at24->nvmem = nvmem_register(&at24->nvmem_config); 57857d15550SAndrew Lunn 57957d15550SAndrew Lunn if (IS_ERR(at24->nvmem)) { 58057d15550SAndrew Lunn err = PTR_ERR(at24->nvmem); 58157d15550SAndrew Lunn goto err_clients; 58257d15550SAndrew Lunn } 5835195e509SWolfram Sang 5845195e509SWolfram Sang i2c_set_clientdata(client, at24); 5855195e509SWolfram Sang 58657d15550SAndrew Lunn dev_info(&client->dev, "%u byte %s EEPROM, %s, %u bytes/write\n", 58757d15550SAndrew Lunn chip.byte_len, client->name, 5889ed030d7SWolfram Sang writable ? "writable" : "read-only", at24->write_max); 5897aeb9664SJean Delvare if (use_smbus == I2C_SMBUS_WORD_DATA || 5907aeb9664SJean Delvare use_smbus == I2C_SMBUS_BYTE_DATA) { 5917aeb9664SJean Delvare dev_notice(&client->dev, "Falling back to %s reads, " 5927aeb9664SJean Delvare "performance will suffer\n", use_smbus == 5937aeb9664SJean Delvare I2C_SMBUS_WORD_DATA ? "word" : "byte"); 5947aeb9664SJean Delvare } 5955195e509SWolfram Sang 5967274ec8bSKevin Hilman /* export data to kernel code */ 5977274ec8bSKevin Hilman if (chip.setup) 598bec3c11bSAndrew Lunn chip.setup(at24->nvmem, chip.context); 5997274ec8bSKevin Hilman 6005195e509SWolfram Sang return 0; 6015195e509SWolfram Sang 6025195e509SWolfram Sang err_clients: 6035195e509SWolfram Sang for (i = 1; i < num_addresses; i++) 6045195e509SWolfram Sang if (at24->client[i]) 6055195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 6065195e509SWolfram Sang 6075195e509SWolfram Sang return err; 6085195e509SWolfram Sang } 6095195e509SWolfram Sang 610486a5c28SBill Pemberton static int at24_remove(struct i2c_client *client) 6115195e509SWolfram Sang { 6125195e509SWolfram Sang struct at24_data *at24; 6135195e509SWolfram Sang int i; 6145195e509SWolfram Sang 6155195e509SWolfram Sang at24 = i2c_get_clientdata(client); 61657d15550SAndrew Lunn 61757d15550SAndrew Lunn nvmem_unregister(at24->nvmem); 6185195e509SWolfram Sang 6195195e509SWolfram Sang for (i = 1; i < at24->num_addresses; i++) 6205195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 6215195e509SWolfram Sang 6225195e509SWolfram Sang return 0; 6235195e509SWolfram Sang } 6245195e509SWolfram Sang 6255195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 6265195e509SWolfram Sang 6275195e509SWolfram Sang static struct i2c_driver at24_driver = { 6285195e509SWolfram Sang .driver = { 6295195e509SWolfram Sang .name = "at24", 63040d8edc9SAndy Shevchenko .acpi_match_table = ACPI_PTR(at24_acpi_ids), 6315195e509SWolfram Sang }, 6325195e509SWolfram Sang .probe = at24_probe, 6332d6bed9cSBill Pemberton .remove = at24_remove, 6345195e509SWolfram Sang .id_table = at24_ids, 6355195e509SWolfram Sang }; 6365195e509SWolfram Sang 6375195e509SWolfram Sang static int __init at24_init(void) 6385195e509SWolfram Sang { 63945efe847SWolfram Sang if (!io_limit) { 64045efe847SWolfram Sang pr_err("at24: io_limit must not be 0!\n"); 64145efe847SWolfram Sang return -EINVAL; 64245efe847SWolfram Sang } 64345efe847SWolfram Sang 6445195e509SWolfram Sang io_limit = rounddown_pow_of_two(io_limit); 6455195e509SWolfram Sang return i2c_add_driver(&at24_driver); 6465195e509SWolfram Sang } 6475195e509SWolfram Sang module_init(at24_init); 6485195e509SWolfram Sang 6495195e509SWolfram Sang static void __exit at24_exit(void) 6505195e509SWolfram Sang { 6515195e509SWolfram Sang i2c_del_driver(&at24_driver); 6525195e509SWolfram Sang } 6535195e509SWolfram Sang module_exit(at24_exit); 6545195e509SWolfram Sang 6555195e509SWolfram Sang MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); 6565195e509SWolfram Sang MODULE_AUTHOR("David Brownell and Wolfram Sang"); 6575195e509SWolfram Sang MODULE_LICENSE("GPL"); 658