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 615195e509SWolfram Sang /* 625195e509SWolfram Sang * Lock protects against activities from other Linux tasks, 635195e509SWolfram Sang * but not from changes by other I2C masters. 645195e509SWolfram Sang */ 655195e509SWolfram Sang struct mutex lock; 665195e509SWolfram Sang 675195e509SWolfram Sang u8 *writebuf; 685195e509SWolfram Sang unsigned write_max; 695195e509SWolfram Sang unsigned num_addresses; 705195e509SWolfram Sang 7157d15550SAndrew Lunn struct nvmem_config nvmem_config; 7257d15550SAndrew Lunn struct nvmem_device *nvmem; 7357d15550SAndrew Lunn 745195e509SWolfram Sang /* 755195e509SWolfram Sang * Some chips tie up multiple I2C addresses; dummy devices reserve 765195e509SWolfram Sang * them for us, and we'll use them with SMBus calls. 775195e509SWolfram Sang */ 785195e509SWolfram Sang struct i2c_client *client[]; 795195e509SWolfram Sang }; 805195e509SWolfram Sang 815195e509SWolfram Sang /* 825195e509SWolfram Sang * This parameter is to help this driver avoid blocking other drivers out 835195e509SWolfram Sang * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C 845195e509SWolfram Sang * clock, one 256 byte read takes about 1/43 second which is excessive; 855195e509SWolfram Sang * but the 1/170 second it takes at 400 kHz may be quite reasonable; and 865195e509SWolfram Sang * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible. 875195e509SWolfram Sang * 885195e509SWolfram Sang * This value is forced to be a power of two so that writes align on pages. 895195e509SWolfram Sang */ 905195e509SWolfram Sang static unsigned io_limit = 128; 915195e509SWolfram Sang module_param(io_limit, uint, 0); 925195e509SWolfram Sang MODULE_PARM_DESC(io_limit, "Maximum bytes per I/O (default 128)"); 935195e509SWolfram Sang 945195e509SWolfram Sang /* 955195e509SWolfram Sang * Specs often allow 5 msec for a page write, sometimes 20 msec; 965195e509SWolfram Sang * it's important to recover from write timeouts. 975195e509SWolfram Sang */ 985195e509SWolfram Sang static unsigned write_timeout = 25; 995195e509SWolfram Sang module_param(write_timeout, uint, 0); 1005195e509SWolfram Sang MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)"); 1015195e509SWolfram Sang 1025195e509SWolfram Sang #define AT24_SIZE_BYTELEN 5 1035195e509SWolfram Sang #define AT24_SIZE_FLAGS 8 1045195e509SWolfram Sang 1055195e509SWolfram Sang #define AT24_BITMASK(x) (BIT(x) - 1) 1065195e509SWolfram Sang 1075195e509SWolfram Sang /* create non-zero magic value for given eeprom parameters */ 1085195e509SWolfram Sang #define AT24_DEVICE_MAGIC(_len, _flags) \ 1095195e509SWolfram Sang ((1 << AT24_SIZE_FLAGS | (_flags)) \ 1105195e509SWolfram Sang << AT24_SIZE_BYTELEN | ilog2(_len)) 1115195e509SWolfram Sang 1125195e509SWolfram Sang static const struct i2c_device_id at24_ids[] = { 1135195e509SWolfram Sang /* needs 8 addresses as A0-A2 are ignored */ 1145195e509SWolfram Sang { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) }, 1155195e509SWolfram Sang /* old variants can't be handled with this generic entry! */ 1165195e509SWolfram Sang { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) }, 1175195e509SWolfram Sang { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) }, 1185195e509SWolfram Sang /* spd is a 24c02 in memory DIMMs */ 1195195e509SWolfram Sang { "spd", AT24_DEVICE_MAGIC(2048 / 8, 1205195e509SWolfram Sang AT24_FLAG_READONLY | AT24_FLAG_IRUGO) }, 1215195e509SWolfram Sang { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) }, 1225195e509SWolfram Sang /* 24rf08 quirk is handled at i2c-core */ 1235195e509SWolfram Sang { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 1245195e509SWolfram Sang { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) }, 1255195e509SWolfram Sang { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) }, 1265195e509SWolfram Sang { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) }, 1275195e509SWolfram Sang { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) }, 1285195e509SWolfram Sang { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) }, 1295195e509SWolfram Sang { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) }, 1305195e509SWolfram Sang { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) }, 1315195e509SWolfram Sang { "at24", 0 }, 1325195e509SWolfram Sang { /* END OF LIST */ } 1335195e509SWolfram Sang }; 1345195e509SWolfram Sang MODULE_DEVICE_TABLE(i2c, at24_ids); 1355195e509SWolfram Sang 13640d8edc9SAndy Shevchenko static const struct acpi_device_id at24_acpi_ids[] = { 13740d8edc9SAndy Shevchenko { "INT3499", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 13840d8edc9SAndy Shevchenko { } 13940d8edc9SAndy Shevchenko }; 14040d8edc9SAndy Shevchenko MODULE_DEVICE_TABLE(acpi, at24_acpi_ids); 14140d8edc9SAndy Shevchenko 1425195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 1435195e509SWolfram Sang 1445195e509SWolfram Sang /* 1455195e509SWolfram Sang * This routine supports chips which consume multiple I2C addresses. It 1465195e509SWolfram Sang * computes the addressing information to be used for a given r/w request. 1475195e509SWolfram Sang * Assumes that sanity checks for offset happened at sysfs-layer. 1485195e509SWolfram Sang */ 1495195e509SWolfram Sang static struct i2c_client *at24_translate_offset(struct at24_data *at24, 1505195e509SWolfram Sang unsigned *offset) 1515195e509SWolfram Sang { 1525195e509SWolfram Sang unsigned i; 1535195e509SWolfram Sang 1545195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) { 1555195e509SWolfram Sang i = *offset >> 16; 1565195e509SWolfram Sang *offset &= 0xffff; 1575195e509SWolfram Sang } else { 1585195e509SWolfram Sang i = *offset >> 8; 1595195e509SWolfram Sang *offset &= 0xff; 1605195e509SWolfram Sang } 1615195e509SWolfram Sang 1625195e509SWolfram Sang return at24->client[i]; 1635195e509SWolfram Sang } 1645195e509SWolfram Sang 1655195e509SWolfram Sang static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf, 1665195e509SWolfram Sang unsigned offset, size_t count) 1675195e509SWolfram Sang { 1685195e509SWolfram Sang struct i2c_msg msg[2]; 1695195e509SWolfram Sang u8 msgbuf[2]; 1705195e509SWolfram Sang struct i2c_client *client; 1714d29196cSWolfram Sang unsigned long timeout, read_time; 1725195e509SWolfram Sang int status, i; 1735195e509SWolfram Sang 1745195e509SWolfram Sang memset(msg, 0, sizeof(msg)); 1755195e509SWolfram Sang 1765195e509SWolfram Sang /* 1775195e509SWolfram Sang * REVISIT some multi-address chips don't rollover page reads to 1785195e509SWolfram Sang * the next slave address, so we may need to truncate the count. 1795195e509SWolfram Sang * Those chips might need another quirk flag. 1805195e509SWolfram Sang * 1815195e509SWolfram Sang * If the real hardware used four adjacent 24c02 chips and that 1825195e509SWolfram Sang * were misconfigured as one 24c08, that would be a similar effect: 1835195e509SWolfram Sang * one "eeprom" file not four, but larger reads would fail when 1845195e509SWolfram Sang * they crossed certain pages. 1855195e509SWolfram Sang */ 1865195e509SWolfram Sang 1875195e509SWolfram Sang /* 1885195e509SWolfram Sang * Slave address and byte offset derive from the offset. Always 1895195e509SWolfram Sang * set the byte address; on a multi-master board, another master 1905195e509SWolfram Sang * may have changed the chip's "current" address pointer. 1915195e509SWolfram Sang */ 1925195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 1935195e509SWolfram Sang 1945195e509SWolfram Sang if (count > io_limit) 1955195e509SWolfram Sang count = io_limit; 1965195e509SWolfram Sang 1972cd9fbd0SIrina Tirdea if (at24->use_smbus) { 1984d29196cSWolfram Sang /* Smaller eeproms can work given some SMBus extension calls */ 1995195e509SWolfram Sang if (count > I2C_SMBUS_BLOCK_MAX) 2005195e509SWolfram Sang count = I2C_SMBUS_BLOCK_MAX; 2012cd9fbd0SIrina Tirdea } else { 2025195e509SWolfram Sang /* 2034d29196cSWolfram Sang * When we have a better choice than SMBus calls, use a 2044d29196cSWolfram Sang * combined I2C message. Write address; then read up to 2054d29196cSWolfram Sang * io_limit data bytes. Note that read page rollover helps us 2064d29196cSWolfram Sang * here (unlike writes). msgbuf is u8 and will cast to our 2074d29196cSWolfram Sang * needs. 2085195e509SWolfram Sang */ 2095195e509SWolfram Sang i = 0; 2105195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 2115195e509SWolfram Sang msgbuf[i++] = offset >> 8; 2125195e509SWolfram Sang msgbuf[i++] = offset; 2135195e509SWolfram Sang 2145195e509SWolfram Sang msg[0].addr = client->addr; 2155195e509SWolfram Sang msg[0].buf = msgbuf; 2165195e509SWolfram Sang msg[0].len = i; 2175195e509SWolfram Sang 2185195e509SWolfram Sang msg[1].addr = client->addr; 2195195e509SWolfram Sang msg[1].flags = I2C_M_RD; 2205195e509SWolfram Sang msg[1].buf = buf; 2215195e509SWolfram Sang msg[1].len = count; 2224d29196cSWolfram Sang } 2235195e509SWolfram Sang 2244d29196cSWolfram Sang /* 2254d29196cSWolfram Sang * Reads fail if the previous write didn't complete yet. We may 2264d29196cSWolfram Sang * loop a few times until this one succeeds, waiting at least 2274d29196cSWolfram Sang * long enough for one entire page write to work. 2284d29196cSWolfram Sang */ 2294d29196cSWolfram Sang timeout = jiffies + msecs_to_jiffies(write_timeout); 2304d29196cSWolfram Sang do { 2314d29196cSWolfram Sang read_time = jiffies; 2322cd9fbd0SIrina Tirdea if (at24->use_smbus) { 2332cd9fbd0SIrina Tirdea status = i2c_smbus_read_i2c_block_data_or_emulated(client, offset, 2344d29196cSWolfram Sang count, buf); 2352cd9fbd0SIrina Tirdea } else { 2365195e509SWolfram Sang status = i2c_transfer(client->adapter, msg, 2); 2375195e509SWolfram Sang if (status == 2) 2384d29196cSWolfram Sang status = count; 2394d29196cSWolfram Sang } 2404d29196cSWolfram Sang dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 2414d29196cSWolfram Sang count, offset, status, jiffies); 2424d29196cSWolfram Sang 2434d29196cSWolfram Sang if (status == count) 2445195e509SWolfram Sang return count; 2454d29196cSWolfram Sang 2461d98d0ecSBartosz Golaszewski usleep_range(1000, 1500); 2474d29196cSWolfram Sang } while (time_before(read_time, timeout)); 2484d29196cSWolfram Sang 2494d29196cSWolfram Sang return -ETIMEDOUT; 2505195e509SWolfram Sang } 2515195e509SWolfram Sang 2525195e509SWolfram Sang /* 2535195e509SWolfram Sang * Note that if the hardware write-protect pin is pulled high, the whole 2545195e509SWolfram Sang * chip is normally write protected. But there are plenty of product 2555195e509SWolfram Sang * variants here, including OTP fuses and partial chip protect. 2565195e509SWolfram Sang * 2575195e509SWolfram Sang * We only use page mode writes; the alternative is sloooow. This routine 2585195e509SWolfram Sang * writes at most one page. 2595195e509SWolfram Sang */ 260280ca299SGeert Uytterhoeven static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf, 2615195e509SWolfram Sang unsigned offset, size_t count) 2625195e509SWolfram Sang { 2635195e509SWolfram Sang struct i2c_client *client; 2645195e509SWolfram Sang struct i2c_msg msg; 265a839ce66SChristian Gmeiner ssize_t status = 0; 2665195e509SWolfram Sang unsigned long timeout, write_time; 2675195e509SWolfram Sang unsigned next_page; 2685195e509SWolfram Sang 2695195e509SWolfram Sang /* Get corresponding I2C address and adjust offset */ 2705195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 2715195e509SWolfram Sang 2725195e509SWolfram Sang /* write_max is at most a page */ 2735195e509SWolfram Sang if (count > at24->write_max) 2745195e509SWolfram Sang count = at24->write_max; 2755195e509SWolfram Sang 2765195e509SWolfram Sang /* Never roll over backwards, to the start of this page */ 2775195e509SWolfram Sang next_page = roundup(offset + 1, at24->chip.page_size); 2785195e509SWolfram Sang if (offset + count > next_page) 2795195e509SWolfram Sang count = next_page - offset; 2805195e509SWolfram Sang 2815195e509SWolfram Sang /* If we'll use I2C calls for I/O, set up the message */ 2825195e509SWolfram Sang if (!at24->use_smbus) { 2835195e509SWolfram Sang int i = 0; 2845195e509SWolfram Sang 2855195e509SWolfram Sang msg.addr = client->addr; 2865195e509SWolfram Sang msg.flags = 0; 2875195e509SWolfram Sang 2885195e509SWolfram Sang /* msg.buf is u8 and casts will mask the values */ 2895195e509SWolfram Sang msg.buf = at24->writebuf; 2905195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 2915195e509SWolfram Sang msg.buf[i++] = offset >> 8; 2925195e509SWolfram Sang 2935195e509SWolfram Sang msg.buf[i++] = offset; 2945195e509SWolfram Sang memcpy(&msg.buf[i], buf, count); 2955195e509SWolfram Sang msg.len = i + count; 2965195e509SWolfram Sang } 2975195e509SWolfram Sang 2985195e509SWolfram Sang /* 2995195e509SWolfram Sang * Writes fail if the previous one didn't complete yet. We may 3005195e509SWolfram Sang * loop a few times until this one succeeds, waiting at least 3015195e509SWolfram Sang * long enough for one entire page write to work. 3025195e509SWolfram Sang */ 3035195e509SWolfram Sang timeout = jiffies + msecs_to_jiffies(write_timeout); 3045195e509SWolfram Sang do { 3055195e509SWolfram Sang write_time = jiffies; 306a839ce66SChristian Gmeiner if (at24->use_smbus_write) { 307a839ce66SChristian Gmeiner switch (at24->use_smbus_write) { 308a839ce66SChristian Gmeiner case I2C_SMBUS_I2C_BLOCK_DATA: 3095195e509SWolfram Sang status = i2c_smbus_write_i2c_block_data(client, 3105195e509SWolfram Sang offset, count, buf); 311a839ce66SChristian Gmeiner break; 312a839ce66SChristian Gmeiner case I2C_SMBUS_BYTE_DATA: 313a839ce66SChristian Gmeiner status = i2c_smbus_write_byte_data(client, 314a839ce66SChristian Gmeiner offset, buf[0]); 315a839ce66SChristian Gmeiner break; 316a839ce66SChristian Gmeiner } 317a839ce66SChristian Gmeiner 3185195e509SWolfram Sang if (status == 0) 3195195e509SWolfram Sang status = count; 3205195e509SWolfram Sang } else { 3215195e509SWolfram Sang status = i2c_transfer(client->adapter, &msg, 1); 3225195e509SWolfram Sang if (status == 1) 3235195e509SWolfram Sang status = count; 3245195e509SWolfram Sang } 3255195e509SWolfram Sang dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n", 3265195e509SWolfram Sang count, offset, status, jiffies); 3275195e509SWolfram Sang 3285195e509SWolfram Sang if (status == count) 3295195e509SWolfram Sang return count; 3305195e509SWolfram Sang 3311d98d0ecSBartosz Golaszewski usleep_range(1000, 1500); 3325195e509SWolfram Sang } while (time_before(write_time, timeout)); 3335195e509SWolfram Sang 3345195e509SWolfram Sang return -ETIMEDOUT; 3355195e509SWolfram Sang } 3365195e509SWolfram Sang 337d5bc0047SBartosz Golaszewski static int at24_read(void *priv, unsigned int off, void *val, size_t count) 338d5bc0047SBartosz Golaszewski { 339d5bc0047SBartosz Golaszewski struct at24_data *at24 = priv; 340d5bc0047SBartosz Golaszewski char *buf = val; 341d5bc0047SBartosz Golaszewski 342d5bc0047SBartosz Golaszewski if (unlikely(!count)) 343d5bc0047SBartosz Golaszewski return count; 344d5bc0047SBartosz Golaszewski 345d5bc0047SBartosz Golaszewski /* 346d5bc0047SBartosz Golaszewski * Read data from chip, protecting against concurrent updates 347d5bc0047SBartosz Golaszewski * from this host, but not from other I2C masters. 348d5bc0047SBartosz Golaszewski */ 349d5bc0047SBartosz Golaszewski mutex_lock(&at24->lock); 350d5bc0047SBartosz Golaszewski 351d5bc0047SBartosz Golaszewski while (count) { 352d5bc0047SBartosz Golaszewski int status; 353d5bc0047SBartosz Golaszewski 354d5bc0047SBartosz Golaszewski status = at24_eeprom_read(at24, buf, off, count); 355d5bc0047SBartosz Golaszewski if (status < 0) { 356d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 357d5bc0047SBartosz Golaszewski return status; 358d5bc0047SBartosz Golaszewski } 359d5bc0047SBartosz Golaszewski buf += status; 360d5bc0047SBartosz Golaszewski off += status; 361d5bc0047SBartosz Golaszewski count -= status; 362d5bc0047SBartosz Golaszewski } 363d5bc0047SBartosz Golaszewski 364d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 365d5bc0047SBartosz Golaszewski 366d5bc0047SBartosz Golaszewski return 0; 367d5bc0047SBartosz Golaszewski } 368d5bc0047SBartosz Golaszewski 369cf0361a2SSrinivas Kandagatla static int at24_write(void *priv, unsigned int off, void *val, size_t count) 3705195e509SWolfram Sang { 371cf0361a2SSrinivas Kandagatla struct at24_data *at24 = priv; 372cf0361a2SSrinivas Kandagatla char *buf = val; 3735195e509SWolfram Sang 3745195e509SWolfram Sang if (unlikely(!count)) 375cf0361a2SSrinivas Kandagatla return -EINVAL; 3765195e509SWolfram Sang 3775195e509SWolfram Sang /* 3785195e509SWolfram Sang * Write data to chip, protecting against concurrent updates 3795195e509SWolfram Sang * from this host, but not from other I2C masters. 3805195e509SWolfram Sang */ 3815195e509SWolfram Sang mutex_lock(&at24->lock); 3825195e509SWolfram Sang 3835195e509SWolfram Sang while (count) { 384cf0361a2SSrinivas Kandagatla int status; 3855195e509SWolfram Sang 3865195e509SWolfram Sang status = at24_eeprom_write(at24, buf, off, count); 387cf0361a2SSrinivas Kandagatla if (status < 0) { 388cf0361a2SSrinivas Kandagatla mutex_unlock(&at24->lock); 389cf0361a2SSrinivas Kandagatla return status; 3905195e509SWolfram Sang } 3915195e509SWolfram Sang buf += status; 3925195e509SWolfram Sang off += status; 3935195e509SWolfram Sang count -= status; 3945195e509SWolfram Sang } 3955195e509SWolfram Sang 3965195e509SWolfram Sang mutex_unlock(&at24->lock); 3975195e509SWolfram Sang 39857d15550SAndrew Lunn return 0; 39957d15550SAndrew Lunn } 40057d15550SAndrew Lunn 4019ed030d7SWolfram Sang #ifdef CONFIG_OF 4029ed030d7SWolfram Sang static void at24_get_ofdata(struct i2c_client *client, 4039ed030d7SWolfram Sang struct at24_platform_data *chip) 4049ed030d7SWolfram Sang { 4059ed030d7SWolfram Sang const __be32 *val; 4069ed030d7SWolfram Sang struct device_node *node = client->dev.of_node; 4079ed030d7SWolfram Sang 4089ed030d7SWolfram Sang if (node) { 4099ed030d7SWolfram Sang if (of_get_property(node, "read-only", NULL)) 4109ed030d7SWolfram Sang chip->flags |= AT24_FLAG_READONLY; 4119ed030d7SWolfram Sang val = of_get_property(node, "pagesize", NULL); 4129ed030d7SWolfram Sang if (val) 4139ed030d7SWolfram Sang chip->page_size = be32_to_cpup(val); 4149ed030d7SWolfram Sang } 4159ed030d7SWolfram Sang } 4169ed030d7SWolfram Sang #else 4179ed030d7SWolfram Sang static void at24_get_ofdata(struct i2c_client *client, 4189ed030d7SWolfram Sang struct at24_platform_data *chip) 4199ed030d7SWolfram Sang { } 4209ed030d7SWolfram Sang #endif /* CONFIG_OF */ 4219ed030d7SWolfram Sang 4225195e509SWolfram Sang static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) 4235195e509SWolfram Sang { 4245195e509SWolfram Sang struct at24_platform_data chip; 42540d8edc9SAndy Shevchenko kernel_ulong_t magic = 0; 4265195e509SWolfram Sang bool writable; 4277aeb9664SJean Delvare int use_smbus = 0; 428a839ce66SChristian Gmeiner int use_smbus_write = 0; 4295195e509SWolfram Sang struct at24_data *at24; 4305195e509SWolfram Sang int err; 4315195e509SWolfram Sang unsigned i, num_addresses; 4325195e509SWolfram Sang 4335195e509SWolfram Sang if (client->dev.platform_data) { 4345195e509SWolfram Sang chip = *(struct at24_platform_data *)client->dev.platform_data; 4355195e509SWolfram Sang } else { 43640d8edc9SAndy Shevchenko if (id) { 43740d8edc9SAndy Shevchenko magic = id->driver_data; 43840d8edc9SAndy Shevchenko } else { 43940d8edc9SAndy Shevchenko const struct acpi_device_id *aid; 44040d8edc9SAndy Shevchenko 44140d8edc9SAndy Shevchenko aid = acpi_match_device(at24_acpi_ids, &client->dev); 44240d8edc9SAndy Shevchenko if (aid) 44340d8edc9SAndy Shevchenko magic = aid->driver_data; 44440d8edc9SAndy Shevchenko } 44540d8edc9SAndy Shevchenko if (!magic) 446f0ac2363SNikolay Balandin return -ENODEV; 447f0ac2363SNikolay Balandin 4485195e509SWolfram Sang chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN)); 4495195e509SWolfram Sang magic >>= AT24_SIZE_BYTELEN; 4505195e509SWolfram Sang chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS); 4515195e509SWolfram Sang /* 4525195e509SWolfram Sang * This is slow, but we can't know all eeproms, so we better 4535195e509SWolfram Sang * play safe. Specifying custom eeprom-types via platform_data 4545195e509SWolfram Sang * is recommended anyhow. 4555195e509SWolfram Sang */ 4565195e509SWolfram Sang chip.page_size = 1; 4577274ec8bSKevin Hilman 4589ed030d7SWolfram Sang /* update chipdata if OF is present */ 4599ed030d7SWolfram Sang at24_get_ofdata(client, &chip); 4609ed030d7SWolfram Sang 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"); 46845efe847SWolfram Sang if (!chip.page_size) { 46945efe847SWolfram Sang dev_err(&client->dev, "page_size must not be 0!\n"); 470f0ac2363SNikolay Balandin return -EINVAL; 47145efe847SWolfram Sang } 4725195e509SWolfram Sang if (!is_power_of_2(chip.page_size)) 4735195e509SWolfram Sang dev_warn(&client->dev, 4745195e509SWolfram Sang "page_size looks suspicious (no power of 2)!\n"); 4755195e509SWolfram Sang 4765195e509SWolfram Sang /* Use I2C operations unless we're stuck with SMBus extensions. */ 4775195e509SWolfram Sang if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 478f0ac2363SNikolay Balandin if (chip.flags & AT24_FLAG_ADDR16) 479f0ac2363SNikolay Balandin return -EPFNOSUPPORT; 480f0ac2363SNikolay Balandin 4817aeb9664SJean Delvare if (i2c_check_functionality(client->adapter, 4825195e509SWolfram Sang I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 4837aeb9664SJean Delvare use_smbus = I2C_SMBUS_I2C_BLOCK_DATA; 4847aeb9664SJean Delvare } else if (i2c_check_functionality(client->adapter, 4857aeb9664SJean Delvare I2C_FUNC_SMBUS_READ_WORD_DATA)) { 4867aeb9664SJean Delvare use_smbus = I2C_SMBUS_WORD_DATA; 4877aeb9664SJean Delvare } else if (i2c_check_functionality(client->adapter, 4887aeb9664SJean Delvare I2C_FUNC_SMBUS_READ_BYTE_DATA)) { 4897aeb9664SJean Delvare use_smbus = I2C_SMBUS_BYTE_DATA; 4907aeb9664SJean Delvare } else { 491f0ac2363SNikolay Balandin return -EPFNOSUPPORT; 4925195e509SWolfram Sang } 4935195e509SWolfram Sang 494a839ce66SChristian Gmeiner if (i2c_check_functionality(client->adapter, 495a839ce66SChristian Gmeiner I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { 496a839ce66SChristian Gmeiner use_smbus_write = I2C_SMBUS_I2C_BLOCK_DATA; 497a839ce66SChristian Gmeiner } else if (i2c_check_functionality(client->adapter, 498a839ce66SChristian Gmeiner I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) { 499a839ce66SChristian Gmeiner use_smbus_write = I2C_SMBUS_BYTE_DATA; 500a839ce66SChristian Gmeiner chip.page_size = 1; 501a839ce66SChristian Gmeiner } 502a839ce66SChristian Gmeiner } 503a839ce66SChristian Gmeiner 5045195e509SWolfram Sang if (chip.flags & AT24_FLAG_TAKE8ADDR) 5055195e509SWolfram Sang num_addresses = 8; 5065195e509SWolfram Sang else 5075195e509SWolfram Sang num_addresses = DIV_ROUND_UP(chip.byte_len, 5085195e509SWolfram Sang (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256); 5095195e509SWolfram Sang 510f0ac2363SNikolay Balandin at24 = devm_kzalloc(&client->dev, sizeof(struct at24_data) + 5115195e509SWolfram Sang num_addresses * sizeof(struct i2c_client *), GFP_KERNEL); 512f0ac2363SNikolay Balandin if (!at24) 513f0ac2363SNikolay Balandin return -ENOMEM; 5145195e509SWolfram Sang 5155195e509SWolfram Sang mutex_init(&at24->lock); 5165195e509SWolfram Sang at24->use_smbus = use_smbus; 517a839ce66SChristian Gmeiner at24->use_smbus_write = use_smbus_write; 5185195e509SWolfram Sang at24->chip = chip; 5195195e509SWolfram Sang at24->num_addresses = num_addresses; 5205195e509SWolfram Sang 5215195e509SWolfram Sang writable = !(chip.flags & AT24_FLAG_READONLY); 5225195e509SWolfram Sang if (writable) { 523a839ce66SChristian Gmeiner if (!use_smbus || use_smbus_write) { 5245195e509SWolfram Sang 5255195e509SWolfram Sang unsigned write_max = chip.page_size; 5265195e509SWolfram Sang 5275195e509SWolfram Sang if (write_max > io_limit) 5285195e509SWolfram Sang write_max = io_limit; 5295195e509SWolfram Sang if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX) 5305195e509SWolfram Sang write_max = I2C_SMBUS_BLOCK_MAX; 5315195e509SWolfram Sang at24->write_max = write_max; 5325195e509SWolfram Sang 5335195e509SWolfram Sang /* buffer (data + address at the beginning) */ 534f0ac2363SNikolay Balandin at24->writebuf = devm_kzalloc(&client->dev, 535f0ac2363SNikolay Balandin write_max + 2, GFP_KERNEL); 536f0ac2363SNikolay Balandin if (!at24->writebuf) 537f0ac2363SNikolay Balandin return -ENOMEM; 5385195e509SWolfram Sang } else { 5395195e509SWolfram Sang dev_warn(&client->dev, 5405195e509SWolfram Sang "cannot write due to controller restrictions."); 5415195e509SWolfram Sang } 5425195e509SWolfram Sang } 5435195e509SWolfram Sang 5445195e509SWolfram Sang at24->client[0] = client; 5455195e509SWolfram Sang 5465195e509SWolfram Sang /* use dummy devices for multiple-address chips */ 5475195e509SWolfram Sang for (i = 1; i < num_addresses; i++) { 5485195e509SWolfram Sang at24->client[i] = i2c_new_dummy(client->adapter, 5495195e509SWolfram Sang client->addr + i); 5505195e509SWolfram Sang if (!at24->client[i]) { 5515195e509SWolfram Sang dev_err(&client->dev, "address 0x%02x unavailable\n", 5525195e509SWolfram Sang client->addr + i); 5535195e509SWolfram Sang err = -EADDRINUSE; 5545195e509SWolfram Sang goto err_clients; 5555195e509SWolfram Sang } 5565195e509SWolfram Sang } 5575195e509SWolfram Sang 55857d15550SAndrew Lunn at24->nvmem_config.name = dev_name(&client->dev); 55957d15550SAndrew Lunn at24->nvmem_config.dev = &client->dev; 56057d15550SAndrew Lunn at24->nvmem_config.read_only = !writable; 56157d15550SAndrew Lunn at24->nvmem_config.root_only = true; 56257d15550SAndrew Lunn at24->nvmem_config.owner = THIS_MODULE; 56357d15550SAndrew Lunn at24->nvmem_config.compat = true; 56457d15550SAndrew Lunn at24->nvmem_config.base_dev = &client->dev; 565cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_read = at24_read; 566cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_write = at24_write; 567cf0361a2SSrinivas Kandagatla at24->nvmem_config.priv = at24; 568cf0361a2SSrinivas Kandagatla at24->nvmem_config.stride = 4; 569cf0361a2SSrinivas Kandagatla at24->nvmem_config.word_size = 1; 570cf0361a2SSrinivas Kandagatla at24->nvmem_config.size = chip.byte_len; 57157d15550SAndrew Lunn 57257d15550SAndrew Lunn at24->nvmem = nvmem_register(&at24->nvmem_config); 57357d15550SAndrew Lunn 57457d15550SAndrew Lunn if (IS_ERR(at24->nvmem)) { 57557d15550SAndrew Lunn err = PTR_ERR(at24->nvmem); 57657d15550SAndrew Lunn goto err_clients; 57757d15550SAndrew Lunn } 5785195e509SWolfram Sang 5795195e509SWolfram Sang i2c_set_clientdata(client, at24); 5805195e509SWolfram Sang 58157d15550SAndrew Lunn dev_info(&client->dev, "%u byte %s EEPROM, %s, %u bytes/write\n", 58257d15550SAndrew Lunn chip.byte_len, client->name, 5839ed030d7SWolfram Sang writable ? "writable" : "read-only", at24->write_max); 5847aeb9664SJean Delvare if (use_smbus == I2C_SMBUS_WORD_DATA || 5857aeb9664SJean Delvare use_smbus == I2C_SMBUS_BYTE_DATA) { 5867aeb9664SJean Delvare dev_notice(&client->dev, "Falling back to %s reads, " 5877aeb9664SJean Delvare "performance will suffer\n", use_smbus == 5887aeb9664SJean Delvare I2C_SMBUS_WORD_DATA ? "word" : "byte"); 5897aeb9664SJean Delvare } 5905195e509SWolfram Sang 5917274ec8bSKevin Hilman /* export data to kernel code */ 5927274ec8bSKevin Hilman if (chip.setup) 593bec3c11bSAndrew Lunn chip.setup(at24->nvmem, chip.context); 5947274ec8bSKevin Hilman 5955195e509SWolfram Sang return 0; 5965195e509SWolfram Sang 5975195e509SWolfram Sang err_clients: 5985195e509SWolfram Sang for (i = 1; i < num_addresses; i++) 5995195e509SWolfram Sang if (at24->client[i]) 6005195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 6015195e509SWolfram Sang 6025195e509SWolfram Sang return err; 6035195e509SWolfram Sang } 6045195e509SWolfram Sang 605486a5c28SBill Pemberton static int at24_remove(struct i2c_client *client) 6065195e509SWolfram Sang { 6075195e509SWolfram Sang struct at24_data *at24; 6085195e509SWolfram Sang int i; 6095195e509SWolfram Sang 6105195e509SWolfram Sang at24 = i2c_get_clientdata(client); 61157d15550SAndrew Lunn 61257d15550SAndrew Lunn nvmem_unregister(at24->nvmem); 6135195e509SWolfram Sang 6145195e509SWolfram Sang for (i = 1; i < at24->num_addresses; i++) 6155195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 6165195e509SWolfram Sang 6175195e509SWolfram Sang return 0; 6185195e509SWolfram Sang } 6195195e509SWolfram Sang 6205195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 6215195e509SWolfram Sang 6225195e509SWolfram Sang static struct i2c_driver at24_driver = { 6235195e509SWolfram Sang .driver = { 6245195e509SWolfram Sang .name = "at24", 62540d8edc9SAndy Shevchenko .acpi_match_table = ACPI_PTR(at24_acpi_ids), 6265195e509SWolfram Sang }, 6275195e509SWolfram Sang .probe = at24_probe, 6282d6bed9cSBill Pemberton .remove = at24_remove, 6295195e509SWolfram Sang .id_table = at24_ids, 6305195e509SWolfram Sang }; 6315195e509SWolfram Sang 6325195e509SWolfram Sang static int __init at24_init(void) 6335195e509SWolfram Sang { 63445efe847SWolfram Sang if (!io_limit) { 63545efe847SWolfram Sang pr_err("at24: io_limit must not be 0!\n"); 63645efe847SWolfram Sang return -EINVAL; 63745efe847SWolfram Sang } 63845efe847SWolfram Sang 6395195e509SWolfram Sang io_limit = rounddown_pow_of_two(io_limit); 6405195e509SWolfram Sang return i2c_add_driver(&at24_driver); 6415195e509SWolfram Sang } 6425195e509SWolfram Sang module_init(at24_init); 6435195e509SWolfram Sang 6445195e509SWolfram Sang static void __exit at24_exit(void) 6455195e509SWolfram Sang { 6465195e509SWolfram Sang i2c_del_driver(&at24_driver); 6475195e509SWolfram Sang } 6485195e509SWolfram Sang module_exit(at24_exit); 6495195e509SWolfram Sang 6505195e509SWolfram Sang MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); 6515195e509SWolfram Sang MODULE_AUTHOR("David Brownell and Wolfram Sang"); 6525195e509SWolfram Sang MODULE_LICENSE("GPL"); 653