at24.c 22.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
2 3 4 5 6 7
/*
 * at24.c - handle most I2C EEPROMs
 *
 * Copyright (C) 2005-2007 David Brownell
 * Copyright (C) 2008 Wolfram Sang, Pengutronix
 */
8

9 10 11
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
12
#include <linux/of_device.h>
13 14 15 16 17 18 19
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/mod_devicetable.h>
#include <linux/log2.h>
#include <linux/bitops.h>
#include <linux/jiffies.h>
20
#include <linux/property.h>
21
#include <linux/acpi.h>
22
#include <linux/i2c.h>
23
#include <linux/nvmem-provider.h>
24
#include <linux/regmap.h>
25
#include <linux/platform_data/at24.h>
26
#include <linux/pm_runtime.h>
27
#include <linux/gpio/consumer.h>
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

/*
 * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable.
 * Differences between different vendor product lines (like Atmel AT24C or
 * MicroChip 24LC, etc) won't much matter for typical read/write access.
 * There are also I2C RAM chips, likewise interchangeable. One example
 * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes).
 *
 * However, misconfiguration can lose data. "Set 16-bit memory address"
 * to a part with 8-bit addressing will overwrite data. Writing with too
 * big a page size also loses data. And it's not safe to assume that the
 * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC
 * uses 0x51, for just one example.
 *
 * Accordingly, explicit board-specific configuration data should be used
 * in almost all cases. (One partial exception is an SMBus used to access
 * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.)
 *
 * So this driver uses "new style" I2C driver binding, expecting to be
 * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or
 * similar kernel-resident tables; or, configuration data coming from
 * a bootloader.
 *
 * Other than binding model, current differences from "eeprom" driver are
 * that this one handles write access and isn't restricted to 24c02 devices.
 * It also handles larger devices (32 kbit and up) with two-byte addresses,
 * which won't work on pure SMBus systems.
 */

57 58 59 60 61
struct at24_client {
	struct i2c_client *client;
	struct regmap *regmap;
};

62 63 64 65 66 67 68
struct at24_data {
	/*
	 * Lock protects against activities from other Linux tasks,
	 * but not from changes by other I2C masters.
	 */
	struct mutex lock;

69 70
	unsigned int write_max;
	unsigned int num_addresses;
71
	unsigned int offset_adj;
72

73 74 75 76
	u32 byte_len;
	u16 page_size;
	u8 flags;

77 78
	struct nvmem_device *nvmem;

79 80
	struct gpio_desc *wp_gpio;

81 82 83 84
	/*
	 * Some chips tie up multiple I2C addresses; dummy devices reserve
	 * them for us, and we'll use them with SMBus calls.
	 */
85
	struct at24_client client[];
86 87 88 89 90 91 92 93 94 95 96
};

/*
 * This parameter is to help this driver avoid blocking other drivers out
 * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C
 * clock, one 256 byte read takes about 1/43 second which is excessive;
 * but the 1/170 second it takes at 400 kHz may be quite reasonable; and
 * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible.
 *
 * This value is forced to be a power of two so that writes align on pages.
 */
97 98 99
static unsigned int at24_io_limit = 128;
module_param_named(io_limit, at24_io_limit, uint, 0);
MODULE_PARM_DESC(at24_io_limit, "Maximum bytes per I/O (default 128)");
100 101 102 103 104

/*
 * Specs often allow 5 msec for a page write, sometimes 20 msec;
 * it's important to recover from write timeouts.
 */
105 106 107
static unsigned int at24_write_timeout = 25;
module_param_named(write_timeout, at24_write_timeout, uint, 0);
MODULE_PARM_DESC(at24_write_timeout, "Time (in ms) to try writes (default 25)");
108

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
struct at24_chip_data {
	/*
	 * these fields mirror their equivalents in
	 * struct at24_platform_data
	 */
	u32 byte_len;
	u8 flags;
};

#define AT24_CHIP_DATA(_name, _len, _flags)				\
	static const struct at24_chip_data _name = {			\
		.byte_len = _len, .flags = _flags,			\
	}

/* needs 8 addresses as A0-A2 are ignored */
AT24_CHIP_DATA(at24_data_24c00, 128 / 8, AT24_FLAG_TAKE8ADDR);
/* old variants can't be handled with this generic entry! */
AT24_CHIP_DATA(at24_data_24c01, 1024 / 8, 0);
AT24_CHIP_DATA(at24_data_24cs01, 16,
	AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
AT24_CHIP_DATA(at24_data_24c02, 2048 / 8, 0);
AT24_CHIP_DATA(at24_data_24cs02, 16,
	AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
AT24_CHIP_DATA(at24_data_24mac402, 48 / 8,
	AT24_FLAG_MAC | AT24_FLAG_READONLY);
AT24_CHIP_DATA(at24_data_24mac602, 64 / 8,
	AT24_FLAG_MAC | AT24_FLAG_READONLY);
/* spd is a 24c02 in memory DIMMs */
AT24_CHIP_DATA(at24_data_spd, 2048 / 8,
	AT24_FLAG_READONLY | AT24_FLAG_IRUGO);
AT24_CHIP_DATA(at24_data_24c04, 4096 / 8, 0);
AT24_CHIP_DATA(at24_data_24cs04, 16,
	AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
/* 24rf08 quirk is handled at i2c-core */
AT24_CHIP_DATA(at24_data_24c08, 8192 / 8, 0);
AT24_CHIP_DATA(at24_data_24cs08, 16,
	AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
AT24_CHIP_DATA(at24_data_24c16, 16384 / 8, 0);
AT24_CHIP_DATA(at24_data_24cs16, 16,
	AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
AT24_CHIP_DATA(at24_data_24c32, 32768 / 8, AT24_FLAG_ADDR16);
AT24_CHIP_DATA(at24_data_24cs32, 16,
	AT24_FLAG_ADDR16 | AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
AT24_CHIP_DATA(at24_data_24c64, 65536 / 8, AT24_FLAG_ADDR16);
AT24_CHIP_DATA(at24_data_24cs64, 16,
	AT24_FLAG_ADDR16 | AT24_FLAG_SERIAL | AT24_FLAG_READONLY);
AT24_CHIP_DATA(at24_data_24c128, 131072 / 8, AT24_FLAG_ADDR16);
AT24_CHIP_DATA(at24_data_24c256, 262144 / 8, AT24_FLAG_ADDR16);
AT24_CHIP_DATA(at24_data_24c512, 524288 / 8, AT24_FLAG_ADDR16);
AT24_CHIP_DATA(at24_data_24c1024, 1048576 / 8, AT24_FLAG_ADDR16);
159
AT24_CHIP_DATA(at24_data_24c2048, 2097152 / 8, AT24_FLAG_ADDR16);
160 161 162
/* identical to 24c08 ? */
AT24_CHIP_DATA(at24_data_INT3499, 8192 / 8, 0);

163
static const struct i2c_device_id at24_ids[] = {
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
	{ "24c00",	(kernel_ulong_t)&at24_data_24c00 },
	{ "24c01",	(kernel_ulong_t)&at24_data_24c01 },
	{ "24cs01",	(kernel_ulong_t)&at24_data_24cs01 },
	{ "24c02",	(kernel_ulong_t)&at24_data_24c02 },
	{ "24cs02",	(kernel_ulong_t)&at24_data_24cs02 },
	{ "24mac402",	(kernel_ulong_t)&at24_data_24mac402 },
	{ "24mac602",	(kernel_ulong_t)&at24_data_24mac602 },
	{ "spd",	(kernel_ulong_t)&at24_data_spd },
	{ "24c04",	(kernel_ulong_t)&at24_data_24c04 },
	{ "24cs04",	(kernel_ulong_t)&at24_data_24cs04 },
	{ "24c08",	(kernel_ulong_t)&at24_data_24c08 },
	{ "24cs08",	(kernel_ulong_t)&at24_data_24cs08 },
	{ "24c16",	(kernel_ulong_t)&at24_data_24c16 },
	{ "24cs16",	(kernel_ulong_t)&at24_data_24cs16 },
	{ "24c32",	(kernel_ulong_t)&at24_data_24c32 },
	{ "24cs32",	(kernel_ulong_t)&at24_data_24cs32 },
	{ "24c64",	(kernel_ulong_t)&at24_data_24c64 },
	{ "24cs64",	(kernel_ulong_t)&at24_data_24cs64 },
	{ "24c128",	(kernel_ulong_t)&at24_data_24c128 },
	{ "24c256",	(kernel_ulong_t)&at24_data_24c256 },
	{ "24c512",	(kernel_ulong_t)&at24_data_24c512 },
	{ "24c1024",	(kernel_ulong_t)&at24_data_24c1024 },
186
	{ "24c2048",    (kernel_ulong_t)&at24_data_24c2048 },
187
	{ "at24",	0 },
188 189 190 191
	{ /* END OF LIST */ }
};
MODULE_DEVICE_TABLE(i2c, at24_ids);

192
static const struct of_device_id at24_of_match[] = {
193 194
	{ .compatible = "atmel,24c00",		.data = &at24_data_24c00 },
	{ .compatible = "atmel,24c01",		.data = &at24_data_24c01 },
195
	{ .compatible = "atmel,24cs01",		.data = &at24_data_24cs01 },
196
	{ .compatible = "atmel,24c02",		.data = &at24_data_24c02 },
197 198 199
	{ .compatible = "atmel,24cs02",		.data = &at24_data_24cs02 },
	{ .compatible = "atmel,24mac402",	.data = &at24_data_24mac402 },
	{ .compatible = "atmel,24mac602",	.data = &at24_data_24mac602 },
200 201
	{ .compatible = "atmel,spd",		.data = &at24_data_spd },
	{ .compatible = "atmel,24c04",		.data = &at24_data_24c04 },
202
	{ .compatible = "atmel,24cs04",		.data = &at24_data_24cs04 },
203
	{ .compatible = "atmel,24c08",		.data = &at24_data_24c08 },
204
	{ .compatible = "atmel,24cs08",		.data = &at24_data_24cs08 },
205
	{ .compatible = "atmel,24c16",		.data = &at24_data_24c16 },
206
	{ .compatible = "atmel,24cs16",		.data = &at24_data_24cs16 },
207
	{ .compatible = "atmel,24c32",		.data = &at24_data_24c32 },
208
	{ .compatible = "atmel,24cs32",		.data = &at24_data_24cs32 },
209
	{ .compatible = "atmel,24c64",		.data = &at24_data_24c64 },
210
	{ .compatible = "atmel,24cs64",		.data = &at24_data_24cs64 },
211 212 213 214
	{ .compatible = "atmel,24c128",		.data = &at24_data_24c128 },
	{ .compatible = "atmel,24c256",		.data = &at24_data_24c256 },
	{ .compatible = "atmel,24c512",		.data = &at24_data_24c512 },
	{ .compatible = "atmel,24c1024",	.data = &at24_data_24c1024 },
215
	{ .compatible = "atmel,24c2048",	.data = &at24_data_24c2048 },
216
	{ /* END OF LIST */ },
217 218 219
};
MODULE_DEVICE_TABLE(of, at24_of_match);

220
static const struct acpi_device_id at24_acpi_ids[] = {
221 222
	{ "INT3499",	(kernel_ulong_t)&at24_data_INT3499 },
	{ /* END OF LIST */ }
223 224 225
};
MODULE_DEVICE_TABLE(acpi, at24_acpi_ids);

226 227 228 229
/*
 * This routine supports chips which consume multiple I2C addresses. It
 * computes the addressing information to be used for a given r/w request.
 * Assumes that sanity checks for offset happened at sysfs-layer.
230 231 232 233
 *
 * Slave address and byte offset derive from the offset. Always
 * set the byte address; on a multi-master board, another master
 * may have changed the chip's "current" address pointer.
234
 */
235 236
static struct at24_client *at24_translate_offset(struct at24_data *at24,
						 unsigned int *offset)
237
{
238
	unsigned int i;
239

240
	if (at24->flags & AT24_FLAG_ADDR16) {
241 242 243 244 245 246 247
		i = *offset >> 16;
		*offset &= 0xffff;
	} else {
		i = *offset >> 8;
		*offset &= 0xff;
	}

248
	return &at24->client[i];
249 250
}

251 252 253 254 255
static struct device *at24_base_client_dev(struct at24_data *at24)
{
	return &at24->client[0].client->dev;
}

256 257 258 259 260 261 262 263 264 265 266
static size_t at24_adjust_read_count(struct at24_data *at24,
				      unsigned int offset, size_t count)
{
	unsigned int bits;
	size_t remainder;

	/*
	 * In case of multi-address chips that don't rollover reads to
	 * the next slave address: truncate the count to the slave boundary,
	 * so that the read never straddles slaves.
	 */
267 268
	if (at24->flags & AT24_FLAG_NO_RDROL) {
		bits = (at24->flags & AT24_FLAG_ADDR16) ? 16 : 8;
269 270 271 272 273
		remainder = BIT(bits) - offset;
		if (count > remainder)
			count = remainder;
	}

274 275
	if (count > at24_io_limit)
		count = at24_io_limit;
276 277 278 279

	return count;
}

280 281 282 283 284 285 286 287 288 289 290 291
static ssize_t at24_regmap_read(struct at24_data *at24, char *buf,
				unsigned int offset, size_t count)
{
	unsigned long timeout, read_time;
	struct at24_client *at24_client;
	struct i2c_client *client;
	struct regmap *regmap;
	int ret;

	at24_client = at24_translate_offset(at24, &offset);
	regmap = at24_client->regmap;
	client = at24_client->client;
292
	count = at24_adjust_read_count(at24, offset, count);
293 294 295 296

	/* adjust offset for mac and serial read ops */
	offset += at24->offset_adj;

297 298 299 300 301 302 303 304
	timeout = jiffies + msecs_to_jiffies(at24_write_timeout);
	do {
		/*
		 * The timestamp shall be taken before the actual operation
		 * to avoid a premature timeout in case of high CPU load.
		 */
		read_time = jiffies;

305 306 307 308 309
		ret = regmap_bulk_read(regmap, offset, buf, count);
		dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n",
			count, offset, ret, jiffies);
		if (!ret)
			return count;
310 311 312

		usleep_range(1000, 1500);
	} while (time_before(read_time, timeout));
313 314 315 316

	return -ETIMEDOUT;
}

317 318 319 320 321
/*
 * Note that if the hardware write-protect pin is pulled high, the whole
 * chip is normally write protected. But there are plenty of product
 * variants here, including OTP fuses and partial chip protect.
 *
322 323
 * We only use page mode writes; the alternative is sloooow. These routines
 * write at most one page.
324
 */
325 326 327

static size_t at24_adjust_write_count(struct at24_data *at24,
				      unsigned int offset, size_t count)
328
{
329
	unsigned int next_page;
330 331 332 333 334 335

	/* write_max is at most a page */
	if (count > at24->write_max)
		count = at24->write_max;

	/* Never roll over backwards, to the start of this page */
336
	next_page = roundup(offset + 1, at24->page_size);
337 338 339
	if (offset + count > next_page)
		count = next_page - offset;

340 341 342
	return count;
}

343 344 345 346 347 348 349 350 351 352 353 354 355
static ssize_t at24_regmap_write(struct at24_data *at24, const char *buf,
				 unsigned int offset, size_t count)
{
	unsigned long timeout, write_time;
	struct at24_client *at24_client;
	struct i2c_client *client;
	struct regmap *regmap;
	int ret;

	at24_client = at24_translate_offset(at24, &offset);
	regmap = at24_client->regmap;
	client = at24_client->client;
	count = at24_adjust_write_count(at24, offset, count);
356 357 358 359 360 361 362 363
	timeout = jiffies + msecs_to_jiffies(at24_write_timeout);

	do {
		/*
		 * The timestamp shall be taken before the actual operation
		 * to avoid a premature timeout in case of high CPU load.
		 */
		write_time = jiffies;
364 365 366 367 368 369

		ret = regmap_bulk_write(regmap, offset, buf, count);
		dev_dbg(&client->dev, "write %zu@%d --> %d (%ld)\n",
			count, offset, ret, jiffies);
		if (!ret)
			return count;
370 371 372

		usleep_range(1000, 1500);
	} while (time_before(write_time, timeout));
373 374 375 376

	return -ETIMEDOUT;
}

377 378
static int at24_read(void *priv, unsigned int off, void *val, size_t count)
{
379 380
	struct at24_data *at24;
	struct device *dev;
381
	char *buf = val;
382
	int ret;
383

384
	at24 = priv;
385
	dev = at24_base_client_dev(at24);
386

387 388 389
	if (unlikely(!count))
		return count;

390
	if (off + count > at24->byte_len)
391 392
		return -EINVAL;

393
	ret = pm_runtime_get_sync(dev);
394
	if (ret < 0) {
395
		pm_runtime_put_noidle(dev);
396 397 398
		return ret;
	}

399 400 401 402 403 404 405
	/*
	 * Read data from chip, protecting against concurrent updates
	 * from this host, but not from other I2C masters.
	 */
	mutex_lock(&at24->lock);

	while (count) {
406 407
		ret = at24_regmap_read(at24, buf, off, count);
		if (ret < 0) {
408
			mutex_unlock(&at24->lock);
409
			pm_runtime_put(dev);
410
			return ret;
411
		}
412 413 414
		buf += ret;
		off += ret;
		count -= ret;
415 416 417 418
	}

	mutex_unlock(&at24->lock);

419
	pm_runtime_put(dev);
420

421 422 423
	return 0;
}

424
static int at24_write(void *priv, unsigned int off, void *val, size_t count)
425
{
426 427
	struct at24_data *at24;
	struct device *dev;
428
	char *buf = val;
429
	int ret;
430

431
	at24 = priv;
432
	dev = at24_base_client_dev(at24);
433

434
	if (unlikely(!count))
435
		return -EINVAL;
436

437
	if (off + count > at24->byte_len)
438 439
		return -EINVAL;

440
	ret = pm_runtime_get_sync(dev);
441
	if (ret < 0) {
442
		pm_runtime_put_noidle(dev);
443 444 445
		return ret;
	}

446 447 448 449 450
	/*
	 * Write data to chip, protecting against concurrent updates
	 * from this host, but not from other I2C masters.
	 */
	mutex_lock(&at24->lock);
451
	gpiod_set_value_cansleep(at24->wp_gpio, 0);
452 453

	while (count) {
454 455
		ret = at24_regmap_write(at24, buf, off, count);
		if (ret < 0) {
456
			gpiod_set_value_cansleep(at24->wp_gpio, 1);
457
			mutex_unlock(&at24->lock);
458
			pm_runtime_put(dev);
459
			return ret;
460
		}
461 462 463
		buf += ret;
		off += ret;
		count -= ret;
464 465
	}

466
	gpiod_set_value_cansleep(at24->wp_gpio, 1);
467 468
	mutex_unlock(&at24->lock);

469
	pm_runtime_put(dev);
470

471 472 473
	return 0;
}

474 475
static void at24_properties_to_pdata(struct device *dev,
				     struct at24_platform_data *chip)
476
{
477 478 479 480 481
	int err;
	u32 val;

	if (device_property_present(dev, "read-only"))
		chip->flags |= AT24_FLAG_READONLY;
482 483
	if (device_property_present(dev, "no-read-rollover"))
		chip->flags |= AT24_FLAG_NO_RDROL;
484

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
	err = device_property_read_u32(dev, "address-width", &val);
	if (!err) {
		switch (val) {
		case 8:
			if (chip->flags & AT24_FLAG_ADDR16)
				dev_warn(dev, "Override address width to be 8, while default is 16\n");
			chip->flags &= ~AT24_FLAG_ADDR16;
			break;
		case 16:
			chip->flags |= AT24_FLAG_ADDR16;
			break;
		default:
			dev_warn(dev, "Bad \"address-width\" property: %u\n",
				 val);
		}
	}

502 503 504 505
	err = device_property_read_u32(dev, "size", &val);
	if (!err)
		chip->byte_len = val;

506 507 508 509 510 511 512 513 514 515
	err = device_property_read_u32(dev, "pagesize", &val);
	if (!err) {
		chip->page_size = val;
	} else {
		/*
		 * This is slow, but we can't know all eeproms, so we better
		 * play safe. Specifying custom eeprom-types via platform_data
		 * is recommended anyhow.
		 */
		chip->page_size = 1;
516 517 518
	}
}

519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
static int at24_get_pdata(struct device *dev, struct at24_platform_data *pdata)
{
	struct device_node *of_node = dev->of_node;
	const struct at24_chip_data *cdata;
	const struct i2c_device_id *id;
	struct at24_platform_data *pd;

	pd = dev_get_platdata(dev);
	if (pd) {
		memcpy(pdata, pd, sizeof(*pdata));
		return 0;
	}

	id = i2c_match_id(at24_ids, to_i2c_client(dev));

	/*
	 * The I2C core allows OF nodes compatibles to match against the
	 * I2C device ID table as a fallback, so check not only if an OF
	 * node is present but also if it matches an OF device ID entry.
	 */
	if (of_node && of_match_device(at24_of_match, dev))
		cdata = of_device_get_match_data(dev);
	else if (id)
542
		cdata = (void *)id->driver_data;
543 544 545 546 547 548 549 550 551 552 553 554 555
	else
		cdata = acpi_device_get_match_data(dev);

	if (!cdata)
		return -ENODEV;

	pdata->byte_len = cdata->byte_len;
	pdata->flags = cdata->flags;
	at24_properties_to_pdata(dev, pdata);

	return 0;
}

556 557 558 559 560 561 562 563
static void at24_remove_dummy_clients(struct at24_data *at24)
{
	int i;

	for (i = 1; i < at24->num_addresses; i++)
		i2c_unregister_device(at24->client[i].client);
}

564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
static int at24_make_dummy_client(struct at24_data *at24, unsigned int index,
				  struct regmap_config *regmap_config)
{
	struct i2c_client *base_client, *dummy_client;
	unsigned short int addr;
	struct regmap *regmap;
	struct device *dev;

	base_client = at24->client[0].client;
	dev = &base_client->dev;
	addr = base_client->addr + index;

	dummy_client = i2c_new_dummy(base_client->adapter,
				     base_client->addr + index);
	if (!dummy_client) {
		dev_err(dev, "address 0x%02x unavailable\n", addr);
		return -EADDRINUSE;
	}

	regmap = devm_regmap_init_i2c(dummy_client, regmap_config);
	if (IS_ERR(regmap)) {
		i2c_unregister_device(dummy_client);
		return PTR_ERR(regmap);
	}

	at24->client[index].client = dummy_client;
	at24->client[index].regmap = regmap;

	return 0;
}

595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
static unsigned int at24_get_offset_adj(u8 flags, unsigned int byte_len)
{
	if (flags & AT24_FLAG_MAC) {
		/* EUI-48 starts from 0x9a, EUI-64 from 0x98 */
		return 0xa0 - byte_len;
	} else if (flags & AT24_FLAG_SERIAL && flags & AT24_FLAG_ADDR16) {
		/*
		 * For 16 bit address pointers, the word address must contain
		 * a '10' sequence in bits 11 and 10 regardless of the
		 * intended position of the address pointer.
		 */
		return 0x0800;
	} else if (flags & AT24_FLAG_SERIAL) {
		/*
		 * Otherwise the word address must begin with a '10' sequence,
		 * regardless of the intended address.
		 */
		return 0x0080;
	} else {
		return 0;
	}
}

618
static int at24_probe(struct i2c_client *client)
619
{
620
	struct regmap_config regmap_config = { };
621
	struct nvmem_config nvmem_config = { };
622
	struct at24_platform_data pdata = { };
623
	struct device *dev = &client->dev;
624
	bool i2c_fn_i2c, i2c_fn_block;
625 626
	unsigned int i, num_addresses;
	struct at24_data *at24;
627
	struct regmap *regmap;
628
	size_t at24_size;
629
	bool writable;
630
	u8 test_byte;
631
	int err;
632

633 634 635 636
	i2c_fn_i2c = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
	i2c_fn_block = i2c_check_functionality(client->adapter,
					       I2C_FUNC_SMBUS_WRITE_I2C_BLOCK);

637 638 639
	err = at24_get_pdata(dev, &pdata);
	if (err)
		return err;
640

641
	if (!i2c_fn_i2c && !i2c_fn_block)
642 643
		pdata.page_size = 1;

644
	if (!pdata.page_size) {
645
		dev_err(dev, "page_size must not be 0!\n");
646
		return -EINVAL;
647
	}
648

649
	if (!is_power_of_2(pdata.page_size))
650
		dev_warn(dev, "page_size looks suspicious (no power of 2)!\n");
651

652
	if (pdata.flags & AT24_FLAG_TAKE8ADDR)
653 654
		num_addresses = 8;
	else
655 656
		num_addresses =	DIV_ROUND_UP(pdata.byte_len,
			(pdata.flags & AT24_FLAG_ADDR16) ? 65536 : 256);
657

658 659 660 661 662 663
	if ((pdata.flags & AT24_FLAG_SERIAL) && (pdata.flags & AT24_FLAG_MAC)) {
		dev_err(dev,
			"invalid device data - cannot have both AT24_FLAG_SERIAL & AT24_FLAG_MAC.");
		return -EINVAL;
	}

664
	regmap_config.val_bits = 8;
665
	regmap_config.reg_bits = (pdata.flags & AT24_FLAG_ADDR16) ? 16 : 8;
666
	regmap_config.disable_locking = true;
667

668 669 670 671
	regmap = devm_regmap_init_i2c(client, &regmap_config);
	if (IS_ERR(regmap))
		return PTR_ERR(regmap);

672 673
	at24_size = sizeof(*at24) + num_addresses * sizeof(struct at24_client);
	at24 = devm_kzalloc(dev, at24_size, GFP_KERNEL);
674 675
	if (!at24)
		return -ENOMEM;
676 677

	mutex_init(&at24->lock);
678 679 680
	at24->byte_len = pdata.byte_len;
	at24->page_size = pdata.page_size;
	at24->flags = pdata.flags;
681
	at24->num_addresses = num_addresses;
682
	at24->offset_adj = at24_get_offset_adj(pdata.flags, pdata.byte_len);
683 684
	at24->client[0].client = client;
	at24->client[0].regmap = regmap;
685

686
	at24->wp_gpio = devm_gpiod_get_optional(dev, "wp", GPIOD_OUT_HIGH);
687 688 689
	if (IS_ERR(at24->wp_gpio))
		return PTR_ERR(at24->wp_gpio);

690
	writable = !(pdata.flags & AT24_FLAG_READONLY);
691
	if (writable) {
692
		at24->write_max = min_t(unsigned int,
693
					pdata.page_size, at24_io_limit);
694
		if (!i2c_fn_i2c && at24->write_max > I2C_SMBUS_BLOCK_MAX)
695
			at24->write_max = I2C_SMBUS_BLOCK_MAX;
696 697 698 699
	}

	/* use dummy devices for multiple-address chips */
	for (i = 1; i < num_addresses; i++) {
700 701 702 703
		err = at24_make_dummy_client(at24, i, &regmap_config);
		if (err) {
			at24_remove_dummy_clients(at24);
			return err;
704
		}
705 706
	}

707 708
	i2c_set_clientdata(client, at24);

709
	/* enable runtime pm */
710 711
	pm_runtime_set_active(dev);
	pm_runtime_enable(dev);
712

713 714 715 716 717
	/*
	 * Perform a one-byte test read to verify that the
	 * chip is functional.
	 */
	err = at24_read(at24, 0, &test_byte, 1);
718
	pm_runtime_idle(dev);
719 720 721 722 723
	if (err) {
		err = -ENODEV;
		goto err_clients;
	}

724 725
	nvmem_config.name = dev_name(dev);
	nvmem_config.dev = dev;
726 727 728 729
	nvmem_config.read_only = !writable;
	nvmem_config.root_only = true;
	nvmem_config.owner = THIS_MODULE;
	nvmem_config.compat = true;
730
	nvmem_config.base_dev = dev;
731 732 733 734 735
	nvmem_config.reg_read = at24_read;
	nvmem_config.reg_write = at24_write;
	nvmem_config.priv = at24;
	nvmem_config.stride = 1;
	nvmem_config.word_size = 1;
736
	nvmem_config.size = pdata.byte_len;
737

738
	at24->nvmem = devm_nvmem_register(dev, &nvmem_config);
739 740 741 742
	if (IS_ERR(at24->nvmem)) {
		err = PTR_ERR(at24->nvmem);
		goto err_clients;
	}
743

744
	dev_info(dev, "%u byte %s EEPROM, %s, %u bytes/write\n",
745 746
		 pdata.byte_len, client->name,
		 writable ? "writable" : "read-only", at24->write_max);
747

748
	/* export data to kernel code */
749 750
	if (pdata.setup)
		pdata.setup(at24->nvmem, pdata.context);
751

752 753 754
	return 0;

err_clients:
755
	at24_remove_dummy_clients(at24);
756
	pm_runtime_disable(dev);
757

758 759 760
	return err;
}

761
static int at24_remove(struct i2c_client *client)
762 763 764 765
{
	struct at24_data *at24;

	at24 = i2c_get_clientdata(client);
766

767
	at24_remove_dummy_clients(at24);
768 769 770
	pm_runtime_disable(&client->dev);
	pm_runtime_set_suspended(&client->dev);

771 772 773 774 775 776
	return 0;
}

static struct i2c_driver at24_driver = {
	.driver = {
		.name = "at24",
777
		.of_match_table = at24_of_match,
778
		.acpi_match_table = ACPI_PTR(at24_acpi_ids),
779
	},
780
	.probe_new = at24_probe,
781
	.remove = at24_remove,
782 783 784 785 786
	.id_table = at24_ids,
};

static int __init at24_init(void)
{
787 788
	if (!at24_io_limit) {
		pr_err("at24: at24_io_limit must not be 0!\n");
789 790 791
		return -EINVAL;
	}

792
	at24_io_limit = rounddown_pow_of_two(at24_io_limit);
793 794 795 796 797 798 799 800 801 802 803 804 805
	return i2c_add_driver(&at24_driver);
}
module_init(at24_init);

static void __exit at24_exit(void)
{
	i2c_del_driver(&at24_driver);
}
module_exit(at24_exit);

MODULE_DESCRIPTION("Driver for most I2C EEPROMs");
MODULE_AUTHOR("David Brownell and Wolfram Sang");
MODULE_LICENSE("GPL");