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> 157f2a2f0dSJavier Martinez Canillas #include <linux/of_device.h> 165195e509SWolfram Sang #include <linux/slab.h> 175195e509SWolfram Sang #include <linux/delay.h> 185195e509SWolfram Sang #include <linux/mutex.h> 195195e509SWolfram Sang #include <linux/mod_devicetable.h> 205195e509SWolfram Sang #include <linux/log2.h> 215195e509SWolfram Sang #include <linux/bitops.h> 225195e509SWolfram Sang #include <linux/jiffies.h> 23dd905a61SBen Gardner #include <linux/property.h> 2440d8edc9SAndy Shevchenko #include <linux/acpi.h> 255195e509SWolfram Sang #include <linux/i2c.h> 2657d15550SAndrew Lunn #include <linux/nvmem-provider.h> 275c015258SHeiner Kallweit #include <linux/regmap.h> 2825f73ed5SVivien Didelot #include <linux/platform_data/at24.h> 2998e82010SDivagar Mohandass #include <linux/pm_runtime.h> 305195e509SWolfram Sang 315195e509SWolfram Sang /* 325195e509SWolfram Sang * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable. 335195e509SWolfram Sang * Differences between different vendor product lines (like Atmel AT24C or 345195e509SWolfram Sang * MicroChip 24LC, etc) won't much matter for typical read/write access. 355195e509SWolfram Sang * There are also I2C RAM chips, likewise interchangeable. One example 365195e509SWolfram Sang * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes). 375195e509SWolfram Sang * 385195e509SWolfram Sang * However, misconfiguration can lose data. "Set 16-bit memory address" 395195e509SWolfram Sang * to a part with 8-bit addressing will overwrite data. Writing with too 405195e509SWolfram Sang * big a page size also loses data. And it's not safe to assume that the 415195e509SWolfram Sang * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC 425195e509SWolfram Sang * uses 0x51, for just one example. 435195e509SWolfram Sang * 445195e509SWolfram Sang * Accordingly, explicit board-specific configuration data should be used 455195e509SWolfram Sang * in almost all cases. (One partial exception is an SMBus used to access 465195e509SWolfram Sang * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.) 475195e509SWolfram Sang * 485195e509SWolfram Sang * So this driver uses "new style" I2C driver binding, expecting to be 495195e509SWolfram Sang * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or 505195e509SWolfram Sang * similar kernel-resident tables; or, configuration data coming from 515195e509SWolfram Sang * a bootloader. 525195e509SWolfram Sang * 535195e509SWolfram Sang * Other than binding model, current differences from "eeprom" driver are 545195e509SWolfram Sang * that this one handles write access and isn't restricted to 24c02 devices. 555195e509SWolfram Sang * It also handles larger devices (32 kbit and up) with two-byte addresses, 565195e509SWolfram Sang * which won't work on pure SMBus systems. 575195e509SWolfram Sang */ 585195e509SWolfram Sang 595c015258SHeiner Kallweit struct at24_client { 605c015258SHeiner Kallweit struct i2c_client *client; 615c015258SHeiner Kallweit struct regmap *regmap; 625c015258SHeiner Kallweit }; 635c015258SHeiner Kallweit 645195e509SWolfram Sang struct at24_data { 655195e509SWolfram Sang struct at24_platform_data chip; 66318aa9c6SBartosz Golaszewski 675195e509SWolfram Sang /* 685195e509SWolfram Sang * Lock protects against activities from other Linux tasks, 695195e509SWolfram Sang * but not from changes by other I2C masters. 705195e509SWolfram Sang */ 715195e509SWolfram Sang struct mutex lock; 725195e509SWolfram Sang 73aa4ce228SBartosz Golaszewski unsigned int write_max; 74aa4ce228SBartosz Golaszewski unsigned int num_addresses; 754bb5c13cSHeiner Kallweit unsigned int offset_adj; 765195e509SWolfram Sang 7757d15550SAndrew Lunn struct nvmem_config nvmem_config; 7857d15550SAndrew Lunn struct nvmem_device *nvmem; 7957d15550SAndrew Lunn 805195e509SWolfram Sang /* 815195e509SWolfram Sang * Some chips tie up multiple I2C addresses; dummy devices reserve 825195e509SWolfram Sang * them for us, and we'll use them with SMBus calls. 835195e509SWolfram Sang */ 845c015258SHeiner Kallweit struct at24_client client[]; 855195e509SWolfram Sang }; 865195e509SWolfram Sang 875195e509SWolfram Sang /* 885195e509SWolfram Sang * This parameter is to help this driver avoid blocking other drivers out 895195e509SWolfram Sang * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C 905195e509SWolfram Sang * clock, one 256 byte read takes about 1/43 second which is excessive; 915195e509SWolfram Sang * but the 1/170 second it takes at 400 kHz may be quite reasonable; and 925195e509SWolfram Sang * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible. 935195e509SWolfram Sang * 945195e509SWolfram Sang * This value is forced to be a power of two so that writes align on pages. 955195e509SWolfram Sang */ 96aa4ce228SBartosz Golaszewski static unsigned int io_limit = 128; 975195e509SWolfram Sang module_param(io_limit, uint, 0); 985195e509SWolfram Sang MODULE_PARM_DESC(io_limit, "Maximum bytes per I/O (default 128)"); 995195e509SWolfram Sang 1005195e509SWolfram Sang /* 1015195e509SWolfram Sang * Specs often allow 5 msec for a page write, sometimes 20 msec; 1025195e509SWolfram Sang * it's important to recover from write timeouts. 1035195e509SWolfram Sang */ 104aa4ce228SBartosz Golaszewski static unsigned int write_timeout = 25; 1055195e509SWolfram Sang module_param(write_timeout, uint, 0); 1065195e509SWolfram Sang MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)"); 1075195e509SWolfram Sang 1085195e509SWolfram Sang #define AT24_SIZE_BYTELEN 5 1095195e509SWolfram Sang #define AT24_SIZE_FLAGS 8 1105195e509SWolfram Sang 1115195e509SWolfram Sang #define AT24_BITMASK(x) (BIT(x) - 1) 1125195e509SWolfram Sang 1135195e509SWolfram Sang /* create non-zero magic value for given eeprom parameters */ 1145195e509SWolfram Sang #define AT24_DEVICE_MAGIC(_len, _flags) \ 1155195e509SWolfram Sang ((1 << AT24_SIZE_FLAGS | (_flags)) \ 1165195e509SWolfram Sang << AT24_SIZE_BYTELEN | ilog2(_len)) 1175195e509SWolfram Sang 1189344a81eSBartosz Golaszewski /* 1199344a81eSBartosz Golaszewski * Both reads and writes fail if the previous write didn't complete yet. This 1209344a81eSBartosz Golaszewski * macro loops a few times waiting at least long enough for one entire page 12124da3cc0SBartosz Golaszewski * write to work while making sure that at least one iteration is run before 12224da3cc0SBartosz Golaszewski * checking the break condition. 1239344a81eSBartosz Golaszewski * 1249344a81eSBartosz Golaszewski * It takes two parameters: a variable in which the future timeout in jiffies 1259344a81eSBartosz Golaszewski * will be stored and a temporary variable holding the time of the last 1269344a81eSBartosz Golaszewski * iteration of processing the request. Both should be unsigned integers 1279344a81eSBartosz Golaszewski * holding at least 32 bits. 1289344a81eSBartosz Golaszewski */ 1299344a81eSBartosz Golaszewski #define loop_until_timeout(tout, op_time) \ 13024da3cc0SBartosz Golaszewski for (tout = jiffies + msecs_to_jiffies(write_timeout), op_time = 0; \ 13124da3cc0SBartosz Golaszewski op_time ? time_before(op_time, tout) : true; \ 1329344a81eSBartosz Golaszewski usleep_range(1000, 1500), op_time = jiffies) 1339344a81eSBartosz Golaszewski 1345195e509SWolfram Sang static const struct i2c_device_id at24_ids[] = { 1355195e509SWolfram Sang /* needs 8 addresses as A0-A2 are ignored */ 1365195e509SWolfram Sang { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) }, 1375195e509SWolfram Sang /* old variants can't be handled with this generic entry! */ 1385195e509SWolfram Sang { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) }, 139818d0220SBartosz Golaszewski { "24cs01", AT24_DEVICE_MAGIC(16, 140818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1415195e509SWolfram Sang { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) }, 142818d0220SBartosz Golaszewski { "24cs02", AT24_DEVICE_MAGIC(16, 143818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1440b813658SBartosz Golaszewski { "24mac402", AT24_DEVICE_MAGIC(48 / 8, 1450b813658SBartosz Golaszewski AT24_FLAG_MAC | AT24_FLAG_READONLY) }, 1460b813658SBartosz Golaszewski { "24mac602", AT24_DEVICE_MAGIC(64 / 8, 1470b813658SBartosz Golaszewski AT24_FLAG_MAC | AT24_FLAG_READONLY) }, 1485195e509SWolfram Sang /* spd is a 24c02 in memory DIMMs */ 1495195e509SWolfram Sang { "spd", AT24_DEVICE_MAGIC(2048 / 8, 1505195e509SWolfram Sang AT24_FLAG_READONLY | AT24_FLAG_IRUGO) }, 1515195e509SWolfram Sang { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) }, 152818d0220SBartosz Golaszewski { "24cs04", AT24_DEVICE_MAGIC(16, 153818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1545195e509SWolfram Sang /* 24rf08 quirk is handled at i2c-core */ 1555195e509SWolfram Sang { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 156818d0220SBartosz Golaszewski { "24cs08", AT24_DEVICE_MAGIC(16, 157818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1585195e509SWolfram Sang { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) }, 159818d0220SBartosz Golaszewski { "24cs16", AT24_DEVICE_MAGIC(16, 160818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | AT24_FLAG_READONLY) }, 1615195e509SWolfram Sang { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) }, 162818d0220SBartosz Golaszewski { "24cs32", AT24_DEVICE_MAGIC(16, 163818d0220SBartosz Golaszewski AT24_FLAG_ADDR16 | 164818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | 165818d0220SBartosz Golaszewski AT24_FLAG_READONLY) }, 1665195e509SWolfram Sang { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) }, 167818d0220SBartosz Golaszewski { "24cs64", AT24_DEVICE_MAGIC(16, 168818d0220SBartosz Golaszewski AT24_FLAG_ADDR16 | 169818d0220SBartosz Golaszewski AT24_FLAG_SERIAL | 170818d0220SBartosz Golaszewski AT24_FLAG_READONLY) }, 1715195e509SWolfram Sang { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) }, 1725195e509SWolfram Sang { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) }, 1735195e509SWolfram Sang { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) }, 1745195e509SWolfram Sang { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) }, 1755195e509SWolfram Sang { "at24", 0 }, 1765195e509SWolfram Sang { /* END OF LIST */ } 1775195e509SWolfram Sang }; 1785195e509SWolfram Sang MODULE_DEVICE_TABLE(i2c, at24_ids); 1795195e509SWolfram Sang 1807f2a2f0dSJavier Martinez Canillas static const struct of_device_id at24_of_match[] = { 1817f2a2f0dSJavier Martinez Canillas { 1827f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c00", 1837f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) 1847f2a2f0dSJavier Martinez Canillas }, 1857f2a2f0dSJavier Martinez Canillas { 1867f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c01", 1877f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(1024 / 8, 0) 1887f2a2f0dSJavier Martinez Canillas }, 1897f2a2f0dSJavier Martinez Canillas { 1907f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c02", 1917f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(2048 / 8, 0) 1927f2a2f0dSJavier Martinez Canillas }, 1937f2a2f0dSJavier Martinez Canillas { 1947f2a2f0dSJavier Martinez Canillas .compatible = "atmel,spd", 1957f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(2048 / 8, 1967f2a2f0dSJavier Martinez Canillas AT24_FLAG_READONLY | AT24_FLAG_IRUGO) 1977f2a2f0dSJavier Martinez Canillas }, 1987f2a2f0dSJavier Martinez Canillas { 1997f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c04", 2007f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(4096 / 8, 0) 2017f2a2f0dSJavier Martinez Canillas }, 2027f2a2f0dSJavier Martinez Canillas { 2037f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c08", 2047f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(8192 / 8, 0) 2057f2a2f0dSJavier Martinez Canillas }, 2067f2a2f0dSJavier Martinez Canillas { 2077f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c16", 2087f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(16384 / 8, 0) 2097f2a2f0dSJavier Martinez Canillas }, 2107f2a2f0dSJavier Martinez Canillas { 2117f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c32", 2127f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) 2137f2a2f0dSJavier Martinez Canillas }, 2147f2a2f0dSJavier Martinez Canillas { 2157f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c64", 2167f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) 2177f2a2f0dSJavier Martinez Canillas }, 2187f2a2f0dSJavier Martinez Canillas { 2197f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c128", 2207f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) 2217f2a2f0dSJavier Martinez Canillas }, 2227f2a2f0dSJavier Martinez Canillas { 2237f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c256", 2247f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) 2257f2a2f0dSJavier Martinez Canillas }, 2267f2a2f0dSJavier Martinez Canillas { 2277f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c512", 2287f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) 2297f2a2f0dSJavier Martinez Canillas }, 2307f2a2f0dSJavier Martinez Canillas { 2317f2a2f0dSJavier Martinez Canillas .compatible = "atmel,24c1024", 2327f2a2f0dSJavier Martinez Canillas .data = (void *)AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) 2337f2a2f0dSJavier Martinez Canillas }, 2347f2a2f0dSJavier Martinez Canillas { }, 2357f2a2f0dSJavier Martinez Canillas }; 2367f2a2f0dSJavier Martinez Canillas MODULE_DEVICE_TABLE(of, at24_of_match); 2377f2a2f0dSJavier Martinez Canillas 23840d8edc9SAndy Shevchenko static const struct acpi_device_id at24_acpi_ids[] = { 23940d8edc9SAndy Shevchenko { "INT3499", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 24040d8edc9SAndy Shevchenko { } 24140d8edc9SAndy Shevchenko }; 24240d8edc9SAndy Shevchenko MODULE_DEVICE_TABLE(acpi, at24_acpi_ids); 24340d8edc9SAndy Shevchenko 2445195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 2455195e509SWolfram Sang 2465195e509SWolfram Sang /* 2475195e509SWolfram Sang * This routine supports chips which consume multiple I2C addresses. It 2485195e509SWolfram Sang * computes the addressing information to be used for a given r/w request. 2495195e509SWolfram Sang * Assumes that sanity checks for offset happened at sysfs-layer. 2509afd6866SBartosz Golaszewski * 2519afd6866SBartosz Golaszewski * Slave address and byte offset derive from the offset. Always 2529afd6866SBartosz Golaszewski * set the byte address; on a multi-master board, another master 2539afd6866SBartosz Golaszewski * may have changed the chip's "current" address pointer. 2545195e509SWolfram Sang */ 25546049486SHeiner Kallweit static struct at24_client *at24_translate_offset(struct at24_data *at24, 2562da78ac3SBartosz Golaszewski unsigned int *offset) 2575195e509SWolfram Sang { 258aa4ce228SBartosz Golaszewski unsigned int i; 2595195e509SWolfram Sang 2605195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) { 2615195e509SWolfram Sang i = *offset >> 16; 2625195e509SWolfram Sang *offset &= 0xffff; 2635195e509SWolfram Sang } else { 2645195e509SWolfram Sang i = *offset >> 8; 2655195e509SWolfram Sang *offset &= 0xff; 2665195e509SWolfram Sang } 2675195e509SWolfram Sang 26846049486SHeiner Kallweit return &at24->client[i]; 2695195e509SWolfram Sang } 2705195e509SWolfram Sang 271e32213fbSSven Van Asbroeck static size_t at24_adjust_read_count(struct at24_data *at24, 272e32213fbSSven Van Asbroeck unsigned int offset, size_t count) 273e32213fbSSven Van Asbroeck { 274e32213fbSSven Van Asbroeck unsigned int bits; 275e32213fbSSven Van Asbroeck size_t remainder; 276e32213fbSSven Van Asbroeck 277e32213fbSSven Van Asbroeck /* 278e32213fbSSven Van Asbroeck * In case of multi-address chips that don't rollover reads to 279e32213fbSSven Van Asbroeck * the next slave address: truncate the count to the slave boundary, 280e32213fbSSven Van Asbroeck * so that the read never straddles slaves. 281e32213fbSSven Van Asbroeck */ 282e32213fbSSven Van Asbroeck if (at24->chip.flags & AT24_FLAG_NO_RDROL) { 283e32213fbSSven Van Asbroeck bits = (at24->chip.flags & AT24_FLAG_ADDR16) ? 16 : 8; 284e32213fbSSven Van Asbroeck remainder = BIT(bits) - offset; 285e32213fbSSven Van Asbroeck if (count > remainder) 286e32213fbSSven Van Asbroeck count = remainder; 287e32213fbSSven Van Asbroeck } 288e32213fbSSven Van Asbroeck 289e32213fbSSven Van Asbroeck if (count > io_limit) 290e32213fbSSven Van Asbroeck count = io_limit; 291e32213fbSSven Van Asbroeck 292e32213fbSSven Van Asbroeck return count; 293e32213fbSSven Van Asbroeck } 294e32213fbSSven Van Asbroeck 2954bb5c13cSHeiner Kallweit static ssize_t at24_regmap_read(struct at24_data *at24, char *buf, 2964bb5c13cSHeiner Kallweit unsigned int offset, size_t count) 2974bb5c13cSHeiner Kallweit { 2984bb5c13cSHeiner Kallweit unsigned long timeout, read_time; 2994bb5c13cSHeiner Kallweit struct at24_client *at24_client; 3004bb5c13cSHeiner Kallweit struct i2c_client *client; 3014bb5c13cSHeiner Kallweit struct regmap *regmap; 3024bb5c13cSHeiner Kallweit int ret; 3034bb5c13cSHeiner Kallweit 3044bb5c13cSHeiner Kallweit at24_client = at24_translate_offset(at24, &offset); 3054bb5c13cSHeiner Kallweit regmap = at24_client->regmap; 3064bb5c13cSHeiner Kallweit client = at24_client->client; 307e32213fbSSven Van Asbroeck count = at24_adjust_read_count(at24, offset, count); 3084bb5c13cSHeiner Kallweit 3094bb5c13cSHeiner Kallweit /* adjust offset for mac and serial read ops */ 3104bb5c13cSHeiner Kallweit offset += at24->offset_adj; 3114bb5c13cSHeiner Kallweit 3124bb5c13cSHeiner Kallweit loop_until_timeout(timeout, read_time) { 3134bb5c13cSHeiner Kallweit ret = regmap_bulk_read(regmap, offset, buf, count); 3144bb5c13cSHeiner Kallweit dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 3154bb5c13cSHeiner Kallweit count, offset, ret, jiffies); 3164bb5c13cSHeiner Kallweit if (!ret) 3174bb5c13cSHeiner Kallweit return count; 3184bb5c13cSHeiner Kallweit } 3194bb5c13cSHeiner Kallweit 3204bb5c13cSHeiner Kallweit return -ETIMEDOUT; 3214bb5c13cSHeiner Kallweit } 3224bb5c13cSHeiner Kallweit 3235195e509SWolfram Sang /* 3245195e509SWolfram Sang * Note that if the hardware write-protect pin is pulled high, the whole 3255195e509SWolfram Sang * chip is normally write protected. But there are plenty of product 3265195e509SWolfram Sang * variants here, including OTP fuses and partial chip protect. 3275195e509SWolfram Sang * 328cd0c8615SBartosz Golaszewski * We only use page mode writes; the alternative is sloooow. These routines 329cd0c8615SBartosz Golaszewski * write at most one page. 3305195e509SWolfram Sang */ 331cd0c8615SBartosz Golaszewski 332cd0c8615SBartosz Golaszewski static size_t at24_adjust_write_count(struct at24_data *at24, 3332da78ac3SBartosz Golaszewski unsigned int offset, size_t count) 3345195e509SWolfram Sang { 335aa4ce228SBartosz Golaszewski unsigned int next_page; 3365195e509SWolfram Sang 3375195e509SWolfram Sang /* write_max is at most a page */ 3385195e509SWolfram Sang if (count > at24->write_max) 3395195e509SWolfram Sang count = at24->write_max; 3405195e509SWolfram Sang 3415195e509SWolfram Sang /* Never roll over backwards, to the start of this page */ 3425195e509SWolfram Sang next_page = roundup(offset + 1, at24->chip.page_size); 3435195e509SWolfram Sang if (offset + count > next_page) 3445195e509SWolfram Sang count = next_page - offset; 3455195e509SWolfram Sang 346cd0c8615SBartosz Golaszewski return count; 347cd0c8615SBartosz Golaszewski } 348cd0c8615SBartosz Golaszewski 3498e5888e1SHeiner Kallweit static ssize_t at24_regmap_write(struct at24_data *at24, const char *buf, 3508e5888e1SHeiner Kallweit unsigned int offset, size_t count) 3518e5888e1SHeiner Kallweit { 3528e5888e1SHeiner Kallweit unsigned long timeout, write_time; 3538e5888e1SHeiner Kallweit struct at24_client *at24_client; 3548e5888e1SHeiner Kallweit struct i2c_client *client; 3558e5888e1SHeiner Kallweit struct regmap *regmap; 3568e5888e1SHeiner Kallweit int ret; 3578e5888e1SHeiner Kallweit 3588e5888e1SHeiner Kallweit at24_client = at24_translate_offset(at24, &offset); 3598e5888e1SHeiner Kallweit regmap = at24_client->regmap; 3608e5888e1SHeiner Kallweit client = at24_client->client; 3618e5888e1SHeiner Kallweit count = at24_adjust_write_count(at24, offset, count); 3628e5888e1SHeiner Kallweit 3638e5888e1SHeiner Kallweit loop_until_timeout(timeout, write_time) { 3648e5888e1SHeiner Kallweit ret = regmap_bulk_write(regmap, offset, buf, count); 3658e5888e1SHeiner Kallweit dev_dbg(&client->dev, "write %zu@%d --> %d (%ld)\n", 3668e5888e1SHeiner Kallweit count, offset, ret, jiffies); 3678e5888e1SHeiner Kallweit if (!ret) 3688e5888e1SHeiner Kallweit return count; 3698e5888e1SHeiner Kallweit } 3708e5888e1SHeiner Kallweit 3718e5888e1SHeiner Kallweit return -ETIMEDOUT; 3728e5888e1SHeiner Kallweit } 3738e5888e1SHeiner Kallweit 374d5bc0047SBartosz Golaszewski static int at24_read(void *priv, unsigned int off, void *val, size_t count) 375d5bc0047SBartosz Golaszewski { 376d5bc0047SBartosz Golaszewski struct at24_data *at24 = priv; 3775c015258SHeiner Kallweit struct device *dev = &at24->client[0].client->dev; 378d5bc0047SBartosz Golaszewski char *buf = val; 37998e82010SDivagar Mohandass int ret; 380d5bc0047SBartosz Golaszewski 381d5bc0047SBartosz Golaszewski if (unlikely(!count)) 382d5bc0047SBartosz Golaszewski return count; 383d5bc0047SBartosz Golaszewski 384d9bcd462SHeiner Kallweit if (off + count > at24->chip.byte_len) 385d9bcd462SHeiner Kallweit return -EINVAL; 386d9bcd462SHeiner Kallweit 387f9ecc83fSSakari Ailus ret = pm_runtime_get_sync(dev); 38898e82010SDivagar Mohandass if (ret < 0) { 389f9ecc83fSSakari Ailus pm_runtime_put_noidle(dev); 39098e82010SDivagar Mohandass return ret; 39198e82010SDivagar Mohandass } 39298e82010SDivagar Mohandass 393d5bc0047SBartosz Golaszewski /* 394d5bc0047SBartosz Golaszewski * Read data from chip, protecting against concurrent updates 395d5bc0047SBartosz Golaszewski * from this host, but not from other I2C masters. 396d5bc0047SBartosz Golaszewski */ 397d5bc0047SBartosz Golaszewski mutex_lock(&at24->lock); 398d5bc0047SBartosz Golaszewski 399d5bc0047SBartosz Golaszewski while (count) { 400d5bc0047SBartosz Golaszewski int status; 401d5bc0047SBartosz Golaszewski 4024bb5c13cSHeiner Kallweit status = at24_regmap_read(at24, buf, off, count); 403d5bc0047SBartosz Golaszewski if (status < 0) { 404d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 405f9ecc83fSSakari Ailus pm_runtime_put(dev); 406d5bc0047SBartosz Golaszewski return status; 407d5bc0047SBartosz Golaszewski } 408d5bc0047SBartosz Golaszewski buf += status; 409d5bc0047SBartosz Golaszewski off += status; 410d5bc0047SBartosz Golaszewski count -= status; 411d5bc0047SBartosz Golaszewski } 412d5bc0047SBartosz Golaszewski 413d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 414d5bc0047SBartosz Golaszewski 415f9ecc83fSSakari Ailus pm_runtime_put(dev); 41698e82010SDivagar Mohandass 417d5bc0047SBartosz Golaszewski return 0; 418d5bc0047SBartosz Golaszewski } 419d5bc0047SBartosz Golaszewski 420cf0361a2SSrinivas Kandagatla static int at24_write(void *priv, unsigned int off, void *val, size_t count) 4215195e509SWolfram Sang { 422cf0361a2SSrinivas Kandagatla struct at24_data *at24 = priv; 4235c015258SHeiner Kallweit struct device *dev = &at24->client[0].client->dev; 424cf0361a2SSrinivas Kandagatla char *buf = val; 42598e82010SDivagar Mohandass int ret; 4265195e509SWolfram Sang 4275195e509SWolfram Sang if (unlikely(!count)) 428cf0361a2SSrinivas Kandagatla return -EINVAL; 4295195e509SWolfram Sang 430d9bcd462SHeiner Kallweit if (off + count > at24->chip.byte_len) 431d9bcd462SHeiner Kallweit return -EINVAL; 432d9bcd462SHeiner Kallweit 433f9ecc83fSSakari Ailus ret = pm_runtime_get_sync(dev); 43498e82010SDivagar Mohandass if (ret < 0) { 435f9ecc83fSSakari Ailus pm_runtime_put_noidle(dev); 43698e82010SDivagar Mohandass return ret; 43798e82010SDivagar Mohandass } 43898e82010SDivagar Mohandass 4395195e509SWolfram Sang /* 4405195e509SWolfram Sang * Write data to chip, protecting against concurrent updates 4415195e509SWolfram Sang * from this host, but not from other I2C masters. 4425195e509SWolfram Sang */ 4435195e509SWolfram Sang mutex_lock(&at24->lock); 4445195e509SWolfram Sang 4455195e509SWolfram Sang while (count) { 446cf0361a2SSrinivas Kandagatla int status; 4475195e509SWolfram Sang 4488e5888e1SHeiner Kallweit status = at24_regmap_write(at24, buf, off, count); 449cf0361a2SSrinivas Kandagatla if (status < 0) { 450cf0361a2SSrinivas Kandagatla mutex_unlock(&at24->lock); 451f9ecc83fSSakari Ailus pm_runtime_put(dev); 452cf0361a2SSrinivas Kandagatla return status; 4535195e509SWolfram Sang } 4545195e509SWolfram Sang buf += status; 4555195e509SWolfram Sang off += status; 4565195e509SWolfram Sang count -= status; 4575195e509SWolfram Sang } 4585195e509SWolfram Sang 4595195e509SWolfram Sang mutex_unlock(&at24->lock); 4605195e509SWolfram Sang 461f9ecc83fSSakari Ailus pm_runtime_put(dev); 46298e82010SDivagar Mohandass 46357d15550SAndrew Lunn return 0; 46457d15550SAndrew Lunn } 46557d15550SAndrew Lunn 466dd905a61SBen Gardner static void at24_get_pdata(struct device *dev, struct at24_platform_data *chip) 4679ed030d7SWolfram Sang { 468dd905a61SBen Gardner int err; 469dd905a61SBen Gardner u32 val; 4709ed030d7SWolfram Sang 471dd905a61SBen Gardner if (device_property_present(dev, "read-only")) 4729ed030d7SWolfram Sang chip->flags |= AT24_FLAG_READONLY; 473e32213fbSSven Van Asbroeck if (device_property_present(dev, "no-read-rollover")) 474e32213fbSSven Van Asbroeck chip->flags |= AT24_FLAG_NO_RDROL; 475dd905a61SBen Gardner 476dbc1ab9cSDivagar Mohandass err = device_property_read_u32(dev, "size", &val); 477dbc1ab9cSDivagar Mohandass if (!err) 478dbc1ab9cSDivagar Mohandass chip->byte_len = val; 479dbc1ab9cSDivagar Mohandass 480dd905a61SBen Gardner err = device_property_read_u32(dev, "pagesize", &val); 481dd905a61SBen Gardner if (!err) { 482dd905a61SBen Gardner chip->page_size = val; 483dd905a61SBen Gardner } else { 484dd905a61SBen Gardner /* 485dd905a61SBen Gardner * This is slow, but we can't know all eeproms, so we better 486dd905a61SBen Gardner * play safe. Specifying custom eeprom-types via platform_data 487dd905a61SBen Gardner * is recommended anyhow. 488dd905a61SBen Gardner */ 489dd905a61SBen Gardner chip->page_size = 1; 4909ed030d7SWolfram Sang } 4919ed030d7SWolfram Sang } 4929ed030d7SWolfram Sang 4934bb5c13cSHeiner Kallweit static unsigned int at24_get_offset_adj(u8 flags, unsigned int byte_len) 4944bb5c13cSHeiner Kallweit { 4954bb5c13cSHeiner Kallweit if (flags & AT24_FLAG_MAC) { 4964bb5c13cSHeiner Kallweit /* EUI-48 starts from 0x9a, EUI-64 from 0x98 */ 4974bb5c13cSHeiner Kallweit return 0xa0 - byte_len; 4984bb5c13cSHeiner Kallweit } else if (flags & AT24_FLAG_SERIAL && flags & AT24_FLAG_ADDR16) { 4994bb5c13cSHeiner Kallweit /* 5004bb5c13cSHeiner Kallweit * For 16 bit address pointers, the word address must contain 5014bb5c13cSHeiner Kallweit * a '10' sequence in bits 11 and 10 regardless of the 5024bb5c13cSHeiner Kallweit * intended position of the address pointer. 5034bb5c13cSHeiner Kallweit */ 5044bb5c13cSHeiner Kallweit return 0x0800; 5054bb5c13cSHeiner Kallweit } else if (flags & AT24_FLAG_SERIAL) { 5064bb5c13cSHeiner Kallweit /* 5074bb5c13cSHeiner Kallweit * Otherwise the word address must begin with a '10' sequence, 5084bb5c13cSHeiner Kallweit * regardless of the intended address. 5094bb5c13cSHeiner Kallweit */ 5104bb5c13cSHeiner Kallweit return 0x0080; 5114bb5c13cSHeiner Kallweit } else { 5124bb5c13cSHeiner Kallweit return 0; 5134bb5c13cSHeiner Kallweit } 5144bb5c13cSHeiner Kallweit } 5154bb5c13cSHeiner Kallweit 5165c015258SHeiner Kallweit static const struct regmap_config regmap_config_8 = { 5175c015258SHeiner Kallweit .reg_bits = 8, 5185c015258SHeiner Kallweit .val_bits = 8, 5195c015258SHeiner Kallweit }; 5205c015258SHeiner Kallweit 5215c015258SHeiner Kallweit static const struct regmap_config regmap_config_16 = { 5225c015258SHeiner Kallweit .reg_bits = 16, 5235c015258SHeiner Kallweit .val_bits = 8, 5245c015258SHeiner Kallweit }; 5255c015258SHeiner Kallweit 5265195e509SWolfram Sang static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) 5275195e509SWolfram Sang { 5285195e509SWolfram Sang struct at24_platform_data chip; 52940d8edc9SAndy Shevchenko kernel_ulong_t magic = 0; 5305195e509SWolfram Sang bool writable; 5315195e509SWolfram Sang struct at24_data *at24; 5325195e509SWolfram Sang int err; 533aa4ce228SBartosz Golaszewski unsigned int i, num_addresses; 5345c015258SHeiner Kallweit const struct regmap_config *config; 53500f0ea70SBartosz Golaszewski u8 test_byte; 5365195e509SWolfram Sang 5375195e509SWolfram Sang if (client->dev.platform_data) { 5385195e509SWolfram Sang chip = *(struct at24_platform_data *)client->dev.platform_data; 5395195e509SWolfram Sang } else { 5407f2a2f0dSJavier Martinez Canillas /* 5417f2a2f0dSJavier Martinez Canillas * The I2C core allows OF nodes compatibles to match against the 5427f2a2f0dSJavier Martinez Canillas * I2C device ID table as a fallback, so check not only if an OF 5437f2a2f0dSJavier Martinez Canillas * node is present but also if it matches an OF device ID entry. 5447f2a2f0dSJavier Martinez Canillas */ 5457f2a2f0dSJavier Martinez Canillas if (client->dev.of_node && 5467f2a2f0dSJavier Martinez Canillas of_match_device(at24_of_match, &client->dev)) { 5477f2a2f0dSJavier Martinez Canillas magic = (kernel_ulong_t) 5487f2a2f0dSJavier Martinez Canillas of_device_get_match_data(&client->dev); 5497f2a2f0dSJavier Martinez Canillas } else if (id) { 55040d8edc9SAndy Shevchenko magic = id->driver_data; 55140d8edc9SAndy Shevchenko } else { 55240d8edc9SAndy Shevchenko const struct acpi_device_id *aid; 55340d8edc9SAndy Shevchenko 55440d8edc9SAndy Shevchenko aid = acpi_match_device(at24_acpi_ids, &client->dev); 55540d8edc9SAndy Shevchenko if (aid) 55640d8edc9SAndy Shevchenko magic = aid->driver_data; 55740d8edc9SAndy Shevchenko } 55840d8edc9SAndy Shevchenko if (!magic) 559f0ac2363SNikolay Balandin return -ENODEV; 560f0ac2363SNikolay Balandin 5615195e509SWolfram Sang chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN)); 5625195e509SWolfram Sang magic >>= AT24_SIZE_BYTELEN; 5635195e509SWolfram Sang chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS); 5647274ec8bSKevin Hilman 565dd905a61SBen Gardner at24_get_pdata(&client->dev, &chip); 5669ed030d7SWolfram Sang 5677274ec8bSKevin Hilman chip.setup = NULL; 5687274ec8bSKevin Hilman chip.context = NULL; 5695195e509SWolfram Sang } 5705195e509SWolfram Sang 5715195e509SWolfram Sang if (!is_power_of_2(chip.byte_len)) 5725195e509SWolfram Sang dev_warn(&client->dev, 5735195e509SWolfram Sang "byte_len looks suspicious (no power of 2)!\n"); 57445efe847SWolfram Sang if (!chip.page_size) { 57545efe847SWolfram Sang dev_err(&client->dev, "page_size must not be 0!\n"); 576f0ac2363SNikolay Balandin return -EINVAL; 57745efe847SWolfram Sang } 5785195e509SWolfram Sang if (!is_power_of_2(chip.page_size)) 5795195e509SWolfram Sang dev_warn(&client->dev, 5805195e509SWolfram Sang "page_size looks suspicious (no power of 2)!\n"); 5815195e509SWolfram Sang 5825478e478SBartosz Golaszewski /* 5835478e478SBartosz Golaszewski * REVISIT: the size of the EUI-48 byte array is 6 in at24mac402, while 5845478e478SBartosz Golaszewski * the call to ilog2() in AT24_DEVICE_MAGIC() rounds it down to 4. 5855478e478SBartosz Golaszewski * 5865478e478SBartosz Golaszewski * Eventually we'll get rid of the magic values altoghether in favor of 5875478e478SBartosz Golaszewski * real structs, but for now just manually set the right size. 5885478e478SBartosz Golaszewski */ 5895478e478SBartosz Golaszewski if (chip.flags & AT24_FLAG_MAC && chip.byte_len == 4) 5905478e478SBartosz Golaszewski chip.byte_len = 6; 5915478e478SBartosz Golaszewski 592a23727cbSHeiner Kallweit if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C) && 593a23727cbSHeiner Kallweit !i2c_check_functionality(client->adapter, 594a23727cbSHeiner Kallweit I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) 595a839ce66SChristian Gmeiner chip.page_size = 1; 596a839ce66SChristian Gmeiner 5975195e509SWolfram Sang if (chip.flags & AT24_FLAG_TAKE8ADDR) 5985195e509SWolfram Sang num_addresses = 8; 5995195e509SWolfram Sang else 6005195e509SWolfram Sang num_addresses = DIV_ROUND_UP(chip.byte_len, 6015195e509SWolfram Sang (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256); 6025195e509SWolfram Sang 6035c015258SHeiner Kallweit if (chip.flags & AT24_FLAG_ADDR16) 6045c015258SHeiner Kallweit config = ®map_config_16; 6055c015258SHeiner Kallweit else 6065c015258SHeiner Kallweit config = ®map_config_8; 6075c015258SHeiner Kallweit 608f0ac2363SNikolay Balandin at24 = devm_kzalloc(&client->dev, sizeof(struct at24_data) + 6095c015258SHeiner Kallweit num_addresses * sizeof(struct at24_client), GFP_KERNEL); 610f0ac2363SNikolay Balandin if (!at24) 611f0ac2363SNikolay Balandin return -ENOMEM; 6125195e509SWolfram Sang 6135195e509SWolfram Sang mutex_init(&at24->lock); 6145195e509SWolfram Sang at24->chip = chip; 6155195e509SWolfram Sang at24->num_addresses = num_addresses; 6164bb5c13cSHeiner Kallweit at24->offset_adj = at24_get_offset_adj(chip.flags, chip.byte_len); 6175195e509SWolfram Sang 6185c015258SHeiner Kallweit at24->client[0].client = client; 6195c015258SHeiner Kallweit at24->client[0].regmap = devm_regmap_init_i2c(client, config); 6205c015258SHeiner Kallweit if (IS_ERR(at24->client[0].regmap)) 6215c015258SHeiner Kallweit return PTR_ERR(at24->client[0].regmap); 6225c015258SHeiner Kallweit 6230b813658SBartosz Golaszewski if ((chip.flags & AT24_FLAG_SERIAL) && (chip.flags & AT24_FLAG_MAC)) { 6240b813658SBartosz Golaszewski dev_err(&client->dev, 6250b813658SBartosz Golaszewski "invalid device data - cannot have both AT24_FLAG_SERIAL & AT24_FLAG_MAC."); 6260b813658SBartosz Golaszewski return -EINVAL; 6270b813658SBartosz Golaszewski } 6280b813658SBartosz Golaszewski 6295195e509SWolfram Sang writable = !(chip.flags & AT24_FLAG_READONLY); 6305195e509SWolfram Sang if (writable) { 631a23727cbSHeiner Kallweit at24->write_max = min_t(unsigned int, chip.page_size, io_limit); 632a23727cbSHeiner Kallweit if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C) && 633a23727cbSHeiner Kallweit at24->write_max > I2C_SMBUS_BLOCK_MAX) 634a23727cbSHeiner Kallweit at24->write_max = I2C_SMBUS_BLOCK_MAX; 6355195e509SWolfram Sang } 6365195e509SWolfram Sang 6375195e509SWolfram Sang /* use dummy devices for multiple-address chips */ 6385195e509SWolfram Sang for (i = 1; i < num_addresses; i++) { 6395c015258SHeiner Kallweit at24->client[i].client = i2c_new_dummy(client->adapter, 6405195e509SWolfram Sang client->addr + i); 6415c015258SHeiner Kallweit if (!at24->client[i].client) { 6425195e509SWolfram Sang dev_err(&client->dev, "address 0x%02x unavailable\n", 6435195e509SWolfram Sang client->addr + i); 6445195e509SWolfram Sang err = -EADDRINUSE; 6455195e509SWolfram Sang goto err_clients; 6465195e509SWolfram Sang } 6475c015258SHeiner Kallweit at24->client[i].regmap = devm_regmap_init_i2c( 6485c015258SHeiner Kallweit at24->client[i].client, config); 6495c015258SHeiner Kallweit if (IS_ERR(at24->client[i].regmap)) { 6505c015258SHeiner Kallweit err = PTR_ERR(at24->client[i].regmap); 6515c015258SHeiner Kallweit goto err_clients; 6525c015258SHeiner Kallweit } 6535195e509SWolfram Sang } 6545195e509SWolfram Sang 65500f0ea70SBartosz Golaszewski i2c_set_clientdata(client, at24); 65600f0ea70SBartosz Golaszewski 65798e82010SDivagar Mohandass /* enable runtime pm */ 65898e82010SDivagar Mohandass pm_runtime_set_active(&client->dev); 65998e82010SDivagar Mohandass pm_runtime_enable(&client->dev); 66098e82010SDivagar Mohandass 66100f0ea70SBartosz Golaszewski /* 66200f0ea70SBartosz Golaszewski * Perform a one-byte test read to verify that the 66300f0ea70SBartosz Golaszewski * chip is functional. 66400f0ea70SBartosz Golaszewski */ 66500f0ea70SBartosz Golaszewski err = at24_read(at24, 0, &test_byte, 1); 66698e82010SDivagar Mohandass pm_runtime_idle(&client->dev); 66700f0ea70SBartosz Golaszewski if (err) { 66800f0ea70SBartosz Golaszewski err = -ENODEV; 66900f0ea70SBartosz Golaszewski goto err_clients; 67000f0ea70SBartosz Golaszewski } 67100f0ea70SBartosz Golaszewski 67257d15550SAndrew Lunn at24->nvmem_config.name = dev_name(&client->dev); 67357d15550SAndrew Lunn at24->nvmem_config.dev = &client->dev; 67457d15550SAndrew Lunn at24->nvmem_config.read_only = !writable; 67557d15550SAndrew Lunn at24->nvmem_config.root_only = true; 67657d15550SAndrew Lunn at24->nvmem_config.owner = THIS_MODULE; 67757d15550SAndrew Lunn at24->nvmem_config.compat = true; 67857d15550SAndrew Lunn at24->nvmem_config.base_dev = &client->dev; 679cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_read = at24_read; 680cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_write = at24_write; 681cf0361a2SSrinivas Kandagatla at24->nvmem_config.priv = at24; 6827f6d2ecdSDavid Lechner at24->nvmem_config.stride = 1; 683cf0361a2SSrinivas Kandagatla at24->nvmem_config.word_size = 1; 684cf0361a2SSrinivas Kandagatla at24->nvmem_config.size = chip.byte_len; 68557d15550SAndrew Lunn 68657d15550SAndrew Lunn at24->nvmem = nvmem_register(&at24->nvmem_config); 68757d15550SAndrew Lunn 68857d15550SAndrew Lunn if (IS_ERR(at24->nvmem)) { 68957d15550SAndrew Lunn err = PTR_ERR(at24->nvmem); 69057d15550SAndrew Lunn goto err_clients; 69157d15550SAndrew Lunn } 6925195e509SWolfram Sang 69357d15550SAndrew Lunn dev_info(&client->dev, "%u byte %s EEPROM, %s, %u bytes/write\n", 69457d15550SAndrew Lunn chip.byte_len, client->name, 6959ed030d7SWolfram Sang writable ? "writable" : "read-only", at24->write_max); 6965195e509SWolfram Sang 6977274ec8bSKevin Hilman /* export data to kernel code */ 6987274ec8bSKevin Hilman if (chip.setup) 699bec3c11bSAndrew Lunn chip.setup(at24->nvmem, chip.context); 7007274ec8bSKevin Hilman 7015195e509SWolfram Sang return 0; 7025195e509SWolfram Sang 7035195e509SWolfram Sang err_clients: 7045195e509SWolfram Sang for (i = 1; i < num_addresses; i++) 7055c015258SHeiner Kallweit if (at24->client[i].client) 7065c015258SHeiner Kallweit i2c_unregister_device(at24->client[i].client); 7075195e509SWolfram Sang 70898e82010SDivagar Mohandass pm_runtime_disable(&client->dev); 70998e82010SDivagar Mohandass 7105195e509SWolfram Sang return err; 7115195e509SWolfram Sang } 7125195e509SWolfram Sang 713486a5c28SBill Pemberton static int at24_remove(struct i2c_client *client) 7145195e509SWolfram Sang { 7155195e509SWolfram Sang struct at24_data *at24; 7165195e509SWolfram Sang int i; 7175195e509SWolfram Sang 7185195e509SWolfram Sang at24 = i2c_get_clientdata(client); 71957d15550SAndrew Lunn 72057d15550SAndrew Lunn nvmem_unregister(at24->nvmem); 7215195e509SWolfram Sang 7225195e509SWolfram Sang for (i = 1; i < at24->num_addresses; i++) 7235c015258SHeiner Kallweit i2c_unregister_device(at24->client[i].client); 7245195e509SWolfram Sang 72598e82010SDivagar Mohandass pm_runtime_disable(&client->dev); 72698e82010SDivagar Mohandass pm_runtime_set_suspended(&client->dev); 72798e82010SDivagar Mohandass 7285195e509SWolfram Sang return 0; 7295195e509SWolfram Sang } 7305195e509SWolfram Sang 7315195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 7325195e509SWolfram Sang 7335195e509SWolfram Sang static struct i2c_driver at24_driver = { 7345195e509SWolfram Sang .driver = { 7355195e509SWolfram Sang .name = "at24", 7367f2a2f0dSJavier Martinez Canillas .of_match_table = at24_of_match, 73740d8edc9SAndy Shevchenko .acpi_match_table = ACPI_PTR(at24_acpi_ids), 7385195e509SWolfram Sang }, 7395195e509SWolfram Sang .probe = at24_probe, 7402d6bed9cSBill Pemberton .remove = at24_remove, 7415195e509SWolfram Sang .id_table = at24_ids, 7425195e509SWolfram Sang }; 7435195e509SWolfram Sang 7445195e509SWolfram Sang static int __init at24_init(void) 7455195e509SWolfram Sang { 74645efe847SWolfram Sang if (!io_limit) { 74745efe847SWolfram Sang pr_err("at24: io_limit must not be 0!\n"); 74845efe847SWolfram Sang return -EINVAL; 74945efe847SWolfram Sang } 75045efe847SWolfram Sang 7515195e509SWolfram Sang io_limit = rounddown_pow_of_two(io_limit); 7525195e509SWolfram Sang return i2c_add_driver(&at24_driver); 7535195e509SWolfram Sang } 7545195e509SWolfram Sang module_init(at24_init); 7555195e509SWolfram Sang 7565195e509SWolfram Sang static void __exit at24_exit(void) 7575195e509SWolfram Sang { 7585195e509SWolfram Sang i2c_del_driver(&at24_driver); 7595195e509SWolfram Sang } 7605195e509SWolfram Sang module_exit(at24_exit); 7615195e509SWolfram Sang 7625195e509SWolfram Sang MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); 7635195e509SWolfram Sang MODULE_AUTHOR("David Brownell and Wolfram Sang"); 7645195e509SWolfram Sang MODULE_LICENSE("GPL"); 765