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> 306ce261e8SBartosz Golaszewski #include <linux/gpio/consumer.h> 315195e509SWolfram Sang 325195e509SWolfram Sang /* 335195e509SWolfram Sang * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable. 345195e509SWolfram Sang * Differences between different vendor product lines (like Atmel AT24C or 355195e509SWolfram Sang * MicroChip 24LC, etc) won't much matter for typical read/write access. 365195e509SWolfram Sang * There are also I2C RAM chips, likewise interchangeable. One example 375195e509SWolfram Sang * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes). 385195e509SWolfram Sang * 395195e509SWolfram Sang * However, misconfiguration can lose data. "Set 16-bit memory address" 405195e509SWolfram Sang * to a part with 8-bit addressing will overwrite data. Writing with too 415195e509SWolfram Sang * big a page size also loses data. And it's not safe to assume that the 425195e509SWolfram Sang * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC 435195e509SWolfram Sang * uses 0x51, for just one example. 445195e509SWolfram Sang * 455195e509SWolfram Sang * Accordingly, explicit board-specific configuration data should be used 465195e509SWolfram Sang * in almost all cases. (One partial exception is an SMBus used to access 475195e509SWolfram Sang * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.) 485195e509SWolfram Sang * 495195e509SWolfram Sang * So this driver uses "new style" I2C driver binding, expecting to be 505195e509SWolfram Sang * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or 515195e509SWolfram Sang * similar kernel-resident tables; or, configuration data coming from 525195e509SWolfram Sang * a bootloader. 535195e509SWolfram Sang * 545195e509SWolfram Sang * Other than binding model, current differences from "eeprom" driver are 555195e509SWolfram Sang * that this one handles write access and isn't restricted to 24c02 devices. 565195e509SWolfram Sang * It also handles larger devices (32 kbit and up) with two-byte addresses, 575195e509SWolfram Sang * which won't work on pure SMBus systems. 585195e509SWolfram Sang */ 595195e509SWolfram Sang 605c015258SHeiner Kallweit struct at24_client { 615c015258SHeiner Kallweit struct i2c_client *client; 625c015258SHeiner Kallweit struct regmap *regmap; 635c015258SHeiner Kallweit }; 645c015258SHeiner Kallweit 655195e509SWolfram Sang struct at24_data { 665195e509SWolfram Sang struct at24_platform_data chip; 67318aa9c6SBartosz Golaszewski 685195e509SWolfram Sang /* 695195e509SWolfram Sang * Lock protects against activities from other Linux tasks, 705195e509SWolfram Sang * but not from changes by other I2C masters. 715195e509SWolfram Sang */ 725195e509SWolfram Sang struct mutex lock; 735195e509SWolfram Sang 74aa4ce228SBartosz Golaszewski unsigned int write_max; 75aa4ce228SBartosz Golaszewski unsigned int num_addresses; 764bb5c13cSHeiner Kallweit unsigned int offset_adj; 775195e509SWolfram Sang 7857d15550SAndrew Lunn struct nvmem_config nvmem_config; 7957d15550SAndrew Lunn struct nvmem_device *nvmem; 8057d15550SAndrew Lunn 816ce261e8SBartosz Golaszewski struct gpio_desc *wp_gpio; 826ce261e8SBartosz Golaszewski 835195e509SWolfram Sang /* 845195e509SWolfram Sang * Some chips tie up multiple I2C addresses; dummy devices reserve 855195e509SWolfram Sang * them for us, and we'll use them with SMBus calls. 865195e509SWolfram Sang */ 875c015258SHeiner Kallweit struct at24_client client[]; 885195e509SWolfram Sang }; 895195e509SWolfram Sang 905195e509SWolfram Sang /* 915195e509SWolfram Sang * This parameter is to help this driver avoid blocking other drivers out 925195e509SWolfram Sang * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C 935195e509SWolfram Sang * clock, one 256 byte read takes about 1/43 second which is excessive; 945195e509SWolfram Sang * but the 1/170 second it takes at 400 kHz may be quite reasonable; and 955195e509SWolfram Sang * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible. 965195e509SWolfram Sang * 975195e509SWolfram Sang * This value is forced to be a power of two so that writes align on pages. 985195e509SWolfram Sang */ 99ec3c2d51SBartosz Golaszewski static unsigned int at24_io_limit = 128; 100ec3c2d51SBartosz Golaszewski module_param_named(io_limit, at24_io_limit, uint, 0); 101ec3c2d51SBartosz Golaszewski MODULE_PARM_DESC(at24_io_limit, "Maximum bytes per I/O (default 128)"); 1025195e509SWolfram Sang 1035195e509SWolfram Sang /* 1045195e509SWolfram Sang * Specs often allow 5 msec for a page write, sometimes 20 msec; 1055195e509SWolfram Sang * it's important to recover from write timeouts. 1065195e509SWolfram Sang */ 107ec3c2d51SBartosz Golaszewski static unsigned int at24_write_timeout = 25; 108ec3c2d51SBartosz Golaszewski module_param_named(write_timeout, at24_write_timeout, uint, 0); 109ec3c2d51SBartosz Golaszewski MODULE_PARM_DESC(at24_write_timeout, "Time (in ms) to try writes (default 25)"); 1105195e509SWolfram Sang 1119344a81eSBartosz Golaszewski /* 1129344a81eSBartosz Golaszewski * Both reads and writes fail if the previous write didn't complete yet. This 1139344a81eSBartosz Golaszewski * macro loops a few times waiting at least long enough for one entire page 11424da3cc0SBartosz Golaszewski * write to work while making sure that at least one iteration is run before 11524da3cc0SBartosz Golaszewski * checking the break condition. 1169344a81eSBartosz Golaszewski * 1179344a81eSBartosz Golaszewski * It takes two parameters: a variable in which the future timeout in jiffies 1189344a81eSBartosz Golaszewski * will be stored and a temporary variable holding the time of the last 1199344a81eSBartosz Golaszewski * iteration of processing the request. Both should be unsigned integers 1209344a81eSBartosz Golaszewski * holding at least 32 bits. 1219344a81eSBartosz Golaszewski */ 122ec3c2d51SBartosz Golaszewski #define at24_loop_until_timeout(tout, op_time) \ 123ec3c2d51SBartosz Golaszewski for (tout = jiffies + msecs_to_jiffies(at24_write_timeout), \ 124ec3c2d51SBartosz Golaszewski op_time = 0; \ 12524da3cc0SBartosz Golaszewski op_time ? time_before(op_time, tout) : true; \ 1269344a81eSBartosz Golaszewski usleep_range(1000, 1500), op_time = jiffies) 1279344a81eSBartosz Golaszewski 128b680f4faSSven Van Asbroeck struct at24_chip_data { 129b680f4faSSven Van Asbroeck /* 130b680f4faSSven Van Asbroeck * these fields mirror their equivalents in 131b680f4faSSven Van Asbroeck * struct at24_platform_data 132b680f4faSSven Van Asbroeck */ 133b680f4faSSven Van Asbroeck u32 byte_len; 134b680f4faSSven Van Asbroeck u8 flags; 135b680f4faSSven Van Asbroeck }; 136b680f4faSSven Van Asbroeck 137b680f4faSSven Van Asbroeck #define AT24_CHIP_DATA(_name, _len, _flags) \ 138b680f4faSSven Van Asbroeck static const struct at24_chip_data _name = { \ 139b680f4faSSven Van Asbroeck .byte_len = _len, .flags = _flags, \ 140b680f4faSSven Van Asbroeck } 141b680f4faSSven Van Asbroeck 1425195e509SWolfram Sang /* needs 8 addresses as A0-A2 are ignored */ 143b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c00, 128 / 8, AT24_FLAG_TAKE8ADDR); 1445195e509SWolfram Sang /* old variants can't be handled with this generic entry! */ 145b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c01, 1024 / 8, 0); 146b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs01, 16, 147b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY); 148b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c02, 2048 / 8, 0); 149b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs02, 16, 150b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY); 151b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24mac402, 48 / 8, 152b680f4faSSven Van Asbroeck AT24_FLAG_MAC | AT24_FLAG_READONLY); 153b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24mac602, 64 / 8, 154b680f4faSSven Van Asbroeck AT24_FLAG_MAC | AT24_FLAG_READONLY); 1555195e509SWolfram Sang /* spd is a 24c02 in memory DIMMs */ 156b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_spd, 2048 / 8, 157b680f4faSSven Van Asbroeck AT24_FLAG_READONLY | AT24_FLAG_IRUGO); 158b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c04, 4096 / 8, 0); 159b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs04, 16, 160b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY); 1615195e509SWolfram Sang /* 24rf08 quirk is handled at i2c-core */ 162b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c08, 8192 / 8, 0); 163b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs08, 16, 164b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY); 165b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c16, 16384 / 8, 0); 166b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs16, 16, 167b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY); 168b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c32, 32768 / 8, AT24_FLAG_ADDR16); 169b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs32, 16, 170b680f4faSSven Van Asbroeck AT24_FLAG_ADDR16 | AT24_FLAG_SERIAL | AT24_FLAG_READONLY); 171b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c64, 65536 / 8, AT24_FLAG_ADDR16); 172b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs64, 16, 173b680f4faSSven Van Asbroeck AT24_FLAG_ADDR16 | AT24_FLAG_SERIAL | AT24_FLAG_READONLY); 174b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c128, 131072 / 8, AT24_FLAG_ADDR16); 175b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c256, 262144 / 8, AT24_FLAG_ADDR16); 176b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c512, 524288 / 8, AT24_FLAG_ADDR16); 177b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c1024, 1048576 / 8, AT24_FLAG_ADDR16); 178b680f4faSSven Van Asbroeck /* identical to 24c08 ? */ 179b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_INT3499, 8192 / 8, 0); 180b680f4faSSven Van Asbroeck 181b680f4faSSven Van Asbroeck static const struct i2c_device_id at24_ids[] = { 182b680f4faSSven Van Asbroeck { "24c00", (kernel_ulong_t)&at24_data_24c00 }, 183b680f4faSSven Van Asbroeck { "24c01", (kernel_ulong_t)&at24_data_24c01 }, 184b680f4faSSven Van Asbroeck { "24cs01", (kernel_ulong_t)&at24_data_24cs01 }, 185b680f4faSSven Van Asbroeck { "24c02", (kernel_ulong_t)&at24_data_24c02 }, 186b680f4faSSven Van Asbroeck { "24cs02", (kernel_ulong_t)&at24_data_24cs02 }, 187b680f4faSSven Van Asbroeck { "24mac402", (kernel_ulong_t)&at24_data_24mac402 }, 188b680f4faSSven Van Asbroeck { "24mac602", (kernel_ulong_t)&at24_data_24mac602 }, 189b680f4faSSven Van Asbroeck { "spd", (kernel_ulong_t)&at24_data_spd }, 190b680f4faSSven Van Asbroeck { "24c04", (kernel_ulong_t)&at24_data_24c04 }, 191b680f4faSSven Van Asbroeck { "24cs04", (kernel_ulong_t)&at24_data_24cs04 }, 192b680f4faSSven Van Asbroeck { "24c08", (kernel_ulong_t)&at24_data_24c08 }, 193b680f4faSSven Van Asbroeck { "24cs08", (kernel_ulong_t)&at24_data_24cs08 }, 194b680f4faSSven Van Asbroeck { "24c16", (kernel_ulong_t)&at24_data_24c16 }, 195b680f4faSSven Van Asbroeck { "24cs16", (kernel_ulong_t)&at24_data_24cs16 }, 196b680f4faSSven Van Asbroeck { "24c32", (kernel_ulong_t)&at24_data_24c32 }, 197b680f4faSSven Van Asbroeck { "24cs32", (kernel_ulong_t)&at24_data_24cs32 }, 198b680f4faSSven Van Asbroeck { "24c64", (kernel_ulong_t)&at24_data_24c64 }, 199b680f4faSSven Van Asbroeck { "24cs64", (kernel_ulong_t)&at24_data_24cs64 }, 200b680f4faSSven Van Asbroeck { "24c128", (kernel_ulong_t)&at24_data_24c128 }, 201b680f4faSSven Van Asbroeck { "24c256", (kernel_ulong_t)&at24_data_24c256 }, 202b680f4faSSven Van Asbroeck { "24c512", (kernel_ulong_t)&at24_data_24c512 }, 203b680f4faSSven Van Asbroeck { "24c1024", (kernel_ulong_t)&at24_data_24c1024 }, 2045195e509SWolfram Sang { "at24", 0 }, 2055195e509SWolfram Sang { /* END OF LIST */ } 2065195e509SWolfram Sang }; 2075195e509SWolfram Sang MODULE_DEVICE_TABLE(i2c, at24_ids); 2085195e509SWolfram Sang 2097f2a2f0dSJavier Martinez Canillas static const struct of_device_id at24_of_match[] = { 210b680f4faSSven Van Asbroeck { .compatible = "atmel,24c00", .data = &at24_data_24c00 }, 211b680f4faSSven Van Asbroeck { .compatible = "atmel,24c01", .data = &at24_data_24c01 }, 2120f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs01", .data = &at24_data_24cs01 }, 213b680f4faSSven Van Asbroeck { .compatible = "atmel,24c02", .data = &at24_data_24c02 }, 2140f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs02", .data = &at24_data_24cs02 }, 2150f30aca7SBartosz Golaszewski { .compatible = "atmel,24mac402", .data = &at24_data_24mac402 }, 2160f30aca7SBartosz Golaszewski { .compatible = "atmel,24mac602", .data = &at24_data_24mac602 }, 217b680f4faSSven Van Asbroeck { .compatible = "atmel,spd", .data = &at24_data_spd }, 218b680f4faSSven Van Asbroeck { .compatible = "atmel,24c04", .data = &at24_data_24c04 }, 2190f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs04", .data = &at24_data_24cs04 }, 220b680f4faSSven Van Asbroeck { .compatible = "atmel,24c08", .data = &at24_data_24c08 }, 2210f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs08", .data = &at24_data_24cs08 }, 222b680f4faSSven Van Asbroeck { .compatible = "atmel,24c16", .data = &at24_data_24c16 }, 2230f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs16", .data = &at24_data_24cs16 }, 224b680f4faSSven Van Asbroeck { .compatible = "atmel,24c32", .data = &at24_data_24c32 }, 2250f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs32", .data = &at24_data_24cs32 }, 226b680f4faSSven Van Asbroeck { .compatible = "atmel,24c64", .data = &at24_data_24c64 }, 2270f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs64", .data = &at24_data_24cs64 }, 228b680f4faSSven Van Asbroeck { .compatible = "atmel,24c128", .data = &at24_data_24c128 }, 229b680f4faSSven Van Asbroeck { .compatible = "atmel,24c256", .data = &at24_data_24c256 }, 230b680f4faSSven Van Asbroeck { .compatible = "atmel,24c512", .data = &at24_data_24c512 }, 231b680f4faSSven Van Asbroeck { .compatible = "atmel,24c1024", .data = &at24_data_24c1024 }, 232b680f4faSSven Van Asbroeck { /* END OF LIST */ }, 2337f2a2f0dSJavier Martinez Canillas }; 2347f2a2f0dSJavier Martinez Canillas MODULE_DEVICE_TABLE(of, at24_of_match); 2357f2a2f0dSJavier Martinez Canillas 23640d8edc9SAndy Shevchenko static const struct acpi_device_id at24_acpi_ids[] = { 237b680f4faSSven Van Asbroeck { "INT3499", (kernel_ulong_t)&at24_data_INT3499 }, 238b680f4faSSven Van Asbroeck { /* END OF LIST */ } 23940d8edc9SAndy Shevchenko }; 24040d8edc9SAndy Shevchenko MODULE_DEVICE_TABLE(acpi, at24_acpi_ids); 24140d8edc9SAndy Shevchenko 2425195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 2435195e509SWolfram Sang 2445195e509SWolfram Sang /* 2455195e509SWolfram Sang * This routine supports chips which consume multiple I2C addresses. It 2465195e509SWolfram Sang * computes the addressing information to be used for a given r/w request. 2475195e509SWolfram Sang * Assumes that sanity checks for offset happened at sysfs-layer. 2489afd6866SBartosz Golaszewski * 2499afd6866SBartosz Golaszewski * Slave address and byte offset derive from the offset. Always 2509afd6866SBartosz Golaszewski * set the byte address; on a multi-master board, another master 2519afd6866SBartosz Golaszewski * may have changed the chip's "current" address pointer. 2525195e509SWolfram Sang */ 25346049486SHeiner Kallweit static struct at24_client *at24_translate_offset(struct at24_data *at24, 2542da78ac3SBartosz Golaszewski unsigned int *offset) 2555195e509SWolfram Sang { 256aa4ce228SBartosz Golaszewski unsigned int i; 2575195e509SWolfram Sang 2585195e509SWolfram Sang if (at24->chip.flags & AT24_FLAG_ADDR16) { 2595195e509SWolfram Sang i = *offset >> 16; 2605195e509SWolfram Sang *offset &= 0xffff; 2615195e509SWolfram Sang } else { 2625195e509SWolfram Sang i = *offset >> 8; 2635195e509SWolfram Sang *offset &= 0xff; 2645195e509SWolfram Sang } 2655195e509SWolfram Sang 26646049486SHeiner Kallweit return &at24->client[i]; 2675195e509SWolfram Sang } 2685195e509SWolfram Sang 269e32213fbSSven Van Asbroeck static size_t at24_adjust_read_count(struct at24_data *at24, 270e32213fbSSven Van Asbroeck unsigned int offset, size_t count) 271e32213fbSSven Van Asbroeck { 272e32213fbSSven Van Asbroeck unsigned int bits; 273e32213fbSSven Van Asbroeck size_t remainder; 274e32213fbSSven Van Asbroeck 275e32213fbSSven Van Asbroeck /* 276e32213fbSSven Van Asbroeck * In case of multi-address chips that don't rollover reads to 277e32213fbSSven Van Asbroeck * the next slave address: truncate the count to the slave boundary, 278e32213fbSSven Van Asbroeck * so that the read never straddles slaves. 279e32213fbSSven Van Asbroeck */ 280e32213fbSSven Van Asbroeck if (at24->chip.flags & AT24_FLAG_NO_RDROL) { 281e32213fbSSven Van Asbroeck bits = (at24->chip.flags & AT24_FLAG_ADDR16) ? 16 : 8; 282e32213fbSSven Van Asbroeck remainder = BIT(bits) - offset; 283e32213fbSSven Van Asbroeck if (count > remainder) 284e32213fbSSven Van Asbroeck count = remainder; 285e32213fbSSven Van Asbroeck } 286e32213fbSSven Van Asbroeck 287ec3c2d51SBartosz Golaszewski if (count > at24_io_limit) 288ec3c2d51SBartosz Golaszewski count = at24_io_limit; 289e32213fbSSven Van Asbroeck 290e32213fbSSven Van Asbroeck return count; 291e32213fbSSven Van Asbroeck } 292e32213fbSSven Van Asbroeck 2934bb5c13cSHeiner Kallweit static ssize_t at24_regmap_read(struct at24_data *at24, char *buf, 2944bb5c13cSHeiner Kallweit unsigned int offset, size_t count) 2954bb5c13cSHeiner Kallweit { 2964bb5c13cSHeiner Kallweit unsigned long timeout, read_time; 2974bb5c13cSHeiner Kallweit struct at24_client *at24_client; 2984bb5c13cSHeiner Kallweit struct i2c_client *client; 2994bb5c13cSHeiner Kallweit struct regmap *regmap; 3004bb5c13cSHeiner Kallweit int ret; 3014bb5c13cSHeiner Kallweit 3024bb5c13cSHeiner Kallweit at24_client = at24_translate_offset(at24, &offset); 3034bb5c13cSHeiner Kallweit regmap = at24_client->regmap; 3044bb5c13cSHeiner Kallweit client = at24_client->client; 305e32213fbSSven Van Asbroeck count = at24_adjust_read_count(at24, offset, count); 3064bb5c13cSHeiner Kallweit 3074bb5c13cSHeiner Kallweit /* adjust offset for mac and serial read ops */ 3084bb5c13cSHeiner Kallweit offset += at24->offset_adj; 3094bb5c13cSHeiner Kallweit 310ec3c2d51SBartosz Golaszewski at24_loop_until_timeout(timeout, read_time) { 3114bb5c13cSHeiner Kallweit ret = regmap_bulk_read(regmap, offset, buf, count); 3124bb5c13cSHeiner Kallweit dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 3134bb5c13cSHeiner Kallweit count, offset, ret, jiffies); 3144bb5c13cSHeiner Kallweit if (!ret) 3154bb5c13cSHeiner Kallweit return count; 3164bb5c13cSHeiner Kallweit } 3174bb5c13cSHeiner Kallweit 3184bb5c13cSHeiner Kallweit return -ETIMEDOUT; 3194bb5c13cSHeiner Kallweit } 3204bb5c13cSHeiner Kallweit 3215195e509SWolfram Sang /* 3225195e509SWolfram Sang * Note that if the hardware write-protect pin is pulled high, the whole 3235195e509SWolfram Sang * chip is normally write protected. But there are plenty of product 3245195e509SWolfram Sang * variants here, including OTP fuses and partial chip protect. 3255195e509SWolfram Sang * 326cd0c8615SBartosz Golaszewski * We only use page mode writes; the alternative is sloooow. These routines 327cd0c8615SBartosz Golaszewski * write at most one page. 3285195e509SWolfram Sang */ 329cd0c8615SBartosz Golaszewski 330cd0c8615SBartosz Golaszewski static size_t at24_adjust_write_count(struct at24_data *at24, 3312da78ac3SBartosz Golaszewski unsigned int offset, size_t count) 3325195e509SWolfram Sang { 333aa4ce228SBartosz Golaszewski unsigned int next_page; 3345195e509SWolfram Sang 3355195e509SWolfram Sang /* write_max is at most a page */ 3365195e509SWolfram Sang if (count > at24->write_max) 3375195e509SWolfram Sang count = at24->write_max; 3385195e509SWolfram Sang 3395195e509SWolfram Sang /* Never roll over backwards, to the start of this page */ 3405195e509SWolfram Sang next_page = roundup(offset + 1, at24->chip.page_size); 3415195e509SWolfram Sang if (offset + count > next_page) 3425195e509SWolfram Sang count = next_page - offset; 3435195e509SWolfram Sang 344cd0c8615SBartosz Golaszewski return count; 345cd0c8615SBartosz Golaszewski } 346cd0c8615SBartosz Golaszewski 3478e5888e1SHeiner Kallweit static ssize_t at24_regmap_write(struct at24_data *at24, const char *buf, 3488e5888e1SHeiner Kallweit unsigned int offset, size_t count) 3498e5888e1SHeiner Kallweit { 3508e5888e1SHeiner Kallweit unsigned long timeout, write_time; 3518e5888e1SHeiner Kallweit struct at24_client *at24_client; 3528e5888e1SHeiner Kallweit struct i2c_client *client; 3538e5888e1SHeiner Kallweit struct regmap *regmap; 3548e5888e1SHeiner Kallweit int ret; 3558e5888e1SHeiner Kallweit 3568e5888e1SHeiner Kallweit at24_client = at24_translate_offset(at24, &offset); 3578e5888e1SHeiner Kallweit regmap = at24_client->regmap; 3588e5888e1SHeiner Kallweit client = at24_client->client; 3598e5888e1SHeiner Kallweit count = at24_adjust_write_count(at24, offset, count); 3608e5888e1SHeiner Kallweit 361ec3c2d51SBartosz Golaszewski at24_loop_until_timeout(timeout, write_time) { 3628e5888e1SHeiner Kallweit ret = regmap_bulk_write(regmap, offset, buf, count); 3638e5888e1SHeiner Kallweit dev_dbg(&client->dev, "write %zu@%d --> %d (%ld)\n", 3648e5888e1SHeiner Kallweit count, offset, ret, jiffies); 3658e5888e1SHeiner Kallweit if (!ret) 3668e5888e1SHeiner Kallweit return count; 3678e5888e1SHeiner Kallweit } 3688e5888e1SHeiner Kallweit 3698e5888e1SHeiner Kallweit return -ETIMEDOUT; 3708e5888e1SHeiner Kallweit } 3718e5888e1SHeiner Kallweit 372d5bc0047SBartosz Golaszewski static int at24_read(void *priv, unsigned int off, void *val, size_t count) 373d5bc0047SBartosz Golaszewski { 374d5bc0047SBartosz Golaszewski struct at24_data *at24 = priv; 3755c015258SHeiner Kallweit struct device *dev = &at24->client[0].client->dev; 376d5bc0047SBartosz Golaszewski char *buf = val; 37798e82010SDivagar Mohandass int ret; 378d5bc0047SBartosz Golaszewski 379d5bc0047SBartosz Golaszewski if (unlikely(!count)) 380d5bc0047SBartosz Golaszewski return count; 381d5bc0047SBartosz Golaszewski 382d9bcd462SHeiner Kallweit if (off + count > at24->chip.byte_len) 383d9bcd462SHeiner Kallweit return -EINVAL; 384d9bcd462SHeiner Kallweit 385f9ecc83fSSakari Ailus ret = pm_runtime_get_sync(dev); 38698e82010SDivagar Mohandass if (ret < 0) { 387f9ecc83fSSakari Ailus pm_runtime_put_noidle(dev); 38898e82010SDivagar Mohandass return ret; 38998e82010SDivagar Mohandass } 39098e82010SDivagar Mohandass 391d5bc0047SBartosz Golaszewski /* 392d5bc0047SBartosz Golaszewski * Read data from chip, protecting against concurrent updates 393d5bc0047SBartosz Golaszewski * from this host, but not from other I2C masters. 394d5bc0047SBartosz Golaszewski */ 395d5bc0047SBartosz Golaszewski mutex_lock(&at24->lock); 396d5bc0047SBartosz Golaszewski 397d5bc0047SBartosz Golaszewski while (count) { 398d5bc0047SBartosz Golaszewski int status; 399d5bc0047SBartosz Golaszewski 4004bb5c13cSHeiner Kallweit status = at24_regmap_read(at24, buf, off, count); 401d5bc0047SBartosz Golaszewski if (status < 0) { 402d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 403f9ecc83fSSakari Ailus pm_runtime_put(dev); 404d5bc0047SBartosz Golaszewski return status; 405d5bc0047SBartosz Golaszewski } 406d5bc0047SBartosz Golaszewski buf += status; 407d5bc0047SBartosz Golaszewski off += status; 408d5bc0047SBartosz Golaszewski count -= status; 409d5bc0047SBartosz Golaszewski } 410d5bc0047SBartosz Golaszewski 411d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock); 412d5bc0047SBartosz Golaszewski 413f9ecc83fSSakari Ailus pm_runtime_put(dev); 41498e82010SDivagar Mohandass 415d5bc0047SBartosz Golaszewski return 0; 416d5bc0047SBartosz Golaszewski } 417d5bc0047SBartosz Golaszewski 418cf0361a2SSrinivas Kandagatla static int at24_write(void *priv, unsigned int off, void *val, size_t count) 4195195e509SWolfram Sang { 420cf0361a2SSrinivas Kandagatla struct at24_data *at24 = priv; 4215c015258SHeiner Kallweit struct device *dev = &at24->client[0].client->dev; 422cf0361a2SSrinivas Kandagatla char *buf = val; 42398e82010SDivagar Mohandass int ret; 4245195e509SWolfram Sang 4255195e509SWolfram Sang if (unlikely(!count)) 426cf0361a2SSrinivas Kandagatla return -EINVAL; 4275195e509SWolfram Sang 428d9bcd462SHeiner Kallweit if (off + count > at24->chip.byte_len) 429d9bcd462SHeiner Kallweit return -EINVAL; 430d9bcd462SHeiner Kallweit 431f9ecc83fSSakari Ailus ret = pm_runtime_get_sync(dev); 43298e82010SDivagar Mohandass if (ret < 0) { 433f9ecc83fSSakari Ailus pm_runtime_put_noidle(dev); 43498e82010SDivagar Mohandass return ret; 43598e82010SDivagar Mohandass } 43698e82010SDivagar Mohandass 4375195e509SWolfram Sang /* 4385195e509SWolfram Sang * Write data to chip, protecting against concurrent updates 4395195e509SWolfram Sang * from this host, but not from other I2C masters. 4405195e509SWolfram Sang */ 4415195e509SWolfram Sang mutex_lock(&at24->lock); 4426ce261e8SBartosz Golaszewski gpiod_set_value_cansleep(at24->wp_gpio, 0); 4435195e509SWolfram Sang 4445195e509SWolfram Sang while (count) { 445cf0361a2SSrinivas Kandagatla int status; 4465195e509SWolfram Sang 4478e5888e1SHeiner Kallweit status = at24_regmap_write(at24, buf, off, count); 448cf0361a2SSrinivas Kandagatla if (status < 0) { 4496ce261e8SBartosz Golaszewski gpiod_set_value_cansleep(at24->wp_gpio, 1); 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 4596ce261e8SBartosz Golaszewski gpiod_set_value_cansleep(at24->wp_gpio, 1); 4605195e509SWolfram Sang mutex_unlock(&at24->lock); 4615195e509SWolfram Sang 462f9ecc83fSSakari Ailus pm_runtime_put(dev); 46398e82010SDivagar Mohandass 46457d15550SAndrew Lunn return 0; 46557d15550SAndrew Lunn } 46657d15550SAndrew Lunn 467dd905a61SBen Gardner static void at24_get_pdata(struct device *dev, struct at24_platform_data *chip) 4689ed030d7SWolfram Sang { 469dd905a61SBen Gardner int err; 470dd905a61SBen Gardner u32 val; 4719ed030d7SWolfram Sang 472dd905a61SBen Gardner if (device_property_present(dev, "read-only")) 4739ed030d7SWolfram Sang chip->flags |= AT24_FLAG_READONLY; 474e32213fbSSven Van Asbroeck if (device_property_present(dev, "no-read-rollover")) 475e32213fbSSven Van Asbroeck chip->flags |= AT24_FLAG_NO_RDROL; 476dd905a61SBen Gardner 477dbc1ab9cSDivagar Mohandass err = device_property_read_u32(dev, "size", &val); 478dbc1ab9cSDivagar Mohandass if (!err) 479dbc1ab9cSDivagar Mohandass chip->byte_len = val; 480dbc1ab9cSDivagar Mohandass 481dd905a61SBen Gardner err = device_property_read_u32(dev, "pagesize", &val); 482dd905a61SBen Gardner if (!err) { 483dd905a61SBen Gardner chip->page_size = val; 484dd905a61SBen Gardner } else { 485dd905a61SBen Gardner /* 486dd905a61SBen Gardner * This is slow, but we can't know all eeproms, so we better 487dd905a61SBen Gardner * play safe. Specifying custom eeprom-types via platform_data 488dd905a61SBen Gardner * is recommended anyhow. 489dd905a61SBen Gardner */ 490dd905a61SBen Gardner chip->page_size = 1; 4919ed030d7SWolfram Sang } 4929ed030d7SWolfram Sang } 4939ed030d7SWolfram Sang 4944bb5c13cSHeiner Kallweit static unsigned int at24_get_offset_adj(u8 flags, unsigned int byte_len) 4954bb5c13cSHeiner Kallweit { 4964bb5c13cSHeiner Kallweit if (flags & AT24_FLAG_MAC) { 4974bb5c13cSHeiner Kallweit /* EUI-48 starts from 0x9a, EUI-64 from 0x98 */ 4984bb5c13cSHeiner Kallweit return 0xa0 - byte_len; 4994bb5c13cSHeiner Kallweit } else if (flags & AT24_FLAG_SERIAL && flags & AT24_FLAG_ADDR16) { 5004bb5c13cSHeiner Kallweit /* 5014bb5c13cSHeiner Kallweit * For 16 bit address pointers, the word address must contain 5024bb5c13cSHeiner Kallweit * a '10' sequence in bits 11 and 10 regardless of the 5034bb5c13cSHeiner Kallweit * intended position of the address pointer. 5044bb5c13cSHeiner Kallweit */ 5054bb5c13cSHeiner Kallweit return 0x0800; 5064bb5c13cSHeiner Kallweit } else if (flags & AT24_FLAG_SERIAL) { 5074bb5c13cSHeiner Kallweit /* 5084bb5c13cSHeiner Kallweit * Otherwise the word address must begin with a '10' sequence, 5094bb5c13cSHeiner Kallweit * regardless of the intended address. 5104bb5c13cSHeiner Kallweit */ 5114bb5c13cSHeiner Kallweit return 0x0080; 5124bb5c13cSHeiner Kallweit } else { 5134bb5c13cSHeiner Kallweit return 0; 5144bb5c13cSHeiner Kallweit } 5154bb5c13cSHeiner Kallweit } 5164bb5c13cSHeiner Kallweit 5175195e509SWolfram Sang static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) 5185195e509SWolfram Sang { 519b680f4faSSven Van Asbroeck struct at24_platform_data chip = { 0 }; 520b680f4faSSven Van Asbroeck const struct at24_chip_data *cd = NULL; 5215195e509SWolfram Sang bool writable; 5225195e509SWolfram Sang struct at24_data *at24; 5235195e509SWolfram Sang int err; 524aa4ce228SBartosz Golaszewski unsigned int i, num_addresses; 525eef69398SBartosz Golaszewski struct regmap_config regmap_config = { }; 52600f0ea70SBartosz Golaszewski u8 test_byte; 5275195e509SWolfram Sang 5285195e509SWolfram Sang if (client->dev.platform_data) { 5295195e509SWolfram Sang chip = *(struct at24_platform_data *)client->dev.platform_data; 5305195e509SWolfram Sang } else { 5317f2a2f0dSJavier Martinez Canillas /* 5327f2a2f0dSJavier Martinez Canillas * The I2C core allows OF nodes compatibles to match against the 5337f2a2f0dSJavier Martinez Canillas * I2C device ID table as a fallback, so check not only if an OF 5347f2a2f0dSJavier Martinez Canillas * node is present but also if it matches an OF device ID entry. 5357f2a2f0dSJavier Martinez Canillas */ 5367f2a2f0dSJavier Martinez Canillas if (client->dev.of_node && 5377f2a2f0dSJavier Martinez Canillas of_match_device(at24_of_match, &client->dev)) { 538b680f4faSSven Van Asbroeck cd = of_device_get_match_data(&client->dev); 5397f2a2f0dSJavier Martinez Canillas } else if (id) { 540b680f4faSSven Van Asbroeck cd = (void *)id->driver_data; 54140d8edc9SAndy Shevchenko } else { 54240d8edc9SAndy Shevchenko const struct acpi_device_id *aid; 54340d8edc9SAndy Shevchenko 54440d8edc9SAndy Shevchenko aid = acpi_match_device(at24_acpi_ids, &client->dev); 54540d8edc9SAndy Shevchenko if (aid) 546b680f4faSSven Van Asbroeck cd = (void *)aid->driver_data; 54740d8edc9SAndy Shevchenko } 548b680f4faSSven Van Asbroeck if (!cd) 549f0ac2363SNikolay Balandin return -ENODEV; 550f0ac2363SNikolay Balandin 551b680f4faSSven Van Asbroeck chip.byte_len = cd->byte_len; 552b680f4faSSven Van Asbroeck chip.flags = cd->flags; 553dd905a61SBen Gardner at24_get_pdata(&client->dev, &chip); 5545195e509SWolfram Sang } 5555195e509SWolfram Sang 5565195e509SWolfram Sang if (!is_power_of_2(chip.byte_len)) 5575195e509SWolfram Sang dev_warn(&client->dev, 5585195e509SWolfram Sang "byte_len looks suspicious (no power of 2)!\n"); 55945efe847SWolfram Sang if (!chip.page_size) { 56045efe847SWolfram Sang dev_err(&client->dev, "page_size must not be 0!\n"); 561f0ac2363SNikolay Balandin return -EINVAL; 56245efe847SWolfram Sang } 5635195e509SWolfram Sang if (!is_power_of_2(chip.page_size)) 5645195e509SWolfram Sang dev_warn(&client->dev, 5655195e509SWolfram Sang "page_size looks suspicious (no power of 2)!\n"); 5665195e509SWolfram Sang 567a23727cbSHeiner Kallweit if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C) && 568a23727cbSHeiner Kallweit !i2c_check_functionality(client->adapter, 569a23727cbSHeiner Kallweit I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) 570a839ce66SChristian Gmeiner chip.page_size = 1; 571a839ce66SChristian Gmeiner 5725195e509SWolfram Sang if (chip.flags & AT24_FLAG_TAKE8ADDR) 5735195e509SWolfram Sang num_addresses = 8; 5745195e509SWolfram Sang else 5755195e509SWolfram Sang num_addresses = DIV_ROUND_UP(chip.byte_len, 5765195e509SWolfram Sang (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256); 5775195e509SWolfram Sang 578eef69398SBartosz Golaszewski regmap_config.val_bits = 8; 579eef69398SBartosz Golaszewski regmap_config.reg_bits = (chip.flags & AT24_FLAG_ADDR16) ? 16 : 8; 5805c015258SHeiner Kallweit 581f0ac2363SNikolay Balandin at24 = devm_kzalloc(&client->dev, sizeof(struct at24_data) + 5825c015258SHeiner Kallweit num_addresses * sizeof(struct at24_client), GFP_KERNEL); 583f0ac2363SNikolay Balandin if (!at24) 584f0ac2363SNikolay Balandin return -ENOMEM; 5855195e509SWolfram Sang 5865195e509SWolfram Sang mutex_init(&at24->lock); 5875195e509SWolfram Sang at24->chip = chip; 5885195e509SWolfram Sang at24->num_addresses = num_addresses; 5894bb5c13cSHeiner Kallweit at24->offset_adj = at24_get_offset_adj(chip.flags, chip.byte_len); 5905195e509SWolfram Sang 5916ce261e8SBartosz Golaszewski at24->wp_gpio = devm_gpiod_get_optional(&client->dev, 5926ce261e8SBartosz Golaszewski "wp", GPIOD_OUT_HIGH); 5936ce261e8SBartosz Golaszewski if (IS_ERR(at24->wp_gpio)) 5946ce261e8SBartosz Golaszewski return PTR_ERR(at24->wp_gpio); 5956ce261e8SBartosz Golaszewski 5965c015258SHeiner Kallweit at24->client[0].client = client; 597eef69398SBartosz Golaszewski at24->client[0].regmap = devm_regmap_init_i2c(client, ®map_config); 5985c015258SHeiner Kallweit if (IS_ERR(at24->client[0].regmap)) 5995c015258SHeiner Kallweit return PTR_ERR(at24->client[0].regmap); 6005c015258SHeiner Kallweit 6010b813658SBartosz Golaszewski if ((chip.flags & AT24_FLAG_SERIAL) && (chip.flags & AT24_FLAG_MAC)) { 6020b813658SBartosz Golaszewski dev_err(&client->dev, 6030b813658SBartosz Golaszewski "invalid device data - cannot have both AT24_FLAG_SERIAL & AT24_FLAG_MAC."); 6040b813658SBartosz Golaszewski return -EINVAL; 6050b813658SBartosz Golaszewski } 6060b813658SBartosz Golaszewski 6075195e509SWolfram Sang writable = !(chip.flags & AT24_FLAG_READONLY); 6085195e509SWolfram Sang if (writable) { 609ec3c2d51SBartosz Golaszewski at24->write_max = min_t(unsigned int, 610ec3c2d51SBartosz Golaszewski chip.page_size, at24_io_limit); 611a23727cbSHeiner Kallweit if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C) && 612a23727cbSHeiner Kallweit at24->write_max > I2C_SMBUS_BLOCK_MAX) 613a23727cbSHeiner Kallweit at24->write_max = I2C_SMBUS_BLOCK_MAX; 6145195e509SWolfram Sang } 6155195e509SWolfram Sang 6165195e509SWolfram Sang /* use dummy devices for multiple-address chips */ 6175195e509SWolfram Sang for (i = 1; i < num_addresses; i++) { 6185c015258SHeiner Kallweit at24->client[i].client = i2c_new_dummy(client->adapter, 6195195e509SWolfram Sang client->addr + i); 6205c015258SHeiner Kallweit if (!at24->client[i].client) { 6215195e509SWolfram Sang dev_err(&client->dev, "address 0x%02x unavailable\n", 6225195e509SWolfram Sang client->addr + i); 6235195e509SWolfram Sang err = -EADDRINUSE; 6245195e509SWolfram Sang goto err_clients; 6255195e509SWolfram Sang } 6265c015258SHeiner Kallweit at24->client[i].regmap = devm_regmap_init_i2c( 627eef69398SBartosz Golaszewski at24->client[i].client, 628eef69398SBartosz Golaszewski ®map_config); 6295c015258SHeiner Kallweit if (IS_ERR(at24->client[i].regmap)) { 6305c015258SHeiner Kallweit err = PTR_ERR(at24->client[i].regmap); 6315c015258SHeiner Kallweit goto err_clients; 6325c015258SHeiner Kallweit } 6335195e509SWolfram Sang } 6345195e509SWolfram Sang 63500f0ea70SBartosz Golaszewski i2c_set_clientdata(client, at24); 63600f0ea70SBartosz Golaszewski 63798e82010SDivagar Mohandass /* enable runtime pm */ 63898e82010SDivagar Mohandass pm_runtime_set_active(&client->dev); 63998e82010SDivagar Mohandass pm_runtime_enable(&client->dev); 64098e82010SDivagar Mohandass 64100f0ea70SBartosz Golaszewski /* 64200f0ea70SBartosz Golaszewski * Perform a one-byte test read to verify that the 64300f0ea70SBartosz Golaszewski * chip is functional. 64400f0ea70SBartosz Golaszewski */ 64500f0ea70SBartosz Golaszewski err = at24_read(at24, 0, &test_byte, 1); 64698e82010SDivagar Mohandass pm_runtime_idle(&client->dev); 64700f0ea70SBartosz Golaszewski if (err) { 64800f0ea70SBartosz Golaszewski err = -ENODEV; 64900f0ea70SBartosz Golaszewski goto err_clients; 65000f0ea70SBartosz Golaszewski } 65100f0ea70SBartosz Golaszewski 65257d15550SAndrew Lunn at24->nvmem_config.name = dev_name(&client->dev); 65357d15550SAndrew Lunn at24->nvmem_config.dev = &client->dev; 65457d15550SAndrew Lunn at24->nvmem_config.read_only = !writable; 65557d15550SAndrew Lunn at24->nvmem_config.root_only = true; 65657d15550SAndrew Lunn at24->nvmem_config.owner = THIS_MODULE; 65757d15550SAndrew Lunn at24->nvmem_config.compat = true; 65857d15550SAndrew Lunn at24->nvmem_config.base_dev = &client->dev; 659cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_read = at24_read; 660cf0361a2SSrinivas Kandagatla at24->nvmem_config.reg_write = at24_write; 661cf0361a2SSrinivas Kandagatla at24->nvmem_config.priv = at24; 6627f6d2ecdSDavid Lechner at24->nvmem_config.stride = 1; 663cf0361a2SSrinivas Kandagatla at24->nvmem_config.word_size = 1; 664cf0361a2SSrinivas Kandagatla at24->nvmem_config.size = chip.byte_len; 66557d15550SAndrew Lunn 66657d15550SAndrew Lunn at24->nvmem = nvmem_register(&at24->nvmem_config); 66757d15550SAndrew Lunn 66857d15550SAndrew Lunn if (IS_ERR(at24->nvmem)) { 66957d15550SAndrew Lunn err = PTR_ERR(at24->nvmem); 67057d15550SAndrew Lunn goto err_clients; 67157d15550SAndrew Lunn } 6725195e509SWolfram Sang 67357d15550SAndrew Lunn dev_info(&client->dev, "%u byte %s EEPROM, %s, %u bytes/write\n", 67457d15550SAndrew Lunn chip.byte_len, client->name, 6759ed030d7SWolfram Sang writable ? "writable" : "read-only", at24->write_max); 6765195e509SWolfram Sang 6777274ec8bSKevin Hilman /* export data to kernel code */ 6787274ec8bSKevin Hilman if (chip.setup) 679bec3c11bSAndrew Lunn chip.setup(at24->nvmem, chip.context); 6807274ec8bSKevin Hilman 6815195e509SWolfram Sang return 0; 6825195e509SWolfram Sang 6835195e509SWolfram Sang err_clients: 6845195e509SWolfram Sang for (i = 1; i < num_addresses; i++) 6855c015258SHeiner Kallweit if (at24->client[i].client) 6865c015258SHeiner Kallweit i2c_unregister_device(at24->client[i].client); 6875195e509SWolfram Sang 68898e82010SDivagar Mohandass pm_runtime_disable(&client->dev); 68998e82010SDivagar Mohandass 6905195e509SWolfram Sang return err; 6915195e509SWolfram Sang } 6925195e509SWolfram Sang 693486a5c28SBill Pemberton static int at24_remove(struct i2c_client *client) 6945195e509SWolfram Sang { 6955195e509SWolfram Sang struct at24_data *at24; 6965195e509SWolfram Sang int i; 6975195e509SWolfram Sang 6985195e509SWolfram Sang at24 = i2c_get_clientdata(client); 69957d15550SAndrew Lunn 70057d15550SAndrew Lunn nvmem_unregister(at24->nvmem); 7015195e509SWolfram Sang 7025195e509SWolfram Sang for (i = 1; i < at24->num_addresses; i++) 7035c015258SHeiner Kallweit i2c_unregister_device(at24->client[i].client); 7045195e509SWolfram Sang 70598e82010SDivagar Mohandass pm_runtime_disable(&client->dev); 70698e82010SDivagar Mohandass pm_runtime_set_suspended(&client->dev); 70798e82010SDivagar Mohandass 7085195e509SWolfram Sang return 0; 7095195e509SWolfram Sang } 7105195e509SWolfram Sang 7115195e509SWolfram Sang /*-------------------------------------------------------------------------*/ 7125195e509SWolfram Sang 7135195e509SWolfram Sang static struct i2c_driver at24_driver = { 7145195e509SWolfram Sang .driver = { 7155195e509SWolfram Sang .name = "at24", 7167f2a2f0dSJavier Martinez Canillas .of_match_table = at24_of_match, 71740d8edc9SAndy Shevchenko .acpi_match_table = ACPI_PTR(at24_acpi_ids), 7185195e509SWolfram Sang }, 7195195e509SWolfram Sang .probe = at24_probe, 7202d6bed9cSBill Pemberton .remove = at24_remove, 7215195e509SWolfram Sang .id_table = at24_ids, 7225195e509SWolfram Sang }; 7235195e509SWolfram Sang 7245195e509SWolfram Sang static int __init at24_init(void) 7255195e509SWolfram Sang { 726ec3c2d51SBartosz Golaszewski if (!at24_io_limit) { 727ec3c2d51SBartosz Golaszewski pr_err("at24: at24_io_limit must not be 0!\n"); 72845efe847SWolfram Sang return -EINVAL; 72945efe847SWolfram Sang } 73045efe847SWolfram Sang 731ec3c2d51SBartosz Golaszewski at24_io_limit = rounddown_pow_of_two(at24_io_limit); 7325195e509SWolfram Sang return i2c_add_driver(&at24_driver); 7335195e509SWolfram Sang } 7345195e509SWolfram Sang module_init(at24_init); 7355195e509SWolfram Sang 7365195e509SWolfram Sang static void __exit at24_exit(void) 7375195e509SWolfram Sang { 7385195e509SWolfram Sang i2c_del_driver(&at24_driver); 7395195e509SWolfram Sang } 7405195e509SWolfram Sang module_exit(at24_exit); 7415195e509SWolfram Sang 7425195e509SWolfram Sang MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); 7435195e509SWolfram Sang MODULE_AUTHOR("David Brownell and Wolfram Sang"); 7445195e509SWolfram Sang MODULE_LICENSE("GPL"); 745