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> 22dd905a61SBen Gardner #include <linux/property.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 11924da3cc0SBartosz Golaszewski * write to work while making sure that at least one iteration is run before 12024da3cc0SBartosz Golaszewski * checking the break condition. 1219344a81eSBartosz Golaszewski * 1229344a81eSBartosz Golaszewski * It takes two parameters: a variable in which the future timeout in jiffies 1239344a81eSBartosz Golaszewski * will be stored and a temporary variable holding the time of the last 1249344a81eSBartosz Golaszewski * iteration of processing the request. Both should be unsigned integers 1259344a81eSBartosz Golaszewski * holding at least 32 bits. 1269344a81eSBartosz Golaszewski */ 1279344a81eSBartosz Golaszewski #define loop_until_timeout(tout, op_time) \ 12824da3cc0SBartosz Golaszewski for (tout = jiffies + msecs_to_jiffies(write_timeout), op_time = 0; \ 12924da3cc0SBartosz Golaszewski op_time ? time_before(op_time, tout) : true; \ 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) }, 137818d0220SBartosz Golaszewski { "24cs01", AT24_DEVICE_MAGIC(16, 138818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1395195e509SWolfram Sang { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) }, 140818d0220SBartosz Golaszewski { "24cs02", AT24_DEVICE_MAGIC(16, 141818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1420b813658SBartosz Golaszewski { "24mac402", AT24_DEVICE_MAGIC(48 / 8, 1430b813658SBartosz Golaszewski AT24_FLAG_MAC | AT24_FLAG_READONLY) }, 1440b813658SBartosz Golaszewski { "24mac602", AT24_DEVICE_MAGIC(64 / 8, 1450b813658SBartosz Golaszewski AT24_FLAG_MAC | AT24_FLAG_READONLY) }, 1465195e509SWolfram Sang /* spd is a 24c02 in memory DIMMs */ 1475195e509SWolfram Sang { "spd", AT24_DEVICE_MAGIC(2048 / 8, 1485195e509SWolfram Sang AT24_FLAG_READONLY | AT24_FLAG_IRUGO) }, 1495195e509SWolfram Sang { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) }, 150818d0220SBartosz Golaszewski { "24cs04", AT24_DEVICE_MAGIC(16, 151818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1525195e509SWolfram Sang /* 24rf08 quirk is handled at i2c-core */ 1535195e509SWolfram Sang { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 154818d0220SBartosz Golaszewski { "24cs08", AT24_DEVICE_MAGIC(16, 155818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1565195e509SWolfram Sang { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) }, 157818d0220SBartosz Golaszewski { "24cs16", AT24_DEVICE_MAGIC(16, 158818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1595195e509SWolfram Sang { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) }, 160818d0220SBartosz Golaszewski { "24cs32", AT24_DEVICE_MAGIC(16, 161818d0220SBartosz Golaszewski AT24_FLAG_ADDR16 | 162818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | 163818d0220SBartosz Golaszewski AT24_FLAG_READONLY) }, 1645195e509SWolfram Sang { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) }, 165818d0220SBartosz Golaszewski { "24cs64", AT24_DEVICE_MAGIC(16, 166818d0220SBartosz Golaszewski AT24_FLAG_ADDR16 | 167818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | 168818d0220SBartosz Golaszewski AT24_FLAG_READONLY) }, 1695195e509SWolfram Sang { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) }, 1705195e509SWolfram Sang { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) }, 1715195e509SWolfram Sang { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) }, 1725195e509SWolfram Sang { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) }, 1735195e509SWolfram Sang { "at24", 0 }, 1745195e509SWolfram Sang { /* END OF LIST */ } 1755195e509SWolfram Sang }; 1765195e509SWolfram Sang MODULE_DEVICE_TABLE(i2c, at24_ids); 1775195e509SWolfram Sang 17840d8edc9SAndy Shevchenko static const struct acpi_device_id at24_acpi_ids[] = { 17940d8edc9SAndy Shevchenko { "INT3499", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 18040d8edc9SAndy Shevchenko { } 18140d8edc9SAndy Shevchenko }; 18240d8edc9SAndy Shevchenko MODULE_DEVICE_TABLE(acpi, at24_acpi_ids); 18340d8edc9SAndy Shevchenko 1845195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 1855195e509SWolfram Sang 1865195e509SWolfram Sang /* 1875195e509SWolfram Sang * This routine supports chips which consume multiple I2C addresses. It 1885195e509SWolfram Sang * computes the addressing information to be used for a given r/w request. 1895195e509SWolfram Sang * Assumes that sanity checks for offset happened at sysfs-layer. 1909afd6866SBartosz Golaszewski * 1919afd6866SBartosz Golaszewski * Slave address and byte offset derive from the offset. Always 1929afd6866SBartosz Golaszewski * set the byte address; on a multi-master board, another master 1939afd6866SBartosz Golaszewski * may have changed the chip's "current" address pointer. 1949afd6866SBartosz Golaszewski * 1959afd6866SBartosz Golaszewski * REVISIT some multi-address chips don't rollover page reads to 1969afd6866SBartosz Golaszewski * the next slave address, so we may need to truncate the count. 1979afd6866SBartosz Golaszewski * Those chips might need another quirk flag. 1989afd6866SBartosz Golaszewski * 1999afd6866SBartosz Golaszewski * If the real hardware used four adjacent 24c02 chips and that 2009afd6866SBartosz Golaszewski * were misconfigured as one 24c08, that would be a similar effect: 2019afd6866SBartosz Golaszewski * one "eeprom" file not four, but larger reads would fail when 2029afd6866SBartosz Golaszewski * they crossed certain pages. 2035195e509SWolfram Sang */ 2045195e509SWolfram Sang static struct i2c_client *at24_translate_offset(struct at24_data *at24, 2052da78ac3SBartosz Golaszewski unsigned int *offset) 2065195e509SWolfram Sang { 2075195e509SWolfram Sang unsigned i; 2085195e509SWolfram Sang 2095195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) { 2105195e509SWolfram Sang i = *offset >> 16; 2115195e509SWolfram Sang *offset &= 0xffff; 2125195e509SWolfram Sang } else { 2135195e509SWolfram Sang i = *offset >> 8; 2145195e509SWolfram Sang *offset &= 0xff; 2155195e509SWolfram Sang } 2165195e509SWolfram Sang 2175195e509SWolfram Sang return at24->client[i]; 2185195e509SWolfram Sang } 2195195e509SWolfram Sang 2209afd6866SBartosz Golaszewski static ssize_t at24_eeprom_read_smbus(struct at24_data *at24, char *buf, 2212da78ac3SBartosz Golaszewski unsigned int offset, size_t count) 2225195e509SWolfram Sang { 2234d29196cSWolfram Sang unsigned long timeout, read_time; 2249afd6866SBartosz Golaszewski struct i2c_client *client; 2259afd6866SBartosz Golaszewski int status; 2265195e509SWolfram Sang 2275195e509SWolfram Sang client = at24_translate_offset(at24, &offset); 2285195e509SWolfram Sang 2295195e509SWolfram Sang if (count > io_limit) 2305195e509SWolfram Sang count = io_limit; 2315195e509SWolfram Sang 2324d29196cSWolfram Sang /* Smaller eeproms can work given some SMBus extension calls */ 2335195e509SWolfram Sang if (count > I2C_SMBUS_BLOCK_MAX) 2345195e509SWolfram Sang count = I2C_SMBUS_BLOCK_MAX; 2359afd6866SBartosz Golaszewski 2369afd6866SBartosz Golaszewski loop_until_timeout(timeout, read_time) { 2379afd6866SBartosz Golaszewski status = i2c_smbus_read_i2c_block_data_or_emulated(client, 2389afd6866SBartosz Golaszewski offset, 2399afd6866SBartosz Golaszewski count, buf); 2409afd6866SBartosz Golaszewski 2419afd6866SBartosz Golaszewski dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 2429afd6866SBartosz Golaszewski count, offset, status, jiffies); 2439afd6866SBartosz Golaszewski 2449afd6866SBartosz Golaszewski if (status == count) 2459afd6866SBartosz Golaszewski return count; 2469afd6866SBartosz Golaszewski } 2479afd6866SBartosz Golaszewski 2489afd6866SBartosz Golaszewski return -ETIMEDOUT; 2499afd6866SBartosz Golaszewski } 2509afd6866SBartosz Golaszewski 2519afd6866SBartosz Golaszewski static ssize_t at24_eeprom_read_i2c(struct at24_data *at24, char *buf, 2529afd6866SBartosz Golaszewski unsigned int offset, size_t count) 2539afd6866SBartosz Golaszewski { 2549afd6866SBartosz Golaszewski unsigned long timeout, read_time; 2559afd6866SBartosz Golaszewski struct i2c_client *client; 2569afd6866SBartosz Golaszewski struct i2c_msg msg[2]; 2579afd6866SBartosz Golaszewski int status, i; 2589afd6866SBartosz Golaszewski u8 msgbuf[2]; 2599afd6866SBartosz Golaszewski 2609afd6866SBartosz Golaszewski memset(msg, 0, sizeof(msg)); 2619afd6866SBartosz Golaszewski client = at24_translate_offset(at24, &offset); 2629afd6866SBartosz Golaszewski 2639afd6866SBartosz Golaszewski if (count > io_limit) 2649afd6866SBartosz Golaszewski count = io_limit; 2659afd6866SBartosz Golaszewski 2665195e509SWolfram Sang /* 2679afd6866SBartosz Golaszewski * When we have a better choice than SMBus calls, use a combined I2C 2689afd6866SBartosz Golaszewski * message. Write address; then read up to io_limit data bytes. Note 2699afd6866SBartosz Golaszewski * that read page rollover helps us here (unlike writes). msgbuf is 2709afd6866SBartosz Golaszewski * u8 and will cast to our needs. 2715195e509SWolfram Sang */ 2725195e509SWolfram Sang i = 0; 2735195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 2745195e509SWolfram Sang msgbuf[i++] = offset >> 8; 2755195e509SWolfram Sang msgbuf[i++] = offset; 2765195e509SWolfram Sang 2775195e509SWolfram Sang msg[0].addr = client->addr; 2785195e509SWolfram Sang msg[0].buf = msgbuf; 2795195e509SWolfram Sang msg[0].len = i; 2805195e509SWolfram Sang 2815195e509SWolfram Sang msg[1].addr = client->addr; 2825195e509SWolfram Sang msg[1].flags = I2C_M_RD; 2835195e509SWolfram Sang msg[1].buf = buf; 2845195e509SWolfram Sang msg[1].len = count; 2855195e509SWolfram Sang 2869344a81eSBartosz Golaszewski loop_until_timeout(timeout, read_time) { 2875195e509SWolfram Sang status = i2c_transfer(client->adapter, msg, 2); 2885195e509SWolfram Sang if (status == 2) 2894d29196cSWolfram Sang status = count; 2909afd6866SBartosz Golaszewski 2914d29196cSWolfram Sang dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 2924d29196cSWolfram Sang count, offset, status, jiffies); 2934d29196cSWolfram Sang 2944d29196cSWolfram Sang if (status == count) 2955195e509SWolfram Sang return count; 2969344a81eSBartosz Golaszewski } 2974d29196cSWolfram Sang 2984d29196cSWolfram Sang return -ETIMEDOUT; 2995195e509SWolfram Sang } 3005195e509SWolfram Sang 301818d0220SBartosz Golaszewski static ssize_t at24_eeprom_read_serial(struct at24_data *at24, char *buf, 302818d0220SBartosz Golaszewski unsigned int offset, size_t count) 303818d0220SBartosz Golaszewski { 304818d0220SBartosz Golaszewski unsigned long timeout, read_time; 305818d0220SBartosz Golaszewski struct i2c_client *client; 306818d0220SBartosz Golaszewski struct i2c_msg msg[2]; 307818d0220SBartosz Golaszewski u8 addrbuf[2]; 308818d0220SBartosz Golaszewski int status; 309818d0220SBartosz Golaszewski 310818d0220SBartosz Golaszewski client = at24_translate_offset(at24, &offset); 311818d0220SBartosz Golaszewski 312818d0220SBartosz Golaszewski memset(msg, 0, sizeof(msg)); 313818d0220SBartosz Golaszewski msg[0].addr = client->addr; 314818d0220SBartosz Golaszewski msg[0].buf = addrbuf; 315818d0220SBartosz Golaszewski 316818d0220SBartosz Golaszewski /* 317818d0220SBartosz Golaszewski * The address pointer of the device is shared between the regular 318818d0220SBartosz Golaszewski * EEPROM array and the serial number block. The dummy write (part of 319818d0220SBartosz Golaszewski * the sequential read protocol) ensures the address pointer is reset 320818d0220SBartosz Golaszewski * to the desired position. 321818d0220SBartosz Golaszewski */ 322818d0220SBartosz Golaszewski if (at24->chip.flags & AT24_FLAG_ADDR16) { 323818d0220SBartosz Golaszewski /* 324818d0220SBartosz Golaszewski * For 16 bit address pointers, the word address must contain 325818d0220SBartosz Golaszewski * a '10' sequence in bits 11 and 10 regardless of the 326818d0220SBartosz Golaszewski * intended position of the address pointer. 327818d0220SBartosz Golaszewski */ 328818d0220SBartosz Golaszewski addrbuf[0] = 0x08; 329818d0220SBartosz Golaszewski addrbuf[1] = offset; 330818d0220SBartosz Golaszewski msg[0].len = 2; 331818d0220SBartosz Golaszewski } else { 332818d0220SBartosz Golaszewski /* 333818d0220SBartosz Golaszewski * Otherwise the word address must begin with a '10' sequence, 334818d0220SBartosz Golaszewski * regardless of the intended address. 335818d0220SBartosz Golaszewski */ 336818d0220SBartosz Golaszewski addrbuf[0] = 0x80 + offset; 337818d0220SBartosz Golaszewski msg[0].len = 1; 338818d0220SBartosz Golaszewski } 339818d0220SBartosz Golaszewski 340818d0220SBartosz Golaszewski msg[1].addr = client->addr; 341818d0220SBartosz Golaszewski msg[1].flags = I2C_M_RD; 342818d0220SBartosz Golaszewski msg[1].buf = buf; 343818d0220SBartosz Golaszewski msg[1].len = count; 344818d0220SBartosz Golaszewski 345818d0220SBartosz Golaszewski loop_until_timeout(timeout, read_time) { 346818d0220SBartosz Golaszewski status = i2c_transfer(client->adapter, msg, 2); 347818d0220SBartosz Golaszewski if (status == 2) 348818d0220SBartosz Golaszewski return count; 349818d0220SBartosz Golaszewski } 350818d0220SBartosz Golaszewski 351818d0220SBartosz Golaszewski return -ETIMEDOUT; 352818d0220SBartosz Golaszewski } 353818d0220SBartosz Golaszewski 3540b813658SBartosz Golaszewski static ssize_t at24_eeprom_read_mac(struct at24_data *at24, char *buf, 3550b813658SBartosz Golaszewski unsigned int offset, size_t count) 3560b813658SBartosz Golaszewski { 3570b813658SBartosz Golaszewski unsigned long timeout, read_time; 3580b813658SBartosz Golaszewski struct i2c_client *client; 3590b813658SBartosz Golaszewski struct i2c_msg msg[2]; 3600b813658SBartosz Golaszewski u8 addrbuf[2]; 3610b813658SBartosz Golaszewski int status; 3620b813658SBartosz Golaszewski 3630b813658SBartosz Golaszewski client = at24_translate_offset(at24, &offset); 3640b813658SBartosz Golaszewski 3650b813658SBartosz Golaszewski memset(msg, 0, sizeof(msg)); 3660b813658SBartosz Golaszewski msg[0].addr = client->addr; 3670b813658SBartosz Golaszewski msg[0].buf = addrbuf; 3680b813658SBartosz Golaszewski addrbuf[0] = 0x90 + offset; 3690b813658SBartosz Golaszewski msg[0].len = 1; 3700b813658SBartosz Golaszewski msg[1].addr = client->addr; 3710b813658SBartosz Golaszewski msg[1].flags = I2C_M_RD; 3720b813658SBartosz Golaszewski msg[1].buf = buf; 3730b813658SBartosz Golaszewski msg[1].len = count; 3740b813658SBartosz Golaszewski 3750b813658SBartosz Golaszewski loop_until_timeout(timeout, read_time) { 3760b813658SBartosz Golaszewski status = i2c_transfer(client->adapter, msg, 2); 3770b813658SBartosz Golaszewski if (status == 2) 3780b813658SBartosz Golaszewski return count; 3790b813658SBartosz Golaszewski } 3800b813658SBartosz Golaszewski 3810b813658SBartosz Golaszewski return -ETIMEDOUT; 3820b813658SBartosz Golaszewski } 3830b813658SBartosz Golaszewski 3845195e509SWolfram Sang /* 3855195e509SWolfram Sang * Note that if the hardware write-protect pin is pulled high, the whole 3865195e509SWolfram Sang * chip is normally write protected. But there are plenty of product 3875195e509SWolfram Sang * variants here, including OTP fuses and partial chip protect. 3885195e509SWolfram Sang * 389cd0c8615SBartosz Golaszewski * We only use page mode writes; the alternative is sloooow. These routines 390cd0c8615SBartosz Golaszewski * write at most one page. 3915195e509SWolfram Sang */ 392cd0c8615SBartosz Golaszewski 393cd0c8615SBartosz Golaszewski static size_t at24_adjust_write_count(struct at24_data *at24, 3942da78ac3SBartosz Golaszewski unsigned int offset, size_t count) 3955195e509SWolfram Sang { 3965195e509SWolfram Sang unsigned next_page; 3975195e509SWolfram Sang 3985195e509SWolfram Sang /* write_max is at most a page */ 3995195e509SWolfram Sang if (count > at24->write_max) 4005195e509SWolfram Sang count = at24->write_max; 4015195e509SWolfram Sang 4025195e509SWolfram Sang /* Never roll over backwards, to the start of this page */ 4035195e509SWolfram Sang next_page = roundup(offset + 1, at24->chip.page_size); 4045195e509SWolfram Sang if (offset + count > next_page) 4055195e509SWolfram Sang count = next_page - offset; 4065195e509SWolfram Sang 407cd0c8615SBartosz Golaszewski return count; 408cd0c8615SBartosz Golaszewski } 409cd0c8615SBartosz Golaszewski 410cd0c8615SBartosz Golaszewski static ssize_t at24_eeprom_write_smbus_block(struct at24_data *at24, 411cd0c8615SBartosz Golaszewski const char *buf, 412cd0c8615SBartosz Golaszewski unsigned int offset, size_t count) 413cd0c8615SBartosz Golaszewski { 414cd0c8615SBartosz Golaszewski unsigned long timeout, write_time; 415cd0c8615SBartosz Golaszewski struct i2c_client *client; 416cd0c8615SBartosz Golaszewski ssize_t status = 0; 417cd0c8615SBartosz Golaszewski 418cd0c8615SBartosz Golaszewski client = at24_translate_offset(at24, &offset); 419cd0c8615SBartosz Golaszewski count = at24_adjust_write_count(at24, offset, count); 420cd0c8615SBartosz Golaszewski 421cd0c8615SBartosz Golaszewski loop_until_timeout(timeout, write_time) { 422cd0c8615SBartosz Golaszewski status = i2c_smbus_write_i2c_block_data(client, 423cd0c8615SBartosz Golaszewski offset, count, buf); 424cd0c8615SBartosz Golaszewski if (status == 0) 425cd0c8615SBartosz Golaszewski status = count; 426cd0c8615SBartosz Golaszewski 427cd0c8615SBartosz Golaszewski dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n", 428cd0c8615SBartosz Golaszewski count, offset, status, jiffies); 429cd0c8615SBartosz Golaszewski 430cd0c8615SBartosz Golaszewski if (status == count) 431cd0c8615SBartosz Golaszewski return count; 432cd0c8615SBartosz Golaszewski } 433cd0c8615SBartosz Golaszewski 434cd0c8615SBartosz Golaszewski return -ETIMEDOUT; 435cd0c8615SBartosz Golaszewski } 436cd0c8615SBartosz Golaszewski 437cd0c8615SBartosz Golaszewski static ssize_t at24_eeprom_write_smbus_byte(struct at24_data *at24, 438cd0c8615SBartosz Golaszewski const char *buf, 439cd0c8615SBartosz Golaszewski unsigned int offset, size_t count) 440cd0c8615SBartosz Golaszewski { 441cd0c8615SBartosz Golaszewski unsigned long timeout, write_time; 442cd0c8615SBartosz Golaszewski struct i2c_client *client; 443cd0c8615SBartosz Golaszewski ssize_t status = 0; 444cd0c8615SBartosz Golaszewski 445cd0c8615SBartosz Golaszewski client = at24_translate_offset(at24, &offset); 446cd0c8615SBartosz Golaszewski 447cd0c8615SBartosz Golaszewski loop_until_timeout(timeout, write_time) { 448cd0c8615SBartosz Golaszewski status = i2c_smbus_write_byte_data(client, offset, buf[0]); 449cd0c8615SBartosz Golaszewski if (status == 0) 450cd0c8615SBartosz Golaszewski status = count; 451cd0c8615SBartosz Golaszewski 452cd0c8615SBartosz Golaszewski dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n", 453cd0c8615SBartosz Golaszewski count, offset, status, jiffies); 454cd0c8615SBartosz Golaszewski 455cd0c8615SBartosz Golaszewski if (status == count) 456cd0c8615SBartosz Golaszewski return count; 457cd0c8615SBartosz Golaszewski } 458cd0c8615SBartosz Golaszewski 459cd0c8615SBartosz Golaszewski return -ETIMEDOUT; 460cd0c8615SBartosz Golaszewski } 461cd0c8615SBartosz Golaszewski 462cd0c8615SBartosz Golaszewski static ssize_t at24_eeprom_write_i2c(struct at24_data *at24, const char *buf, 463cd0c8615SBartosz Golaszewski unsigned int offset, size_t count) 464cd0c8615SBartosz Golaszewski { 465cd0c8615SBartosz Golaszewski unsigned long timeout, write_time; 466cd0c8615SBartosz Golaszewski struct i2c_client *client; 467cd0c8615SBartosz Golaszewski struct i2c_msg msg; 468cd0c8615SBartosz Golaszewski ssize_t status = 0; 4695195e509SWolfram Sang int i = 0; 4705195e509SWolfram Sang 471cd0c8615SBartosz Golaszewski client = at24_translate_offset(at24, &offset); 472cd0c8615SBartosz Golaszewski count = at24_adjust_write_count(at24, offset, count); 473cd0c8615SBartosz Golaszewski 4745195e509SWolfram Sang msg.addr = client->addr; 4755195e509SWolfram Sang msg.flags = 0; 4765195e509SWolfram Sang 4775195e509SWolfram Sang /* msg.buf is u8 and casts will mask the values */ 4785195e509SWolfram Sang msg.buf = at24->writebuf; 4795195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) 4805195e509SWolfram Sang msg.buf[i++] = offset >> 8; 4815195e509SWolfram Sang 4825195e509SWolfram Sang msg.buf[i++] = offset; 4835195e509SWolfram Sang memcpy(&msg.buf[i], buf, count); 4845195e509SWolfram Sang msg.len = i + count; 4855195e509SWolfram Sang 4869344a81eSBartosz Golaszewski loop_until_timeout(timeout, write_time) { 4875195e509SWolfram Sang status = i2c_transfer(client->adapter, &msg, 1); 4885195e509SWolfram Sang if (status == 1) 4895195e509SWolfram Sang status = count; 490cd0c8615SBartosz Golaszewski 4915195e509SWolfram Sang dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n", 4925195e509SWolfram Sang count, offset, status, jiffies); 4935195e509SWolfram Sang 4945195e509SWolfram Sang if (status == count) 4955195e509SWolfram Sang return count; 4969344a81eSBartosz Golaszewski } 4975195e509SWolfram Sang 4985195e509SWolfram Sang return -ETIMEDOUT; 4995195e509SWolfram Sang } 5005195e509SWolfram Sang 501d5bc0047SBartosz Golaszewski static int at24_read(void *priv, unsigned int off, void *val, size_t count) 502d5bc0047SBartosz Golaszewski { 503d5bc0047SBartosz Golaszewski struct at24_data *at24 = priv; 504d5bc0047SBartosz Golaszewski char *buf = val; 505d5bc0047SBartosz Golaszewski 506d5bc0047SBartosz Golaszewski if (unlikely(!count)) 507d5bc0047SBartosz Golaszewski return count; 508d5bc0047SBartosz Golaszewski 509d5bc0047SBartosz Golaszewski /* 510d5bc0047SBartosz Golaszewski * Read data from chip, protecting against concurrent updates 511d5bc0047SBartosz Golaszewski * from this host, but not from other I2C masters. 512d5bc0047SBartosz Golaszewski */ 513d5bc0047SBartosz Golaszewski mutex_lock(&at24->lock); 514d5bc0047SBartosz Golaszewski 515d5bc0047SBartosz Golaszewski while (count) { 516d5bc0047SBartosz Golaszewski int status; 517d5bc0047SBartosz Golaszewski 518318aa9c6SBartosz Golaszewski status = at24->read_func(at24, buf, off, count); 519d5bc0047SBartosz Golaszewski if (status < 0) { 520d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 521d5bc0047SBartosz Golaszewski return status; 522d5bc0047SBartosz Golaszewski } 523d5bc0047SBartosz Golaszewski buf += status; 524d5bc0047SBartosz Golaszewski off += status; 525d5bc0047SBartosz Golaszewski count -= status; 526d5bc0047SBartosz Golaszewski } 527d5bc0047SBartosz Golaszewski 528d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 529d5bc0047SBartosz Golaszewski 530d5bc0047SBartosz Golaszewski return 0; 531d5bc0047SBartosz Golaszewski } 532d5bc0047SBartosz Golaszewski 533cf0361a2SSrinivas Kandagatla static int at24_write(void *priv, unsigned int off, void *val, size_t count) 5345195e509SWolfram Sang { 535cf0361a2SSrinivas Kandagatla struct at24_data *at24 = priv; 536cf0361a2SSrinivas Kandagatla char *buf = val; 5375195e509SWolfram Sang 5385195e509SWolfram Sang if (unlikely(!count)) 539cf0361a2SSrinivas Kandagatla return -EINVAL; 5405195e509SWolfram Sang 5415195e509SWolfram Sang /* 5425195e509SWolfram Sang * Write data to chip, protecting against concurrent updates 5435195e509SWolfram Sang * from this host, but not from other I2C masters. 5445195e509SWolfram Sang */ 5455195e509SWolfram Sang mutex_lock(&at24->lock); 5465195e509SWolfram Sang 5475195e509SWolfram Sang while (count) { 548cf0361a2SSrinivas Kandagatla int status; 5495195e509SWolfram Sang 550318aa9c6SBartosz Golaszewski status = at24->write_func(at24, buf, off, count); 551cf0361a2SSrinivas Kandagatla if (status < 0) { 552cf0361a2SSrinivas Kandagatla mutex_unlock(&at24->lock); 553cf0361a2SSrinivas Kandagatla return status; 5545195e509SWolfram Sang } 5555195e509SWolfram Sang buf += status; 5565195e509SWolfram Sang off += status; 5575195e509SWolfram Sang count -= status; 5585195e509SWolfram Sang } 5595195e509SWolfram Sang 5605195e509SWolfram Sang mutex_unlock(&at24->lock); 5615195e509SWolfram Sang 56257d15550SAndrew Lunn return 0; 56357d15550SAndrew Lunn } 56457d15550SAndrew Lunn 565dd905a61SBen Gardner static void at24_get_pdata(struct device *dev, struct at24_platform_data *chip) 5669ed030d7SWolfram Sang { 567dd905a61SBen Gardner int err; 568dd905a61SBen Gardner u32 val; 5699ed030d7SWolfram Sang 570dd905a61SBen Gardner if (device_property_present(dev, "read-only")) 5719ed030d7SWolfram Sang chip->flags |= AT24_FLAG_READONLY; 572dd905a61SBen Gardner 573dbc1ab9cSDivagar Mohandass err = device_property_read_u32(dev, "size", &val); 574dbc1ab9cSDivagar Mohandass if (!err) 575dbc1ab9cSDivagar Mohandass chip->byte_len = val; 576dbc1ab9cSDivagar Mohandass 577dd905a61SBen Gardner err = device_property_read_u32(dev, "pagesize", &val); 578dd905a61SBen Gardner if (!err) { 579dd905a61SBen Gardner chip->page_size = val; 580dd905a61SBen Gardner } else { 581dd905a61SBen Gardner /* 582dd905a61SBen Gardner * This is slow, but we can't know all eeproms, so we better 583dd905a61SBen Gardner * play safe. Specifying custom eeprom-types via platform_data 584dd905a61SBen Gardner * is recommended anyhow. 585dd905a61SBen Gardner */ 586dd905a61SBen Gardner chip->page_size = 1; 5879ed030d7SWolfram Sang } 5889ed030d7SWolfram Sang } 5899ed030d7SWolfram Sang 5905195e509SWolfram Sang static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) 5915195e509SWolfram Sang { 5925195e509SWolfram Sang struct at24_platform_data chip; 59340d8edc9SAndy Shevchenko kernel_ulong_t magic = 0; 5945195e509SWolfram Sang bool writable; 5957aeb9664SJean Delvare int use_smbus = 0; 596a839ce66SChristian Gmeiner int use_smbus_write = 0; 5975195e509SWolfram Sang struct at24_data *at24; 5985195e509SWolfram Sang int err; 5995195e509SWolfram Sang unsigned i, num_addresses; 60000f0ea70SBartosz Golaszewski u8 test_byte; 6015195e509SWolfram Sang 6025195e509SWolfram Sang if (client->dev.platform_data) { 6035195e509SWolfram Sang chip = *(struct at24_platform_data *)client->dev.platform_data; 6045195e509SWolfram Sang } else { 60540d8edc9SAndy Shevchenko if (id) { 60640d8edc9SAndy Shevchenko magic = id->driver_data; 60740d8edc9SAndy Shevchenko } else { 60840d8edc9SAndy Shevchenko const struct acpi_device_id *aid; 60940d8edc9SAndy Shevchenko 61040d8edc9SAndy Shevchenko aid = acpi_match_device(at24_acpi_ids, &client->dev); 61140d8edc9SAndy Shevchenko if (aid) 61240d8edc9SAndy Shevchenko magic = aid->driver_data; 61340d8edc9SAndy Shevchenko } 61440d8edc9SAndy Shevchenko if (!magic) 615f0ac2363SNikolay Balandin return -ENODEV; 616f0ac2363SNikolay Balandin 6175195e509SWolfram Sang chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN)); 6185195e509SWolfram Sang magic >>= AT24_SIZE_BYTELEN; 6195195e509SWolfram Sang chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS); 6207274ec8bSKevin Hilman 621dd905a61SBen Gardner at24_get_pdata(&client->dev, &chip); 6229ed030d7SWolfram Sang 6237274ec8bSKevin Hilman chip.setup = NULL; 6247274ec8bSKevin Hilman chip.context = NULL; 6255195e509SWolfram Sang } 6265195e509SWolfram Sang 6275195e509SWolfram Sang if (!is_power_of_2(chip.byte_len)) 6285195e509SWolfram Sang dev_warn(&client->dev, 6295195e509SWolfram Sang "byte_len looks suspicious (no power of 2)!\n"); 63045efe847SWolfram Sang if (!chip.page_size) { 63145efe847SWolfram Sang dev_err(&client->dev, "page_size must not be 0!\n"); 632f0ac2363SNikolay Balandin return -EINVAL; 63345efe847SWolfram Sang } 6345195e509SWolfram Sang if (!is_power_of_2(chip.page_size)) 6355195e509SWolfram Sang dev_warn(&client->dev, 6365195e509SWolfram Sang "page_size looks suspicious (no power of 2)!\n"); 6375195e509SWolfram Sang 6385195e509SWolfram Sang /* Use I2C operations unless we're stuck with SMBus extensions. */ 6395195e509SWolfram Sang if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 640f0ac2363SNikolay Balandin if (chip.flags & AT24_FLAG_ADDR16) 641f0ac2363SNikolay Balandin return -EPFNOSUPPORT; 642f0ac2363SNikolay Balandin 6437aeb9664SJean Delvare if (i2c_check_functionality(client->adapter, 6445195e509SWolfram Sang I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 6457aeb9664SJean Delvare use_smbus = I2C_SMBUS_I2C_BLOCK_DATA; 6467aeb9664SJean Delvare } else if (i2c_check_functionality(client->adapter, 6477aeb9664SJean Delvare I2C_FUNC_SMBUS_READ_WORD_DATA)) { 6487aeb9664SJean Delvare use_smbus = I2C_SMBUS_WORD_DATA; 6497aeb9664SJean Delvare } else if (i2c_check_functionality(client->adapter, 6507aeb9664SJean Delvare I2C_FUNC_SMBUS_READ_BYTE_DATA)) { 6517aeb9664SJean Delvare use_smbus = I2C_SMBUS_BYTE_DATA; 6527aeb9664SJean Delvare } else { 653f0ac2363SNikolay Balandin return -EPFNOSUPPORT; 6545195e509SWolfram Sang } 6555195e509SWolfram Sang 656a839ce66SChristian Gmeiner if (i2c_check_functionality(client->adapter, 657a839ce66SChristian Gmeiner I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { 658a839ce66SChristian Gmeiner use_smbus_write = I2C_SMBUS_I2C_BLOCK_DATA; 659a839ce66SChristian Gmeiner } else if (i2c_check_functionality(client->adapter, 660a839ce66SChristian Gmeiner I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) { 661a839ce66SChristian Gmeiner use_smbus_write = I2C_SMBUS_BYTE_DATA; 662a839ce66SChristian Gmeiner chip.page_size = 1; 663a839ce66SChristian Gmeiner } 664a839ce66SChristian Gmeiner } 665a839ce66SChristian Gmeiner 6665195e509SWolfram Sang if (chip.flags & AT24_FLAG_TAKE8ADDR) 6675195e509SWolfram Sang num_addresses = 8; 6685195e509SWolfram Sang else 6695195e509SWolfram Sang num_addresses = DIV_ROUND_UP(chip.byte_len, 6705195e509SWolfram Sang (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256); 6715195e509SWolfram Sang 672f0ac2363SNikolay Balandin at24 = devm_kzalloc(&client->dev, sizeof(struct at24_data) + 6735195e509SWolfram Sang num_addresses * sizeof(struct i2c_client *), GFP_KERNEL); 674f0ac2363SNikolay Balandin if (!at24) 675f0ac2363SNikolay Balandin return -ENOMEM; 6765195e509SWolfram Sang 6775195e509SWolfram Sang mutex_init(&at24->lock); 6785195e509SWolfram Sang at24->use_smbus = use_smbus; 679a839ce66SChristian Gmeiner at24->use_smbus_write = use_smbus_write; 6805195e509SWolfram Sang at24->chip = chip; 6815195e509SWolfram Sang at24->num_addresses = num_addresses; 6825195e509SWolfram Sang 6830b813658SBartosz Golaszewski if ((chip.flags & AT24_FLAG_SERIAL) && (chip.flags & AT24_FLAG_MAC)) { 6840b813658SBartosz Golaszewski dev_err(&client->dev, 6850b813658SBartosz Golaszewski "invalid device data - cannot have both AT24_FLAG_SERIAL & AT24_FLAG_MAC."); 6860b813658SBartosz Golaszewski return -EINVAL; 6870b813658SBartosz Golaszewski } 6880b813658SBartosz Golaszewski 689818d0220SBartosz Golaszewski if (chip.flags & AT24_FLAG_SERIAL) { 690818d0220SBartosz Golaszewski at24->read_func = at24_eeprom_read_serial; 6910b813658SBartosz Golaszewski } else if (chip.flags & AT24_FLAG_MAC) { 6920b813658SBartosz Golaszewski at24->read_func = at24_eeprom_read_mac; 693818d0220SBartosz Golaszewski } else { 6949afd6866SBartosz Golaszewski at24->read_func = at24->use_smbus ? at24_eeprom_read_smbus 6959afd6866SBartosz Golaszewski : at24_eeprom_read_i2c; 696818d0220SBartosz Golaszewski } 697818d0220SBartosz Golaszewski 698cd0c8615SBartosz Golaszewski if (at24->use_smbus) { 699cd0c8615SBartosz Golaszewski if (at24->use_smbus_write == I2C_SMBUS_I2C_BLOCK_DATA) 700cd0c8615SBartosz Golaszewski at24->write_func = at24_eeprom_write_smbus_block; 701cd0c8615SBartosz Golaszewski else 702cd0c8615SBartosz Golaszewski at24->write_func = at24_eeprom_write_smbus_byte; 703cd0c8615SBartosz Golaszewski } else { 704cd0c8615SBartosz Golaszewski at24->write_func = at24_eeprom_write_i2c; 705cd0c8615SBartosz Golaszewski } 706318aa9c6SBartosz Golaszewski 7075195e509SWolfram Sang writable = !(chip.flags & AT24_FLAG_READONLY); 7085195e509SWolfram Sang if (writable) { 709a839ce66SChristian Gmeiner if (!use_smbus || use_smbus_write) { 7105195e509SWolfram Sang 7115195e509SWolfram Sang unsigned write_max = chip.page_size; 7125195e509SWolfram Sang 7135195e509SWolfram Sang if (write_max > io_limit) 7145195e509SWolfram Sang write_max = io_limit; 7155195e509SWolfram Sang if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX) 7165195e509SWolfram Sang write_max = I2C_SMBUS_BLOCK_MAX; 7175195e509SWolfram Sang at24->write_max = write_max; 7185195e509SWolfram Sang 7195195e509SWolfram Sang /* buffer (data + address at the beginning) */ 720f0ac2363SNikolay Balandin at24->writebuf = devm_kzalloc(&client->dev, 721f0ac2363SNikolay Balandin write_max + 2, GFP_KERNEL); 722f0ac2363SNikolay Balandin if (!at24->writebuf) 723f0ac2363SNikolay Balandin return -ENOMEM; 7245195e509SWolfram Sang } else { 7255195e509SWolfram Sang dev_warn(&client->dev, 7265195e509SWolfram Sang "cannot write due to controller restrictions."); 7275195e509SWolfram Sang } 7285195e509SWolfram Sang } 7295195e509SWolfram Sang 7305195e509SWolfram Sang at24->client[0] = client; 7315195e509SWolfram Sang 7325195e509SWolfram Sang /* use dummy devices for multiple-address chips */ 7335195e509SWolfram Sang for (i = 1; i < num_addresses; i++) { 7345195e509SWolfram Sang at24->client[i] = i2c_new_dummy(client->adapter, 7355195e509SWolfram Sang client->addr + i); 7365195e509SWolfram Sang if (!at24->client[i]) { 7375195e509SWolfram Sang dev_err(&client->dev, "address 0x%02x unavailable\n", 7385195e509SWolfram Sang client->addr + i); 7395195e509SWolfram Sang err = -EADDRINUSE; 7405195e509SWolfram Sang goto err_clients; 7415195e509SWolfram Sang } 7425195e509SWolfram Sang } 7435195e509SWolfram Sang 74400f0ea70SBartosz Golaszewski i2c_set_clientdata(client, at24); 74500f0ea70SBartosz Golaszewski 74600f0ea70SBartosz Golaszewski /* 74700f0ea70SBartosz Golaszewski * Perform a one-byte test read to verify that the 74800f0ea70SBartosz Golaszewski * chip is functional. 74900f0ea70SBartosz Golaszewski */ 75000f0ea70SBartosz Golaszewski err = at24_read(at24, 0, &test_byte, 1); 75100f0ea70SBartosz Golaszewski if (err) { 75200f0ea70SBartosz Golaszewski err = -ENODEV; 75300f0ea70SBartosz Golaszewski goto err_clients; 75400f0ea70SBartosz Golaszewski } 75500f0ea70SBartosz Golaszewski 75657d15550SAndrew Lunn at24->nvmem_config.name = dev_name(&client->dev); 75757d15550SAndrew Lunn at24->nvmem_config.dev = &client->dev; 75857d15550SAndrew Lunn at24->nvmem_config.read_only = !writable; 75957d15550SAndrew Lunn at24->nvmem_config.root_only = true; 76057d15550SAndrew Lunn at24->nvmem_config.owner = THIS_MODULE; 76157d15550SAndrew Lunn at24->nvmem_config.compat = true; 76257d15550SAndrew Lunn at24->nvmem_config.base_dev = &client->dev; 763cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_read = at24_read; 764cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_write = at24_write; 765cf0361a2SSrinivas Kandagatla at24->nvmem_config.priv = at24; 766cf0361a2SSrinivas Kandagatla at24->nvmem_config.stride = 4; 767cf0361a2SSrinivas Kandagatla at24->nvmem_config.word_size = 1; 768cf0361a2SSrinivas Kandagatla at24->nvmem_config.size = chip.byte_len; 76957d15550SAndrew Lunn 77057d15550SAndrew Lunn at24->nvmem = nvmem_register(&at24->nvmem_config); 77157d15550SAndrew Lunn 77257d15550SAndrew Lunn if (IS_ERR(at24->nvmem)) { 77357d15550SAndrew Lunn err = PTR_ERR(at24->nvmem); 77457d15550SAndrew Lunn goto err_clients; 77557d15550SAndrew Lunn } 7765195e509SWolfram Sang 77757d15550SAndrew Lunn dev_info(&client->dev, "%u byte %s EEPROM, %s, %u bytes/write\n", 77857d15550SAndrew Lunn chip.byte_len, client->name, 7799ed030d7SWolfram Sang writable ? "writable" : "read-only", at24->write_max); 7807aeb9664SJean Delvare if (use_smbus == I2C_SMBUS_WORD_DATA || 7817aeb9664SJean Delvare use_smbus == I2C_SMBUS_BYTE_DATA) { 7827aeb9664SJean Delvare dev_notice(&client->dev, "Falling back to %s reads, " 7837aeb9664SJean Delvare "performance will suffer\n", use_smbus == 7847aeb9664SJean Delvare I2C_SMBUS_WORD_DATA ? "word" : "byte"); 7857aeb9664SJean Delvare } 7865195e509SWolfram Sang 7877274ec8bSKevin Hilman /* export data to kernel code */ 7887274ec8bSKevin Hilman if (chip.setup) 789bec3c11bSAndrew Lunn chip.setup(at24->nvmem, chip.context); 7907274ec8bSKevin Hilman 7915195e509SWolfram Sang return 0; 7925195e509SWolfram Sang 7935195e509SWolfram Sang err_clients: 7945195e509SWolfram Sang for (i = 1; i < num_addresses; i++) 7955195e509SWolfram Sang if (at24->client[i]) 7965195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 7975195e509SWolfram Sang 7985195e509SWolfram Sang return err; 7995195e509SWolfram Sang } 8005195e509SWolfram Sang 801486a5c28SBill Pemberton static int at24_remove(struct i2c_client *client) 8025195e509SWolfram Sang { 8035195e509SWolfram Sang struct at24_data *at24; 8045195e509SWolfram Sang int i; 8055195e509SWolfram Sang 8065195e509SWolfram Sang at24 = i2c_get_clientdata(client); 80757d15550SAndrew Lunn 80857d15550SAndrew Lunn nvmem_unregister(at24->nvmem); 8095195e509SWolfram Sang 8105195e509SWolfram Sang for (i = 1; i < at24->num_addresses; i++) 8115195e509SWolfram Sang i2c_unregister_device(at24->client[i]); 8125195e509SWolfram Sang 8135195e509SWolfram Sang return 0; 8145195e509SWolfram Sang } 8155195e509SWolfram Sang 8165195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 8175195e509SWolfram Sang 8185195e509SWolfram Sang static struct i2c_driver at24_driver = { 8195195e509SWolfram Sang .driver = { 8205195e509SWolfram Sang .name = "at24", 82140d8edc9SAndy Shevchenko .acpi_match_table = ACPI_PTR(at24_acpi_ids), 8225195e509SWolfram Sang }, 8235195e509SWolfram Sang .probe = at24_probe, 8242d6bed9cSBill Pemberton .remove = at24_remove, 8255195e509SWolfram Sang .id_table = at24_ids, 8265195e509SWolfram Sang }; 8275195e509SWolfram Sang 8285195e509SWolfram Sang static int __init at24_init(void) 8295195e509SWolfram Sang { 83045efe847SWolfram Sang if (!io_limit) { 83145efe847SWolfram Sang pr_err("at24: io_limit must not be 0!\n"); 83245efe847SWolfram Sang return -EINVAL; 83345efe847SWolfram Sang } 83445efe847SWolfram Sang 8355195e509SWolfram Sang io_limit = rounddown_pow_of_two(io_limit); 8365195e509SWolfram Sang return i2c_add_driver(&at24_driver); 8375195e509SWolfram Sang } 8385195e509SWolfram Sang module_init(at24_init); 8395195e509SWolfram Sang 8405195e509SWolfram Sang static void __exit at24_exit(void) 8415195e509SWolfram Sang { 8425195e509SWolfram Sang i2c_del_driver(&at24_driver); 8435195e509SWolfram Sang } 8445195e509SWolfram Sang module_exit(at24_exit); 8455195e509SWolfram Sang 8465195e509SWolfram Sang MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); 8475195e509SWolfram Sang MODULE_AUTHOR("David Brownell and Wolfram Sang"); 8485195e509SWolfram Sang MODULE_LICENSE("GPL"); 849