1567ec716SBartosz Golaszewski // SPDX-License-Identifier: GPL-2.0-or-later
25195e509SWolfram Sang /*
35195e509SWolfram Sang * at24.c - handle most I2C EEPROMs
45195e509SWolfram Sang *
55195e509SWolfram Sang * Copyright (C) 2005-2007 David Brownell
65195e509SWolfram Sang * Copyright (C) 2008 Wolfram Sang, Pengutronix
75195e509SWolfram Sang */
84ac0d3fbSBartosz Golaszewski
940d8edc9SAndy Shevchenko #include <linux/acpi.h>
1069afc4b6SBartosz Golaszewski #include <linux/bitops.h>
11a4423cedSJean Delvare #include <linux/capability.h>
1269afc4b6SBartosz Golaszewski #include <linux/delay.h>
1369afc4b6SBartosz Golaszewski #include <linux/i2c.h>
1469afc4b6SBartosz Golaszewski #include <linux/init.h>
1569afc4b6SBartosz Golaszewski #include <linux/jiffies.h>
1669afc4b6SBartosz Golaszewski #include <linux/kernel.h>
1769afc4b6SBartosz Golaszewski #include <linux/mod_devicetable.h>
1869afc4b6SBartosz Golaszewski #include <linux/module.h>
1969afc4b6SBartosz Golaszewski #include <linux/mutex.h>
2069afc4b6SBartosz Golaszewski #include <linux/nvmem-provider.h>
2169afc4b6SBartosz Golaszewski #include <linux/of_device.h>
2269afc4b6SBartosz Golaszewski #include <linux/pm_runtime.h>
2369afc4b6SBartosz Golaszewski #include <linux/property.h>
2469afc4b6SBartosz Golaszewski #include <linux/regmap.h>
25cd5676dbSBibby Hsieh #include <linux/regulator/consumer.h>
2669afc4b6SBartosz Golaszewski #include <linux/slab.h>
275195e509SWolfram Sang
284fa882c9SBartosz Golaszewski /* Address pointer is 16 bit. */
294fa882c9SBartosz Golaszewski #define AT24_FLAG_ADDR16 BIT(7)
304fa882c9SBartosz Golaszewski /* sysfs-entry will be read-only. */
314fa882c9SBartosz Golaszewski #define AT24_FLAG_READONLY BIT(6)
324fa882c9SBartosz Golaszewski /* sysfs-entry will be world-readable. */
334fa882c9SBartosz Golaszewski #define AT24_FLAG_IRUGO BIT(5)
344fa882c9SBartosz Golaszewski /* Take always 8 addresses (24c00). */
354fa882c9SBartosz Golaszewski #define AT24_FLAG_TAKE8ADDR BIT(4)
364fa882c9SBartosz Golaszewski /* Factory-programmed serial number. */
374fa882c9SBartosz Golaszewski #define AT24_FLAG_SERIAL BIT(3)
384fa882c9SBartosz Golaszewski /* Factory-programmed mac address. */
394fa882c9SBartosz Golaszewski #define AT24_FLAG_MAC BIT(2)
404fa882c9SBartosz Golaszewski /* Does not auto-rollover reads to the next slave address. */
414fa882c9SBartosz Golaszewski #define AT24_FLAG_NO_RDROL BIT(1)
424fa882c9SBartosz Golaszewski
435195e509SWolfram Sang /*
445195e509SWolfram Sang * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable.
455195e509SWolfram Sang * Differences between different vendor product lines (like Atmel AT24C or
465195e509SWolfram Sang * MicroChip 24LC, etc) won't much matter for typical read/write access.
475195e509SWolfram Sang * There are also I2C RAM chips, likewise interchangeable. One example
485195e509SWolfram Sang * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes).
495195e509SWolfram Sang *
505195e509SWolfram Sang * However, misconfiguration can lose data. "Set 16-bit memory address"
515195e509SWolfram Sang * to a part with 8-bit addressing will overwrite data. Writing with too
525195e509SWolfram Sang * big a page size also loses data. And it's not safe to assume that the
535195e509SWolfram Sang * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC
545195e509SWolfram Sang * uses 0x51, for just one example.
555195e509SWolfram Sang *
565195e509SWolfram Sang * Accordingly, explicit board-specific configuration data should be used
575195e509SWolfram Sang * in almost all cases. (One partial exception is an SMBus used to access
585195e509SWolfram Sang * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.)
595195e509SWolfram Sang *
605195e509SWolfram Sang * So this driver uses "new style" I2C driver binding, expecting to be
615195e509SWolfram Sang * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or
625195e509SWolfram Sang * similar kernel-resident tables; or, configuration data coming from
635195e509SWolfram Sang * a bootloader.
645195e509SWolfram Sang *
655195e509SWolfram Sang * Other than binding model, current differences from "eeprom" driver are
665195e509SWolfram Sang * that this one handles write access and isn't restricted to 24c02 devices.
675195e509SWolfram Sang * It also handles larger devices (32 kbit and up) with two-byte addresses,
685195e509SWolfram Sang * which won't work on pure SMBus systems.
695195e509SWolfram Sang */
705195e509SWolfram Sang
715195e509SWolfram Sang struct at24_data {
725195e509SWolfram Sang /*
735195e509SWolfram Sang * Lock protects against activities from other Linux tasks,
745195e509SWolfram Sang * but not from changes by other I2C masters.
755195e509SWolfram Sang */
765195e509SWolfram Sang struct mutex lock;
775195e509SWolfram Sang
78aa4ce228SBartosz Golaszewski unsigned int write_max;
79aa4ce228SBartosz Golaszewski unsigned int num_addresses;
804bb5c13cSHeiner Kallweit unsigned int offset_adj;
815195e509SWolfram Sang
827c280664SBartosz Golaszewski u32 byte_len;
837c280664SBartosz Golaszewski u16 page_size;
847c280664SBartosz Golaszewski u8 flags;
857c280664SBartosz Golaszewski
8657d15550SAndrew Lunn struct nvmem_device *nvmem;
87cd5676dbSBibby Hsieh struct regulator *vcc_reg;
88a4423cedSJean Delvare void (*read_post)(unsigned int off, char *buf, size_t count);
8957d15550SAndrew Lunn
905195e509SWolfram Sang /*
915195e509SWolfram Sang * Some chips tie up multiple I2C addresses; dummy devices reserve
9292e17647SHeiner Kallweit * them for us.
935195e509SWolfram Sang */
94d08aea21SMaxim Kochetkov u8 bank_addr_shift;
9592e17647SHeiner Kallweit struct regmap *client_regmaps[];
965195e509SWolfram Sang };
975195e509SWolfram Sang
985195e509SWolfram Sang /*
995195e509SWolfram Sang * This parameter is to help this driver avoid blocking other drivers out
1005195e509SWolfram Sang * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C
1015195e509SWolfram Sang * clock, one 256 byte read takes about 1/43 second which is excessive;
1025195e509SWolfram Sang * but the 1/170 second it takes at 400 kHz may be quite reasonable; and
1035195e509SWolfram Sang * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible.
1045195e509SWolfram Sang *
1055195e509SWolfram Sang * This value is forced to be a power of two so that writes align on pages.
1065195e509SWolfram Sang */
107ec3c2d51SBartosz Golaszewski static unsigned int at24_io_limit = 128;
108ec3c2d51SBartosz Golaszewski module_param_named(io_limit, at24_io_limit, uint, 0);
109ec3c2d51SBartosz Golaszewski MODULE_PARM_DESC(at24_io_limit, "Maximum bytes per I/O (default 128)");
1105195e509SWolfram Sang
1115195e509SWolfram Sang /*
1125195e509SWolfram Sang * Specs often allow 5 msec for a page write, sometimes 20 msec;
1135195e509SWolfram Sang * it's important to recover from write timeouts.
1145195e509SWolfram Sang */
115ec3c2d51SBartosz Golaszewski static unsigned int at24_write_timeout = 25;
116ec3c2d51SBartosz Golaszewski module_param_named(write_timeout, at24_write_timeout, uint, 0);
117ec3c2d51SBartosz Golaszewski MODULE_PARM_DESC(at24_write_timeout, "Time (in ms) to try writes (default 25)");
1185195e509SWolfram Sang
119b680f4faSSven Van Asbroeck struct at24_chip_data {
120b680f4faSSven Van Asbroeck u32 byte_len;
121b680f4faSSven Van Asbroeck u8 flags;
122d08aea21SMaxim Kochetkov u8 bank_addr_shift;
123a4423cedSJean Delvare void (*read_post)(unsigned int off, char *buf, size_t count);
124b680f4faSSven Van Asbroeck };
125b680f4faSSven Van Asbroeck
126b680f4faSSven Van Asbroeck #define AT24_CHIP_DATA(_name, _len, _flags) \
127b680f4faSSven Van Asbroeck static const struct at24_chip_data _name = { \
128b680f4faSSven Van Asbroeck .byte_len = _len, .flags = _flags, \
129b680f4faSSven Van Asbroeck }
130b680f4faSSven Van Asbroeck
131a4423cedSJean Delvare #define AT24_CHIP_DATA_CB(_name, _len, _flags, _read_post) \
132a4423cedSJean Delvare static const struct at24_chip_data _name = { \
133a4423cedSJean Delvare .byte_len = _len, .flags = _flags, \
134a4423cedSJean Delvare .read_post = _read_post, \
135a4423cedSJean Delvare }
136a4423cedSJean Delvare
137d08aea21SMaxim Kochetkov #define AT24_CHIP_DATA_BS(_name, _len, _flags, _bank_addr_shift) \
138d08aea21SMaxim Kochetkov static const struct at24_chip_data _name = { \
139d08aea21SMaxim Kochetkov .byte_len = _len, .flags = _flags, \
140d08aea21SMaxim Kochetkov .bank_addr_shift = _bank_addr_shift \
141d08aea21SMaxim Kochetkov }
142d08aea21SMaxim Kochetkov
at24_read_post_vaio(unsigned int off,char * buf,size_t count)143a4423cedSJean Delvare static void at24_read_post_vaio(unsigned int off, char *buf, size_t count)
144a4423cedSJean Delvare {
145a4423cedSJean Delvare int i;
146a4423cedSJean Delvare
147a4423cedSJean Delvare if (capable(CAP_SYS_ADMIN))
148a4423cedSJean Delvare return;
149a4423cedSJean Delvare
150a4423cedSJean Delvare /*
151a4423cedSJean Delvare * Hide VAIO private settings to regular users:
152a4423cedSJean Delvare * - BIOS passwords: bytes 0x00 to 0x0f
153a4423cedSJean Delvare * - UUID: bytes 0x10 to 0x1f
154a4423cedSJean Delvare * - Serial number: 0xc0 to 0xdf
155a4423cedSJean Delvare */
156a4423cedSJean Delvare for (i = 0; i < count; i++) {
157a4423cedSJean Delvare if ((off + i <= 0x1f) ||
158a4423cedSJean Delvare (off + i >= 0xc0 && off + i <= 0xdf))
159a4423cedSJean Delvare buf[i] = 0;
160a4423cedSJean Delvare }
161a4423cedSJean Delvare }
162a4423cedSJean Delvare
1635195e509SWolfram Sang /* needs 8 addresses as A0-A2 are ignored */
164b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c00, 128 / 8, AT24_FLAG_TAKE8ADDR);
1655195e509SWolfram Sang /* old variants can't be handled with this generic entry! */
166b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c01, 1024 / 8, 0);
167b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs01, 16,
168b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
169b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c02, 2048 / 8, 0);
170b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs02, 16,
171b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
172b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24mac402, 48 / 8,
173b680f4faSSven Van Asbroeck AT24_FLAG_MAC | AT24_FLAG_READONLY);
174b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24mac602, 64 / 8,
175b680f4faSSven Van Asbroeck AT24_FLAG_MAC | AT24_FLAG_READONLY);
1765195e509SWolfram Sang /* spd is a 24c02 in memory DIMMs */
177b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_spd, 2048 / 8,
178b680f4faSSven Van Asbroeck AT24_FLAG_READONLY | AT24_FLAG_IRUGO);
179a4423cedSJean Delvare /* 24c02_vaio is a 24c02 on some Sony laptops */
180a4423cedSJean Delvare AT24_CHIP_DATA_CB(at24_data_24c02_vaio, 2048 / 8,
181a4423cedSJean Delvare AT24_FLAG_READONLY | AT24_FLAG_IRUGO,
182a4423cedSJean Delvare at24_read_post_vaio);
183b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c04, 4096 / 8, 0);
184b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs04, 16,
185b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
1865195e509SWolfram Sang /* 24rf08 quirk is handled at i2c-core */
187b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c08, 8192 / 8, 0);
188b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs08, 16,
189b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
190b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c16, 16384 / 8, 0);
191b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs16, 16,
192b680f4faSSven Van Asbroeck AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
193b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c32, 32768 / 8, AT24_FLAG_ADDR16);
194b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs32, 16,
195b680f4faSSven Van Asbroeck AT24_FLAG_ADDR16 | AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
196b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c64, 65536 / 8, AT24_FLAG_ADDR16);
197b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24cs64, 16,
198b680f4faSSven Van Asbroeck AT24_FLAG_ADDR16 | AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
199b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c128, 131072 / 8, AT24_FLAG_ADDR16);
200b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c256, 262144 / 8, AT24_FLAG_ADDR16);
201b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c512, 524288 / 8, AT24_FLAG_ADDR16);
202b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_24c1024, 1048576 / 8, AT24_FLAG_ADDR16);
203d08aea21SMaxim Kochetkov AT24_CHIP_DATA_BS(at24_data_24c1025, 1048576 / 8, AT24_FLAG_ADDR16, 2);
20437cf28d3SAdrian Bunk AT24_CHIP_DATA(at24_data_24c2048, 2097152 / 8, AT24_FLAG_ADDR16);
205b680f4faSSven Van Asbroeck /* identical to 24c08 ? */
206b680f4faSSven Van Asbroeck AT24_CHIP_DATA(at24_data_INT3499, 8192 / 8, 0);
207b680f4faSSven Van Asbroeck
208b680f4faSSven Van Asbroeck static const struct i2c_device_id at24_ids[] = {
209b680f4faSSven Van Asbroeck { "24c00", (kernel_ulong_t)&at24_data_24c00 },
210b680f4faSSven Van Asbroeck { "24c01", (kernel_ulong_t)&at24_data_24c01 },
211b680f4faSSven Van Asbroeck { "24cs01", (kernel_ulong_t)&at24_data_24cs01 },
212b680f4faSSven Van Asbroeck { "24c02", (kernel_ulong_t)&at24_data_24c02 },
213b680f4faSSven Van Asbroeck { "24cs02", (kernel_ulong_t)&at24_data_24cs02 },
214b680f4faSSven Van Asbroeck { "24mac402", (kernel_ulong_t)&at24_data_24mac402 },
215b680f4faSSven Van Asbroeck { "24mac602", (kernel_ulong_t)&at24_data_24mac602 },
216b680f4faSSven Van Asbroeck { "spd", (kernel_ulong_t)&at24_data_spd },
217a4423cedSJean Delvare { "24c02-vaio", (kernel_ulong_t)&at24_data_24c02_vaio },
218b680f4faSSven Van Asbroeck { "24c04", (kernel_ulong_t)&at24_data_24c04 },
219b680f4faSSven Van Asbroeck { "24cs04", (kernel_ulong_t)&at24_data_24cs04 },
220b680f4faSSven Van Asbroeck { "24c08", (kernel_ulong_t)&at24_data_24c08 },
221b680f4faSSven Van Asbroeck { "24cs08", (kernel_ulong_t)&at24_data_24cs08 },
222b680f4faSSven Van Asbroeck { "24c16", (kernel_ulong_t)&at24_data_24c16 },
223b680f4faSSven Van Asbroeck { "24cs16", (kernel_ulong_t)&at24_data_24cs16 },
224b680f4faSSven Van Asbroeck { "24c32", (kernel_ulong_t)&at24_data_24c32 },
225b680f4faSSven Van Asbroeck { "24cs32", (kernel_ulong_t)&at24_data_24cs32 },
226b680f4faSSven Van Asbroeck { "24c64", (kernel_ulong_t)&at24_data_24c64 },
227b680f4faSSven Van Asbroeck { "24cs64", (kernel_ulong_t)&at24_data_24cs64 },
228b680f4faSSven Van Asbroeck { "24c128", (kernel_ulong_t)&at24_data_24c128 },
229b680f4faSSven Van Asbroeck { "24c256", (kernel_ulong_t)&at24_data_24c256 },
230b680f4faSSven Van Asbroeck { "24c512", (kernel_ulong_t)&at24_data_24c512 },
231b680f4faSSven Van Asbroeck { "24c1024", (kernel_ulong_t)&at24_data_24c1024 },
232d08aea21SMaxim Kochetkov { "24c1025", (kernel_ulong_t)&at24_data_24c1025 },
23337cf28d3SAdrian Bunk { "24c2048", (kernel_ulong_t)&at24_data_24c2048 },
2345195e509SWolfram Sang { "at24", 0 },
2355195e509SWolfram Sang { /* END OF LIST */ }
2365195e509SWolfram Sang };
2375195e509SWolfram Sang MODULE_DEVICE_TABLE(i2c, at24_ids);
2385195e509SWolfram Sang
2397f2a2f0dSJavier Martinez Canillas static const struct of_device_id at24_of_match[] = {
240b680f4faSSven Van Asbroeck { .compatible = "atmel,24c00", .data = &at24_data_24c00 },
241b680f4faSSven Van Asbroeck { .compatible = "atmel,24c01", .data = &at24_data_24c01 },
2420f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs01", .data = &at24_data_24cs01 },
243b680f4faSSven Van Asbroeck { .compatible = "atmel,24c02", .data = &at24_data_24c02 },
2440f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs02", .data = &at24_data_24cs02 },
2450f30aca7SBartosz Golaszewski { .compatible = "atmel,24mac402", .data = &at24_data_24mac402 },
2460f30aca7SBartosz Golaszewski { .compatible = "atmel,24mac602", .data = &at24_data_24mac602 },
247b680f4faSSven Van Asbroeck { .compatible = "atmel,spd", .data = &at24_data_spd },
248b680f4faSSven Van Asbroeck { .compatible = "atmel,24c04", .data = &at24_data_24c04 },
2490f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs04", .data = &at24_data_24cs04 },
250b680f4faSSven Van Asbroeck { .compatible = "atmel,24c08", .data = &at24_data_24c08 },
2510f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs08", .data = &at24_data_24cs08 },
252b680f4faSSven Van Asbroeck { .compatible = "atmel,24c16", .data = &at24_data_24c16 },
2530f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs16", .data = &at24_data_24cs16 },
254b680f4faSSven Van Asbroeck { .compatible = "atmel,24c32", .data = &at24_data_24c32 },
2550f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs32", .data = &at24_data_24cs32 },
256b680f4faSSven Van Asbroeck { .compatible = "atmel,24c64", .data = &at24_data_24c64 },
2570f30aca7SBartosz Golaszewski { .compatible = "atmel,24cs64", .data = &at24_data_24cs64 },
258b680f4faSSven Van Asbroeck { .compatible = "atmel,24c128", .data = &at24_data_24c128 },
259b680f4faSSven Van Asbroeck { .compatible = "atmel,24c256", .data = &at24_data_24c256 },
260b680f4faSSven Van Asbroeck { .compatible = "atmel,24c512", .data = &at24_data_24c512 },
261b680f4faSSven Van Asbroeck { .compatible = "atmel,24c1024", .data = &at24_data_24c1024 },
262d08aea21SMaxim Kochetkov { .compatible = "atmel,24c1025", .data = &at24_data_24c1025 },
26337cf28d3SAdrian Bunk { .compatible = "atmel,24c2048", .data = &at24_data_24c2048 },
264b680f4faSSven Van Asbroeck { /* END OF LIST */ },
2657f2a2f0dSJavier Martinez Canillas };
2667f2a2f0dSJavier Martinez Canillas MODULE_DEVICE_TABLE(of, at24_of_match);
2677f2a2f0dSJavier Martinez Canillas
2688965930cSLee Jones static const struct acpi_device_id __maybe_unused at24_acpi_ids[] = {
269b680f4faSSven Van Asbroeck { "INT3499", (kernel_ulong_t)&at24_data_INT3499 },
2704837621cSMarkus Pietrek { "TPF0001", (kernel_ulong_t)&at24_data_24c1024 },
271b680f4faSSven Van Asbroeck { /* END OF LIST */ }
27240d8edc9SAndy Shevchenko };
27340d8edc9SAndy Shevchenko MODULE_DEVICE_TABLE(acpi, at24_acpi_ids);
27440d8edc9SAndy Shevchenko
2755195e509SWolfram Sang /*
2765195e509SWolfram Sang * This routine supports chips which consume multiple I2C addresses. It
2775195e509SWolfram Sang * computes the addressing information to be used for a given r/w request.
2785195e509SWolfram Sang * Assumes that sanity checks for offset happened at sysfs-layer.
2799afd6866SBartosz Golaszewski *
2809afd6866SBartosz Golaszewski * Slave address and byte offset derive from the offset. Always
2819afd6866SBartosz Golaszewski * set the byte address; on a multi-master board, another master
2829afd6866SBartosz Golaszewski * may have changed the chip's "current" address pointer.
2835195e509SWolfram Sang */
at24_translate_offset(struct at24_data * at24,unsigned int * offset)28492e17647SHeiner Kallweit static struct regmap *at24_translate_offset(struct at24_data *at24,
2852da78ac3SBartosz Golaszewski unsigned int *offset)
2865195e509SWolfram Sang {
287aa4ce228SBartosz Golaszewski unsigned int i;
2885195e509SWolfram Sang
2897c280664SBartosz Golaszewski if (at24->flags & AT24_FLAG_ADDR16) {
2905195e509SWolfram Sang i = *offset >> 16;
2915195e509SWolfram Sang *offset &= 0xffff;
2925195e509SWolfram Sang } else {
2935195e509SWolfram Sang i = *offset >> 8;
2945195e509SWolfram Sang *offset &= 0xff;
2955195e509SWolfram Sang }
2965195e509SWolfram Sang
29792e17647SHeiner Kallweit return at24->client_regmaps[i];
2985195e509SWolfram Sang }
2995195e509SWolfram Sang
at24_base_client_dev(struct at24_data * at24)300f1a640c5SBartosz Golaszewski static struct device *at24_base_client_dev(struct at24_data *at24)
301f1a640c5SBartosz Golaszewski {
30292e17647SHeiner Kallweit return regmap_get_device(at24->client_regmaps[0]);
303f1a640c5SBartosz Golaszewski }
304f1a640c5SBartosz Golaszewski
at24_adjust_read_count(struct at24_data * at24,unsigned int offset,size_t count)305e32213fbSSven Van Asbroeck static size_t at24_adjust_read_count(struct at24_data *at24,
306e32213fbSSven Van Asbroeck unsigned int offset, size_t count)
307e32213fbSSven Van Asbroeck {
308e32213fbSSven Van Asbroeck unsigned int bits;
309e32213fbSSven Van Asbroeck size_t remainder;
310e32213fbSSven Van Asbroeck
311e32213fbSSven Van Asbroeck /*
312e32213fbSSven Van Asbroeck * In case of multi-address chips that don't rollover reads to
313e32213fbSSven Van Asbroeck * the next slave address: truncate the count to the slave boundary,
314e32213fbSSven Van Asbroeck * so that the read never straddles slaves.
315e32213fbSSven Van Asbroeck */
3167c280664SBartosz Golaszewski if (at24->flags & AT24_FLAG_NO_RDROL) {
3177c280664SBartosz Golaszewski bits = (at24->flags & AT24_FLAG_ADDR16) ? 16 : 8;
318e32213fbSSven Van Asbroeck remainder = BIT(bits) - offset;
319e32213fbSSven Van Asbroeck if (count > remainder)
320e32213fbSSven Van Asbroeck count = remainder;
321e32213fbSSven Van Asbroeck }
322e32213fbSSven Van Asbroeck
323ec3c2d51SBartosz Golaszewski if (count > at24_io_limit)
324ec3c2d51SBartosz Golaszewski count = at24_io_limit;
325e32213fbSSven Van Asbroeck
326e32213fbSSven Van Asbroeck return count;
327e32213fbSSven Van Asbroeck }
328e32213fbSSven Van Asbroeck
at24_regmap_read(struct at24_data * at24,char * buf,unsigned int offset,size_t count)3294bb5c13cSHeiner Kallweit static ssize_t at24_regmap_read(struct at24_data *at24, char *buf,
3304bb5c13cSHeiner Kallweit unsigned int offset, size_t count)
3314bb5c13cSHeiner Kallweit {
3324bb5c13cSHeiner Kallweit unsigned long timeout, read_time;
3334bb5c13cSHeiner Kallweit struct regmap *regmap;
3344bb5c13cSHeiner Kallweit int ret;
3354bb5c13cSHeiner Kallweit
33692e17647SHeiner Kallweit regmap = at24_translate_offset(at24, &offset);
337e32213fbSSven Van Asbroeck count = at24_adjust_read_count(at24, offset, count);
3384bb5c13cSHeiner Kallweit
3394bb5c13cSHeiner Kallweit /* adjust offset for mac and serial read ops */
3404bb5c13cSHeiner Kallweit offset += at24->offset_adj;
3414bb5c13cSHeiner Kallweit
3429a9e295eSWang Xin timeout = jiffies + msecs_to_jiffies(at24_write_timeout);
3439a9e295eSWang Xin do {
3449a9e295eSWang Xin /*
3459a9e295eSWang Xin * The timestamp shall be taken before the actual operation
3469a9e295eSWang Xin * to avoid a premature timeout in case of high CPU load.
3479a9e295eSWang Xin */
3489a9e295eSWang Xin read_time = jiffies;
3499a9e295eSWang Xin
3504bb5c13cSHeiner Kallweit ret = regmap_bulk_read(regmap, offset, buf, count);
35192e17647SHeiner Kallweit dev_dbg(regmap_get_device(regmap), "read %zu@%d --> %d (%ld)\n",
3524bb5c13cSHeiner Kallweit count, offset, ret, jiffies);
3534bb5c13cSHeiner Kallweit if (!ret)
3544bb5c13cSHeiner Kallweit return count;
3559a9e295eSWang Xin
3569a9e295eSWang Xin usleep_range(1000, 1500);
3579a9e295eSWang Xin } while (time_before(read_time, timeout));
3584bb5c13cSHeiner Kallweit
3594bb5c13cSHeiner Kallweit return -ETIMEDOUT;
3604bb5c13cSHeiner Kallweit }
3614bb5c13cSHeiner Kallweit
3625195e509SWolfram Sang /*
3635195e509SWolfram Sang * Note that if the hardware write-protect pin is pulled high, the whole
3645195e509SWolfram Sang * chip is normally write protected. But there are plenty of product
3655195e509SWolfram Sang * variants here, including OTP fuses and partial chip protect.
3665195e509SWolfram Sang *
367cd0c8615SBartosz Golaszewski * We only use page mode writes; the alternative is sloooow. These routines
368cd0c8615SBartosz Golaszewski * write at most one page.
3695195e509SWolfram Sang */
370cd0c8615SBartosz Golaszewski
at24_adjust_write_count(struct at24_data * at24,unsigned int offset,size_t count)371cd0c8615SBartosz Golaszewski static size_t at24_adjust_write_count(struct at24_data *at24,
3722da78ac3SBartosz Golaszewski unsigned int offset, size_t count)
3735195e509SWolfram Sang {
374aa4ce228SBartosz Golaszewski unsigned int next_page;
3755195e509SWolfram Sang
3765195e509SWolfram Sang /* write_max is at most a page */
3775195e509SWolfram Sang if (count > at24->write_max)
3785195e509SWolfram Sang count = at24->write_max;
3795195e509SWolfram Sang
3805195e509SWolfram Sang /* Never roll over backwards, to the start of this page */
3817c280664SBartosz Golaszewski next_page = roundup(offset + 1, at24->page_size);
3825195e509SWolfram Sang if (offset + count > next_page)
3835195e509SWolfram Sang count = next_page - offset;
3845195e509SWolfram Sang
385cd0c8615SBartosz Golaszewski return count;
386cd0c8615SBartosz Golaszewski }
387cd0c8615SBartosz Golaszewski
at24_regmap_write(struct at24_data * at24,const char * buf,unsigned int offset,size_t count)3888e5888e1SHeiner Kallweit static ssize_t at24_regmap_write(struct at24_data *at24, const char *buf,
3898e5888e1SHeiner Kallweit unsigned int offset, size_t count)
3908e5888e1SHeiner Kallweit {
3918e5888e1SHeiner Kallweit unsigned long timeout, write_time;
3928e5888e1SHeiner Kallweit struct regmap *regmap;
3938e5888e1SHeiner Kallweit int ret;
3948e5888e1SHeiner Kallweit
39592e17647SHeiner Kallweit regmap = at24_translate_offset(at24, &offset);
3968e5888e1SHeiner Kallweit count = at24_adjust_write_count(at24, offset, count);
3979a9e295eSWang Xin timeout = jiffies + msecs_to_jiffies(at24_write_timeout);
3988e5888e1SHeiner Kallweit
3999a9e295eSWang Xin do {
4009a9e295eSWang Xin /*
4019a9e295eSWang Xin * The timestamp shall be taken before the actual operation
4029a9e295eSWang Xin * to avoid a premature timeout in case of high CPU load.
4039a9e295eSWang Xin */
4049a9e295eSWang Xin write_time = jiffies;
4059a9e295eSWang Xin
4068e5888e1SHeiner Kallweit ret = regmap_bulk_write(regmap, offset, buf, count);
40792e17647SHeiner Kallweit dev_dbg(regmap_get_device(regmap), "write %zu@%d --> %d (%ld)\n",
4088e5888e1SHeiner Kallweit count, offset, ret, jiffies);
4098e5888e1SHeiner Kallweit if (!ret)
4108e5888e1SHeiner Kallweit return count;
4119a9e295eSWang Xin
4129a9e295eSWang Xin usleep_range(1000, 1500);
4139a9e295eSWang Xin } while (time_before(write_time, timeout));
4148e5888e1SHeiner Kallweit
4158e5888e1SHeiner Kallweit return -ETIMEDOUT;
4168e5888e1SHeiner Kallweit }
4178e5888e1SHeiner Kallweit
at24_read(void * priv,unsigned int off,void * val,size_t count)418d5bc0047SBartosz Golaszewski static int at24_read(void *priv, unsigned int off, void *val, size_t count)
419d5bc0047SBartosz Golaszewski {
4205ca2b5b7SBartosz Golaszewski struct at24_data *at24;
4215ca2b5b7SBartosz Golaszewski struct device *dev;
422d5bc0047SBartosz Golaszewski char *buf = val;
42399363d1cSJean Delvare int i, ret;
424d5bc0047SBartosz Golaszewski
4255ca2b5b7SBartosz Golaszewski at24 = priv;
426f1a640c5SBartosz Golaszewski dev = at24_base_client_dev(at24);
4275ca2b5b7SBartosz Golaszewski
428d5bc0047SBartosz Golaszewski if (unlikely(!count))
429d5bc0047SBartosz Golaszewski return count;
430d5bc0047SBartosz Golaszewski
4317c280664SBartosz Golaszewski if (off + count > at24->byte_len)
432d9bcd462SHeiner Kallweit return -EINVAL;
433d9bcd462SHeiner Kallweit
434f9ecc83fSSakari Ailus ret = pm_runtime_get_sync(dev);
43598e82010SDivagar Mohandass if (ret < 0) {
436f9ecc83fSSakari Ailus pm_runtime_put_noidle(dev);
43798e82010SDivagar Mohandass return ret;
43898e82010SDivagar Mohandass }
43998e82010SDivagar Mohandass
440d5bc0047SBartosz Golaszewski /*
441d5bc0047SBartosz Golaszewski * Read data from chip, protecting against concurrent updates
442d5bc0047SBartosz Golaszewski * from this host, but not from other I2C masters.
443d5bc0047SBartosz Golaszewski */
444d5bc0047SBartosz Golaszewski mutex_lock(&at24->lock);
445d5bc0047SBartosz Golaszewski
44699363d1cSJean Delvare for (i = 0; count; i += ret, count -= ret) {
44799363d1cSJean Delvare ret = at24_regmap_read(at24, buf + i, off + i, count);
448eb27fde2SBartosz Golaszewski if (ret < 0) {
449d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock);
450f9ecc83fSSakari Ailus pm_runtime_put(dev);
451eb27fde2SBartosz Golaszewski return ret;
452d5bc0047SBartosz Golaszewski }
453d5bc0047SBartosz Golaszewski }
454d5bc0047SBartosz Golaszewski
455d5bc0047SBartosz Golaszewski mutex_unlock(&at24->lock);
456d5bc0047SBartosz Golaszewski
457f9ecc83fSSakari Ailus pm_runtime_put(dev);
45898e82010SDivagar Mohandass
459a4423cedSJean Delvare if (unlikely(at24->read_post))
46099363d1cSJean Delvare at24->read_post(off, buf, i);
461a4423cedSJean Delvare
462d5bc0047SBartosz Golaszewski return 0;
463d5bc0047SBartosz Golaszewski }
464d5bc0047SBartosz Golaszewski
at24_write(void * priv,unsigned int off,void * val,size_t count)465cf0361a2SSrinivas Kandagatla static int at24_write(void *priv, unsigned int off, void *val, size_t count)
4665195e509SWolfram Sang {
4675ca2b5b7SBartosz Golaszewski struct at24_data *at24;
4685ca2b5b7SBartosz Golaszewski struct device *dev;
469cf0361a2SSrinivas Kandagatla char *buf = val;
47098e82010SDivagar Mohandass int ret;
4715195e509SWolfram Sang
4725ca2b5b7SBartosz Golaszewski at24 = priv;
473f1a640c5SBartosz Golaszewski dev = at24_base_client_dev(at24);
4745ca2b5b7SBartosz Golaszewski
4755195e509SWolfram Sang if (unlikely(!count))
476cf0361a2SSrinivas Kandagatla return -EINVAL;
4775195e509SWolfram Sang
4787c280664SBartosz Golaszewski if (off + count > at24->byte_len)
479d9bcd462SHeiner Kallweit return -EINVAL;
480d9bcd462SHeiner Kallweit
481f9ecc83fSSakari Ailus ret = pm_runtime_get_sync(dev);
48298e82010SDivagar Mohandass if (ret < 0) {
483f9ecc83fSSakari Ailus pm_runtime_put_noidle(dev);
48498e82010SDivagar Mohandass return ret;
48598e82010SDivagar Mohandass }
48698e82010SDivagar Mohandass
4875195e509SWolfram Sang /*
4885195e509SWolfram Sang * Write data to chip, protecting against concurrent updates
4895195e509SWolfram Sang * from this host, but not from other I2C masters.
4905195e509SWolfram Sang */
4915195e509SWolfram Sang mutex_lock(&at24->lock);
4925195e509SWolfram Sang
4935195e509SWolfram Sang while (count) {
494c4fee330SBartosz Golaszewski ret = at24_regmap_write(at24, buf, off, count);
495c4fee330SBartosz Golaszewski if (ret < 0) {
496cf0361a2SSrinivas Kandagatla mutex_unlock(&at24->lock);
497f9ecc83fSSakari Ailus pm_runtime_put(dev);
498c4fee330SBartosz Golaszewski return ret;
4995195e509SWolfram Sang }
500c4fee330SBartosz Golaszewski buf += ret;
501c4fee330SBartosz Golaszewski off += ret;
502c4fee330SBartosz Golaszewski count -= ret;
5035195e509SWolfram Sang }
5045195e509SWolfram Sang
5055195e509SWolfram Sang mutex_unlock(&at24->lock);
5065195e509SWolfram Sang
507f9ecc83fSSakari Ailus pm_runtime_put(dev);
50898e82010SDivagar Mohandass
50957d15550SAndrew Lunn return 0;
51057d15550SAndrew Lunn }
51157d15550SAndrew Lunn
at24_get_chip_data(struct device * dev)5124fa882c9SBartosz Golaszewski static const struct at24_chip_data *at24_get_chip_data(struct device *dev)
513feb2f19bSBartosz Golaszewski {
514feb2f19bSBartosz Golaszewski struct device_node *of_node = dev->of_node;
515feb2f19bSBartosz Golaszewski const struct at24_chip_data *cdata;
516feb2f19bSBartosz Golaszewski const struct i2c_device_id *id;
517feb2f19bSBartosz Golaszewski
518feb2f19bSBartosz Golaszewski id = i2c_match_id(at24_ids, to_i2c_client(dev));
519feb2f19bSBartosz Golaszewski
520feb2f19bSBartosz Golaszewski /*
521feb2f19bSBartosz Golaszewski * The I2C core allows OF nodes compatibles to match against the
522feb2f19bSBartosz Golaszewski * I2C device ID table as a fallback, so check not only if an OF
523feb2f19bSBartosz Golaszewski * node is present but also if it matches an OF device ID entry.
524feb2f19bSBartosz Golaszewski */
525feb2f19bSBartosz Golaszewski if (of_node && of_match_device(at24_of_match, dev))
526feb2f19bSBartosz Golaszewski cdata = of_device_get_match_data(dev);
527feb2f19bSBartosz Golaszewski else if (id)
5285fa4d14eSBartosz Golaszewski cdata = (void *)id->driver_data;
529feb2f19bSBartosz Golaszewski else
530feb2f19bSBartosz Golaszewski cdata = acpi_device_get_match_data(dev);
531feb2f19bSBartosz Golaszewski
532feb2f19bSBartosz Golaszewski if (!cdata)
5334fa882c9SBartosz Golaszewski return ERR_PTR(-ENODEV);
534feb2f19bSBartosz Golaszewski
5354fa882c9SBartosz Golaszewski return cdata;
536feb2f19bSBartosz Golaszewski }
537feb2f19bSBartosz Golaszewski
at24_make_dummy_client(struct at24_data * at24,unsigned int index,struct i2c_client * base_client,struct regmap_config * regmap_config)53873b0d922SBartosz Golaszewski static int at24_make_dummy_client(struct at24_data *at24, unsigned int index,
53992e17647SHeiner Kallweit struct i2c_client *base_client,
54073b0d922SBartosz Golaszewski struct regmap_config *regmap_config)
54173b0d922SBartosz Golaszewski {
54292e17647SHeiner Kallweit struct i2c_client *dummy_client;
54373b0d922SBartosz Golaszewski struct regmap *regmap;
54473b0d922SBartosz Golaszewski
54592e17647SHeiner Kallweit dummy_client = devm_i2c_new_dummy_device(&base_client->dev,
54692e17647SHeiner Kallweit base_client->adapter,
547d08aea21SMaxim Kochetkov base_client->addr +
548d08aea21SMaxim Kochetkov (index << at24->bank_addr_shift));
549e7308628SBartosz Golaszewski if (IS_ERR(dummy_client))
550e7308628SBartosz Golaszewski return PTR_ERR(dummy_client);
55173b0d922SBartosz Golaszewski
55273b0d922SBartosz Golaszewski regmap = devm_regmap_init_i2c(dummy_client, regmap_config);
553e7308628SBartosz Golaszewski if (IS_ERR(regmap))
55473b0d922SBartosz Golaszewski return PTR_ERR(regmap);
55573b0d922SBartosz Golaszewski
55692e17647SHeiner Kallweit at24->client_regmaps[index] = regmap;
55773b0d922SBartosz Golaszewski
55873b0d922SBartosz Golaszewski return 0;
55973b0d922SBartosz Golaszewski }
56073b0d922SBartosz Golaszewski
at24_get_offset_adj(u8 flags,unsigned int byte_len)5614bb5c13cSHeiner Kallweit static unsigned int at24_get_offset_adj(u8 flags, unsigned int byte_len)
5624bb5c13cSHeiner Kallweit {
5634bb5c13cSHeiner Kallweit if (flags & AT24_FLAG_MAC) {
5644bb5c13cSHeiner Kallweit /* EUI-48 starts from 0x9a, EUI-64 from 0x98 */
5654bb5c13cSHeiner Kallweit return 0xa0 - byte_len;
5664bb5c13cSHeiner Kallweit } else if (flags & AT24_FLAG_SERIAL && flags & AT24_FLAG_ADDR16) {
5674bb5c13cSHeiner Kallweit /*
5684bb5c13cSHeiner Kallweit * For 16 bit address pointers, the word address must contain
5694bb5c13cSHeiner Kallweit * a '10' sequence in bits 11 and 10 regardless of the
5704bb5c13cSHeiner Kallweit * intended position of the address pointer.
5714bb5c13cSHeiner Kallweit */
5724bb5c13cSHeiner Kallweit return 0x0800;
5734bb5c13cSHeiner Kallweit } else if (flags & AT24_FLAG_SERIAL) {
5744bb5c13cSHeiner Kallweit /*
5754bb5c13cSHeiner Kallweit * Otherwise the word address must begin with a '10' sequence,
5764bb5c13cSHeiner Kallweit * regardless of the intended address.
5774bb5c13cSHeiner Kallweit */
5784bb5c13cSHeiner Kallweit return 0x0080;
5794bb5c13cSHeiner Kallweit } else {
5804bb5c13cSHeiner Kallweit return 0;
5814bb5c13cSHeiner Kallweit }
5824bb5c13cSHeiner Kallweit }
5834bb5c13cSHeiner Kallweit
at24_probe_temp_sensor(struct i2c_client * client)5844d5ace78SHeiner Kallweit static void at24_probe_temp_sensor(struct i2c_client *client)
5854d5ace78SHeiner Kallweit {
5864d5ace78SHeiner Kallweit struct at24_data *at24 = i2c_get_clientdata(client);
5874d5ace78SHeiner Kallweit struct i2c_board_info info = { .type = "jc42" };
5884d5ace78SHeiner Kallweit int ret;
5894d5ace78SHeiner Kallweit u8 val;
5904d5ace78SHeiner Kallweit
5914d5ace78SHeiner Kallweit /*
5924d5ace78SHeiner Kallweit * Byte 2 has value 11 for DDR3, earlier versions don't
5934d5ace78SHeiner Kallweit * support the thermal sensor present flag
5944d5ace78SHeiner Kallweit */
5954d5ace78SHeiner Kallweit ret = at24_read(at24, 2, &val, 1);
5964d5ace78SHeiner Kallweit if (ret || val != 11)
5974d5ace78SHeiner Kallweit return;
5984d5ace78SHeiner Kallweit
5994d5ace78SHeiner Kallweit /* Byte 32, bit 7 is set if temp sensor is present */
6004d5ace78SHeiner Kallweit ret = at24_read(at24, 32, &val, 1);
6014d5ace78SHeiner Kallweit if (ret || !(val & BIT(7)))
6024d5ace78SHeiner Kallweit return;
6034d5ace78SHeiner Kallweit
6044d5ace78SHeiner Kallweit info.addr = 0x18 | (client->addr & 7);
6054d5ace78SHeiner Kallweit
6064d5ace78SHeiner Kallweit i2c_new_client_device(client->adapter, &info);
6074d5ace78SHeiner Kallweit }
6084d5ace78SHeiner Kallweit
at24_probe(struct i2c_client * client)60948b6a7d1SBartosz Golaszewski static int at24_probe(struct i2c_client *client)
6105195e509SWolfram Sang {
611eef69398SBartosz Golaszewski struct regmap_config regmap_config = { };
6128cdc4e7eSBartosz Golaszewski struct nvmem_config nvmem_config = { };
6134fa882c9SBartosz Golaszewski u32 byte_len, page_size, flags, addrw;
6144fa882c9SBartosz Golaszewski const struct at24_chip_data *cdata;
615021c7d7bSBartosz Golaszewski struct device *dev = &client->dev;
61634d43fafSBartosz Golaszewski bool i2c_fn_i2c, i2c_fn_block;
6175ca2b5b7SBartosz Golaszewski unsigned int i, num_addresses;
6185ca2b5b7SBartosz Golaszewski struct at24_data *at24;
6191e96078eSSakari Ailus bool full_power;
620551a1266SBartosz Golaszewski struct regmap *regmap;
6215ca2b5b7SBartosz Golaszewski bool writable;
62200f0ea70SBartosz Golaszewski u8 test_byte;
6235ca2b5b7SBartosz Golaszewski int err;
6245195e509SWolfram Sang
62534d43fafSBartosz Golaszewski i2c_fn_i2c = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
62634d43fafSBartosz Golaszewski i2c_fn_block = i2c_check_functionality(client->adapter,
62734d43fafSBartosz Golaszewski I2C_FUNC_SMBUS_WRITE_I2C_BLOCK);
62834d43fafSBartosz Golaszewski
6294fa882c9SBartosz Golaszewski cdata = at24_get_chip_data(dev);
6304fa882c9SBartosz Golaszewski if (IS_ERR(cdata))
6314fa882c9SBartosz Golaszewski return PTR_ERR(cdata);
6324fa882c9SBartosz Golaszewski
6334fa882c9SBartosz Golaszewski err = device_property_read_u32(dev, "pagesize", &page_size);
634feb2f19bSBartosz Golaszewski if (err)
6354fa882c9SBartosz Golaszewski /*
6364fa882c9SBartosz Golaszewski * This is slow, but we can't know all eeproms, so we better
637dce91ba3SBartosz Golaszewski * play safe. Specifying custom eeprom-types via device tree
638dce91ba3SBartosz Golaszewski * or properties is recommended anyhow.
6394fa882c9SBartosz Golaszewski */
6404fa882c9SBartosz Golaszewski page_size = 1;
6414fa882c9SBartosz Golaszewski
6424fa882c9SBartosz Golaszewski flags = cdata->flags;
6434fa882c9SBartosz Golaszewski if (device_property_present(dev, "read-only"))
6444fa882c9SBartosz Golaszewski flags |= AT24_FLAG_READONLY;
6454fa882c9SBartosz Golaszewski if (device_property_present(dev, "no-read-rollover"))
6464fa882c9SBartosz Golaszewski flags |= AT24_FLAG_NO_RDROL;
6474fa882c9SBartosz Golaszewski
6484fa882c9SBartosz Golaszewski err = device_property_read_u32(dev, "address-width", &addrw);
6494fa882c9SBartosz Golaszewski if (!err) {
6504fa882c9SBartosz Golaszewski switch (addrw) {
6514fa882c9SBartosz Golaszewski case 8:
6524fa882c9SBartosz Golaszewski if (flags & AT24_FLAG_ADDR16)
6534fa882c9SBartosz Golaszewski dev_warn(dev,
6544fa882c9SBartosz Golaszewski "Override address width to be 8, while default is 16\n");
6554fa882c9SBartosz Golaszewski flags &= ~AT24_FLAG_ADDR16;
6564fa882c9SBartosz Golaszewski break;
6574fa882c9SBartosz Golaszewski case 16:
6584fa882c9SBartosz Golaszewski flags |= AT24_FLAG_ADDR16;
6594fa882c9SBartosz Golaszewski break;
6604fa882c9SBartosz Golaszewski default:
6614fa882c9SBartosz Golaszewski dev_warn(dev, "Bad \"address-width\" property: %u\n",
6624fa882c9SBartosz Golaszewski addrw);
6634fa882c9SBartosz Golaszewski }
6644fa882c9SBartosz Golaszewski }
6654fa882c9SBartosz Golaszewski
6664fa882c9SBartosz Golaszewski err = device_property_read_u32(dev, "size", &byte_len);
6674fa882c9SBartosz Golaszewski if (err)
6684fa882c9SBartosz Golaszewski byte_len = cdata->byte_len;
6695195e509SWolfram Sang
67034d43fafSBartosz Golaszewski if (!i2c_fn_i2c && !i2c_fn_block)
6714fa882c9SBartosz Golaszewski page_size = 1;
672551a1266SBartosz Golaszewski
6734fa882c9SBartosz Golaszewski if (!page_size) {
674021c7d7bSBartosz Golaszewski dev_err(dev, "page_size must not be 0!\n");
675f0ac2363SNikolay Balandin return -EINVAL;
67645efe847SWolfram Sang }
677de5db101SBartosz Golaszewski
6784fa882c9SBartosz Golaszewski if (!is_power_of_2(page_size))
679021c7d7bSBartosz Golaszewski dev_warn(dev, "page_size looks suspicious (no power of 2)!\n");
6805195e509SWolfram Sang
681950bcbbeSBartosz Golaszewski err = device_property_read_u32(dev, "num-addresses", &num_addresses);
682950bcbbeSBartosz Golaszewski if (err) {
6834fa882c9SBartosz Golaszewski if (flags & AT24_FLAG_TAKE8ADDR)
6845195e509SWolfram Sang num_addresses = 8;
6855195e509SWolfram Sang else
6864fa882c9SBartosz Golaszewski num_addresses = DIV_ROUND_UP(byte_len,
6874fa882c9SBartosz Golaszewski (flags & AT24_FLAG_ADDR16) ? 65536 : 256);
688950bcbbeSBartosz Golaszewski }
6895195e509SWolfram Sang
6904fa882c9SBartosz Golaszewski if ((flags & AT24_FLAG_SERIAL) && (flags & AT24_FLAG_MAC)) {
691551a1266SBartosz Golaszewski dev_err(dev,
692551a1266SBartosz Golaszewski "invalid device data - cannot have both AT24_FLAG_SERIAL & AT24_FLAG_MAC.");
693551a1266SBartosz Golaszewski return -EINVAL;
694551a1266SBartosz Golaszewski }
695551a1266SBartosz Golaszewski
696eef69398SBartosz Golaszewski regmap_config.val_bits = 8;
6974fa882c9SBartosz Golaszewski regmap_config.reg_bits = (flags & AT24_FLAG_ADDR16) ? 16 : 8;
698d154316dSBartosz Golaszewski regmap_config.disable_locking = true;
6995c015258SHeiner Kallweit
700551a1266SBartosz Golaszewski regmap = devm_regmap_init_i2c(client, ®map_config);
701551a1266SBartosz Golaszewski if (IS_ERR(regmap))
702551a1266SBartosz Golaszewski return PTR_ERR(regmap);
703551a1266SBartosz Golaszewski
70492e17647SHeiner Kallweit at24 = devm_kzalloc(dev, struct_size(at24, client_regmaps, num_addresses),
7059ae9d9bfSGustavo A. R. Silva GFP_KERNEL);
706f0ac2363SNikolay Balandin if (!at24)
707f0ac2363SNikolay Balandin return -ENOMEM;
7085195e509SWolfram Sang
7095195e509SWolfram Sang mutex_init(&at24->lock);
7104fa882c9SBartosz Golaszewski at24->byte_len = byte_len;
7114fa882c9SBartosz Golaszewski at24->page_size = page_size;
7124fa882c9SBartosz Golaszewski at24->flags = flags;
713a4423cedSJean Delvare at24->read_post = cdata->read_post;
714d08aea21SMaxim Kochetkov at24->bank_addr_shift = cdata->bank_addr_shift;
7155195e509SWolfram Sang at24->num_addresses = num_addresses;
7164fa882c9SBartosz Golaszewski at24->offset_adj = at24_get_offset_adj(flags, byte_len);
71792e17647SHeiner Kallweit at24->client_regmaps[0] = regmap;
7185195e509SWolfram Sang
719cd5676dbSBibby Hsieh at24->vcc_reg = devm_regulator_get(dev, "vcc");
720cd5676dbSBibby Hsieh if (IS_ERR(at24->vcc_reg))
721cd5676dbSBibby Hsieh return PTR_ERR(at24->vcc_reg);
7226ce261e8SBartosz Golaszewski
7234fa882c9SBartosz Golaszewski writable = !(flags & AT24_FLAG_READONLY);
7245195e509SWolfram Sang if (writable) {
725ec3c2d51SBartosz Golaszewski at24->write_max = min_t(unsigned int,
7264fa882c9SBartosz Golaszewski page_size, at24_io_limit);
72734d43fafSBartosz Golaszewski if (!i2c_fn_i2c && at24->write_max > I2C_SMBUS_BLOCK_MAX)
728a23727cbSHeiner Kallweit at24->write_max = I2C_SMBUS_BLOCK_MAX;
7295195e509SWolfram Sang }
7305195e509SWolfram Sang
7315195e509SWolfram Sang /* use dummy devices for multiple-address chips */
7325195e509SWolfram Sang for (i = 1; i < num_addresses; i++) {
73392e17647SHeiner Kallweit err = at24_make_dummy_client(at24, i, client, ®map_config);
734e7308628SBartosz Golaszewski if (err)
73573b0d922SBartosz Golaszewski return err;
7365c015258SHeiner Kallweit }
7375195e509SWolfram Sang
73861f764c3SJon Hunter /*
739c36748acSJérôme Glisse * We initialize nvmem_config.id to NVMEM_DEVID_AUTO even if the
740c36748acSJérôme Glisse * label property is set as some platform can have multiple eeproms
741c36748acSJérôme Glisse * with same label and we can not register each of those with same
742c36748acSJérôme Glisse * label. Failing to register those eeproms trigger cascade failure
743c36748acSJérôme Glisse * on such platform.
74461f764c3SJon Hunter */
745c36748acSJérôme Glisse nvmem_config.id = NVMEM_DEVID_AUTO;
746c36748acSJérôme Glisse
74761f764c3SJon Hunter if (device_property_present(dev, "label")) {
74861f764c3SJon Hunter err = device_property_read_string(dev, "label",
74961f764c3SJon Hunter &nvmem_config.name);
75061f764c3SJon Hunter if (err)
75161f764c3SJon Hunter return err;
75261f764c3SJon Hunter } else {
753021c7d7bSBartosz Golaszewski nvmem_config.name = dev_name(dev);
75461f764c3SJon Hunter }
75561f764c3SJon Hunter
75661f764c3SJon Hunter nvmem_config.type = NVMEM_TYPE_EEPROM;
757021c7d7bSBartosz Golaszewski nvmem_config.dev = dev;
7588cdc4e7eSBartosz Golaszewski nvmem_config.read_only = !writable;
75925e5ef30SJean Delvare nvmem_config.root_only = !(flags & AT24_FLAG_IRUGO);
7608cdc4e7eSBartosz Golaszewski nvmem_config.owner = THIS_MODULE;
7618cdc4e7eSBartosz Golaszewski nvmem_config.compat = true;
762021c7d7bSBartosz Golaszewski nvmem_config.base_dev = dev;
7638cdc4e7eSBartosz Golaszewski nvmem_config.reg_read = at24_read;
7648cdc4e7eSBartosz Golaszewski nvmem_config.reg_write = at24_write;
7658cdc4e7eSBartosz Golaszewski nvmem_config.priv = at24;
7668cdc4e7eSBartosz Golaszewski nvmem_config.stride = 1;
7678cdc4e7eSBartosz Golaszewski nvmem_config.word_size = 1;
7684fa882c9SBartosz Golaszewski nvmem_config.size = byte_len;
76957d15550SAndrew Lunn
770b20eb4c1SBartosz Golaszewski i2c_set_clientdata(client, at24);
771b20eb4c1SBartosz Golaszewski
7721e96078eSSakari Ailus full_power = acpi_dev_state_d0(&client->dev);
7731e96078eSSakari Ailus if (full_power) {
774cd5676dbSBibby Hsieh err = regulator_enable(at24->vcc_reg);
775cd5676dbSBibby Hsieh if (err) {
776cd5676dbSBibby Hsieh dev_err(dev, "Failed to enable vcc regulator\n");
777cd5676dbSBibby Hsieh return err;
778cd5676dbSBibby Hsieh }
779cd5676dbSBibby Hsieh
780b20eb4c1SBartosz Golaszewski pm_runtime_set_active(dev);
7811e96078eSSakari Ailus }
782b20eb4c1SBartosz Golaszewski pm_runtime_enable(dev);
783b20eb4c1SBartosz Golaszewski
784b20eb4c1SBartosz Golaszewski /*
7851e96078eSSakari Ailus * Perform a one-byte test read to verify that the chip is functional,
7861e96078eSSakari Ailus * unless powering on the device is to be avoided during probe (i.e.
7871e96078eSSakari Ailus * it's powered off right now).
788b20eb4c1SBartosz Golaszewski */
7891e96078eSSakari Ailus if (full_power) {
790b20eb4c1SBartosz Golaszewski err = at24_read(at24, 0, &test_byte, 1);
791b20eb4c1SBartosz Golaszewski if (err) {
792b20eb4c1SBartosz Golaszewski pm_runtime_disable(dev);
7932962484dSHsin-Yi Wang if (!pm_runtime_status_suspended(dev))
794cd5676dbSBibby Hsieh regulator_disable(at24->vcc_reg);
795b20eb4c1SBartosz Golaszewski return -ENODEV;
79657d15550SAndrew Lunn }
7971e96078eSSakari Ailus }
7985195e509SWolfram Sang
7992af84c46SDaniel Okazaki at24->nvmem = devm_nvmem_register(dev, &nvmem_config);
8002af84c46SDaniel Okazaki if (IS_ERR(at24->nvmem)) {
8012af84c46SDaniel Okazaki pm_runtime_disable(dev);
8022af84c46SDaniel Okazaki if (!pm_runtime_status_suspended(dev))
8032af84c46SDaniel Okazaki regulator_disable(at24->vcc_reg);
8042af84c46SDaniel Okazaki return dev_err_probe(dev, PTR_ERR(at24->nvmem),
8052af84c46SDaniel Okazaki "failed to register nvmem\n");
8062af84c46SDaniel Okazaki }
8072af84c46SDaniel Okazaki
8084d5ace78SHeiner Kallweit /* If this a SPD EEPROM, probe for DDR3 thermal sensor */
8094d5ace78SHeiner Kallweit if (cdata == &at24_data_spd)
8104d5ace78SHeiner Kallweit at24_probe_temp_sensor(client);
8114d5ace78SHeiner Kallweit
81258d6fee5SMichael Auchter pm_runtime_idle(dev);
81358d6fee5SMichael Auchter
814285be87cSJean Delvare if (writable)
815285be87cSJean Delvare dev_info(dev, "%u byte %s EEPROM, writable, %u bytes/write\n",
816285be87cSJean Delvare byte_len, client->name, at24->write_max);
817285be87cSJean Delvare else
818285be87cSJean Delvare dev_info(dev, "%u byte %s EEPROM, read-only\n",
819285be87cSJean Delvare byte_len, client->name);
8205195e509SWolfram Sang
8215195e509SWolfram Sang return 0;
8225195e509SWolfram Sang }
8235195e509SWolfram Sang
at24_remove(struct i2c_client * client)824ed5c2f5fSUwe Kleine-König static void at24_remove(struct i2c_client *client)
8255195e509SWolfram Sang {
826cd5676dbSBibby Hsieh struct at24_data *at24 = i2c_get_clientdata(client);
827cd5676dbSBibby Hsieh
82898e82010SDivagar Mohandass pm_runtime_disable(&client->dev);
8291e96078eSSakari Ailus if (acpi_dev_state_d0(&client->dev)) {
830cd5676dbSBibby Hsieh if (!pm_runtime_status_suspended(&client->dev))
831cd5676dbSBibby Hsieh regulator_disable(at24->vcc_reg);
83298e82010SDivagar Mohandass pm_runtime_set_suspended(&client->dev);
8331e96078eSSakari Ailus }
8345195e509SWolfram Sang }
8355195e509SWolfram Sang
at24_suspend(struct device * dev)836cd5676dbSBibby Hsieh static int __maybe_unused at24_suspend(struct device *dev)
837cd5676dbSBibby Hsieh {
838cd5676dbSBibby Hsieh struct i2c_client *client = to_i2c_client(dev);
839cd5676dbSBibby Hsieh struct at24_data *at24 = i2c_get_clientdata(client);
840cd5676dbSBibby Hsieh
841cd5676dbSBibby Hsieh return regulator_disable(at24->vcc_reg);
842cd5676dbSBibby Hsieh }
843cd5676dbSBibby Hsieh
at24_resume(struct device * dev)844cd5676dbSBibby Hsieh static int __maybe_unused at24_resume(struct device *dev)
845cd5676dbSBibby Hsieh {
846cd5676dbSBibby Hsieh struct i2c_client *client = to_i2c_client(dev);
847cd5676dbSBibby Hsieh struct at24_data *at24 = i2c_get_clientdata(client);
848cd5676dbSBibby Hsieh
849cd5676dbSBibby Hsieh return regulator_enable(at24->vcc_reg);
850cd5676dbSBibby Hsieh }
851cd5676dbSBibby Hsieh
852cd5676dbSBibby Hsieh static const struct dev_pm_ops at24_pm_ops = {
853cd5676dbSBibby Hsieh SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
854cd5676dbSBibby Hsieh pm_runtime_force_resume)
855cd5676dbSBibby Hsieh SET_RUNTIME_PM_OPS(at24_suspend, at24_resume, NULL)
856cd5676dbSBibby Hsieh };
857cd5676dbSBibby Hsieh
8585195e509SWolfram Sang static struct i2c_driver at24_driver = {
8595195e509SWolfram Sang .driver = {
8605195e509SWolfram Sang .name = "at24",
861cd5676dbSBibby Hsieh .pm = &at24_pm_ops,
8627f2a2f0dSJavier Martinez Canillas .of_match_table = at24_of_match,
86340d8edc9SAndy Shevchenko .acpi_match_table = ACPI_PTR(at24_acpi_ids),
8645195e509SWolfram Sang },
865f050bb8fSUwe Kleine-König .probe = at24_probe,
8662d6bed9cSBill Pemberton .remove = at24_remove,
8675195e509SWolfram Sang .id_table = at24_ids,
8681e96078eSSakari Ailus .flags = I2C_DRV_ACPI_WAIVE_D0_PROBE,
8695195e509SWolfram Sang };
8705195e509SWolfram Sang
at24_init(void)8715195e509SWolfram Sang static int __init at24_init(void)
8725195e509SWolfram Sang {
873ec3c2d51SBartosz Golaszewski if (!at24_io_limit) {
874ec3c2d51SBartosz Golaszewski pr_err("at24: at24_io_limit must not be 0!\n");
87545efe847SWolfram Sang return -EINVAL;
87645efe847SWolfram Sang }
87745efe847SWolfram Sang
878ec3c2d51SBartosz Golaszewski at24_io_limit = rounddown_pow_of_two(at24_io_limit);
8795195e509SWolfram Sang return i2c_add_driver(&at24_driver);
8805195e509SWolfram Sang }
8815195e509SWolfram Sang module_init(at24_init);
8825195e509SWolfram Sang
at24_exit(void)8835195e509SWolfram Sang static void __exit at24_exit(void)
8845195e509SWolfram Sang {
8855195e509SWolfram Sang i2c_del_driver(&at24_driver);
8865195e509SWolfram Sang }
8875195e509SWolfram Sang module_exit(at24_exit);
8885195e509SWolfram Sang
8895195e509SWolfram Sang MODULE_DESCRIPTION("Driver for most I2C EEPROMs");
8905195e509SWolfram Sang MODULE_AUTHOR("David Brownell and Wolfram Sang");
8915195e509SWolfram Sang MODULE_LICENSE("GPL");
892