1 /* 2 * at24.c - handle most I2C EEPROMs 3 * 4 * Copyright (C) 2005-2007 David Brownell 5 * Copyright (C) 2008 Wolfram Sang, Pengutronix 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 */ 12 #include <linux/kernel.h> 13 #include <linux/init.h> 14 #include <linux/module.h> 15 #include <linux/slab.h> 16 #include <linux/delay.h> 17 #include <linux/mutex.h> 18 #include <linux/sysfs.h> 19 #include <linux/mod_devicetable.h> 20 #include <linux/log2.h> 21 #include <linux/bitops.h> 22 #include <linux/jiffies.h> 23 #include <linux/of.h> 24 #include <linux/i2c.h> 25 #include <linux/platform_data/at24.h> 26 27 /* 28 * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable. 29 * Differences between different vendor product lines (like Atmel AT24C or 30 * MicroChip 24LC, etc) won't much matter for typical read/write access. 31 * There are also I2C RAM chips, likewise interchangeable. One example 32 * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes). 33 * 34 * However, misconfiguration can lose data. "Set 16-bit memory address" 35 * to a part with 8-bit addressing will overwrite data. Writing with too 36 * big a page size also loses data. And it's not safe to assume that the 37 * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC 38 * uses 0x51, for just one example. 39 * 40 * Accordingly, explicit board-specific configuration data should be used 41 * in almost all cases. (One partial exception is an SMBus used to access 42 * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.) 43 * 44 * So this driver uses "new style" I2C driver binding, expecting to be 45 * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or 46 * similar kernel-resident tables; or, configuration data coming from 47 * a bootloader. 48 * 49 * Other than binding model, current differences from "eeprom" driver are 50 * that this one handles write access and isn't restricted to 24c02 devices. 51 * It also handles larger devices (32 kbit and up) with two-byte addresses, 52 * which won't work on pure SMBus systems. 53 */ 54 55 struct at24_data { 56 struct at24_platform_data chip; 57 struct memory_accessor macc; 58 int use_smbus; 59 int use_smbus_write; 60 61 /* 62 * Lock protects against activities from other Linux tasks, 63 * but not from changes by other I2C masters. 64 */ 65 struct mutex lock; 66 struct bin_attribute bin; 67 68 u8 *writebuf; 69 unsigned write_max; 70 unsigned num_addresses; 71 72 /* 73 * Some chips tie up multiple I2C addresses; dummy devices reserve 74 * them for us, and we'll use them with SMBus calls. 75 */ 76 struct i2c_client *client[]; 77 }; 78 79 /* 80 * This parameter is to help this driver avoid blocking other drivers out 81 * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C 82 * clock, one 256 byte read takes about 1/43 second which is excessive; 83 * but the 1/170 second it takes at 400 kHz may be quite reasonable; and 84 * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible. 85 * 86 * This value is forced to be a power of two so that writes align on pages. 87 */ 88 static unsigned io_limit = 128; 89 module_param(io_limit, uint, 0); 90 MODULE_PARM_DESC(io_limit, "Maximum bytes per I/O (default 128)"); 91 92 /* 93 * Specs often allow 5 msec for a page write, sometimes 20 msec; 94 * it's important to recover from write timeouts. 95 */ 96 static unsigned write_timeout = 25; 97 module_param(write_timeout, uint, 0); 98 MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)"); 99 100 #define AT24_SIZE_BYTELEN 5 101 #define AT24_SIZE_FLAGS 8 102 103 #define AT24_BITMASK(x) (BIT(x) - 1) 104 105 /* create non-zero magic value for given eeprom parameters */ 106 #define AT24_DEVICE_MAGIC(_len, _flags) \ 107 ((1 << AT24_SIZE_FLAGS | (_flags)) \ 108 << AT24_SIZE_BYTELEN | ilog2(_len)) 109 110 static const struct i2c_device_id at24_ids[] = { 111 /* needs 8 addresses as A0-A2 are ignored */ 112 { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) }, 113 /* old variants can't be handled with this generic entry! */ 114 { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) }, 115 { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) }, 116 /* spd is a 24c02 in memory DIMMs */ 117 { "spd", AT24_DEVICE_MAGIC(2048 / 8, 118 AT24_FLAG_READONLY | AT24_FLAG_IRUGO) }, 119 { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) }, 120 /* 24rf08 quirk is handled at i2c-core */ 121 { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) }, 122 { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) }, 123 { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) }, 124 { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) }, 125 { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) }, 126 { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) }, 127 { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) }, 128 { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) }, 129 { "at24", 0 }, 130 { /* END OF LIST */ } 131 }; 132 MODULE_DEVICE_TABLE(i2c, at24_ids); 133 134 /*-------------------------------------------------------------------------*/ 135 136 /* 137 * This routine supports chips which consume multiple I2C addresses. It 138 * computes the addressing information to be used for a given r/w request. 139 * Assumes that sanity checks for offset happened at sysfs-layer. 140 */ 141 static struct i2c_client *at24_translate_offset(struct at24_data *at24, 142 unsigned *offset) 143 { 144 unsigned i; 145 146 if (at24->chip.flags & AT24_FLAG_ADDR16) { 147 i = *offset >> 16; 148 *offset &= 0xffff; 149 } else { 150 i = *offset >> 8; 151 *offset &= 0xff; 152 } 153 154 return at24->client[i]; 155 } 156 157 static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf, 158 unsigned offset, size_t count) 159 { 160 struct i2c_msg msg[2]; 161 u8 msgbuf[2]; 162 struct i2c_client *client; 163 unsigned long timeout, read_time; 164 int status, i; 165 166 memset(msg, 0, sizeof(msg)); 167 168 /* 169 * REVISIT some multi-address chips don't rollover page reads to 170 * the next slave address, so we may need to truncate the count. 171 * Those chips might need another quirk flag. 172 * 173 * If the real hardware used four adjacent 24c02 chips and that 174 * were misconfigured as one 24c08, that would be a similar effect: 175 * one "eeprom" file not four, but larger reads would fail when 176 * they crossed certain pages. 177 */ 178 179 /* 180 * Slave address and byte offset derive from the offset. Always 181 * set the byte address; on a multi-master board, another master 182 * may have changed the chip's "current" address pointer. 183 */ 184 client = at24_translate_offset(at24, &offset); 185 186 if (count > io_limit) 187 count = io_limit; 188 189 switch (at24->use_smbus) { 190 case I2C_SMBUS_I2C_BLOCK_DATA: 191 /* Smaller eeproms can work given some SMBus extension calls */ 192 if (count > I2C_SMBUS_BLOCK_MAX) 193 count = I2C_SMBUS_BLOCK_MAX; 194 break; 195 case I2C_SMBUS_WORD_DATA: 196 count = 2; 197 break; 198 case I2C_SMBUS_BYTE_DATA: 199 count = 1; 200 break; 201 default: 202 /* 203 * When we have a better choice than SMBus calls, use a 204 * combined I2C message. Write address; then read up to 205 * io_limit data bytes. Note that read page rollover helps us 206 * here (unlike writes). msgbuf is u8 and will cast to our 207 * needs. 208 */ 209 i = 0; 210 if (at24->chip.flags & AT24_FLAG_ADDR16) 211 msgbuf[i++] = offset >> 8; 212 msgbuf[i++] = offset; 213 214 msg[0].addr = client->addr; 215 msg[0].buf = msgbuf; 216 msg[0].len = i; 217 218 msg[1].addr = client->addr; 219 msg[1].flags = I2C_M_RD; 220 msg[1].buf = buf; 221 msg[1].len = count; 222 } 223 224 /* 225 * Reads fail if the previous write didn't complete yet. We may 226 * loop a few times until this one succeeds, waiting at least 227 * long enough for one entire page write to work. 228 */ 229 timeout = jiffies + msecs_to_jiffies(write_timeout); 230 do { 231 read_time = jiffies; 232 switch (at24->use_smbus) { 233 case I2C_SMBUS_I2C_BLOCK_DATA: 234 status = i2c_smbus_read_i2c_block_data(client, offset, 235 count, buf); 236 break; 237 case I2C_SMBUS_WORD_DATA: 238 status = i2c_smbus_read_word_data(client, offset); 239 if (status >= 0) { 240 buf[0] = status & 0xff; 241 buf[1] = status >> 8; 242 status = count; 243 } 244 break; 245 case I2C_SMBUS_BYTE_DATA: 246 status = i2c_smbus_read_byte_data(client, offset); 247 if (status >= 0) { 248 buf[0] = status; 249 status = count; 250 } 251 break; 252 default: 253 status = i2c_transfer(client->adapter, msg, 2); 254 if (status == 2) 255 status = count; 256 } 257 dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n", 258 count, offset, status, jiffies); 259 260 if (status == count) 261 return count; 262 263 /* REVISIT: at HZ=100, this is sloooow */ 264 msleep(1); 265 } while (time_before(read_time, timeout)); 266 267 return -ETIMEDOUT; 268 } 269 270 static ssize_t at24_read(struct at24_data *at24, 271 char *buf, loff_t off, size_t count) 272 { 273 ssize_t retval = 0; 274 275 if (unlikely(!count)) 276 return count; 277 278 /* 279 * Read data from chip, protecting against concurrent updates 280 * from this host, but not from other I2C masters. 281 */ 282 mutex_lock(&at24->lock); 283 284 while (count) { 285 ssize_t status; 286 287 status = at24_eeprom_read(at24, buf, off, count); 288 if (status <= 0) { 289 if (retval == 0) 290 retval = status; 291 break; 292 } 293 buf += status; 294 off += status; 295 count -= status; 296 retval += status; 297 } 298 299 mutex_unlock(&at24->lock); 300 301 return retval; 302 } 303 304 static ssize_t at24_bin_read(struct file *filp, struct kobject *kobj, 305 struct bin_attribute *attr, 306 char *buf, loff_t off, size_t count) 307 { 308 struct at24_data *at24; 309 310 at24 = dev_get_drvdata(container_of(kobj, struct device, kobj)); 311 return at24_read(at24, buf, off, count); 312 } 313 314 315 /* 316 * Note that if the hardware write-protect pin is pulled high, the whole 317 * chip is normally write protected. But there are plenty of product 318 * variants here, including OTP fuses and partial chip protect. 319 * 320 * We only use page mode writes; the alternative is sloooow. This routine 321 * writes at most one page. 322 */ 323 static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf, 324 unsigned offset, size_t count) 325 { 326 struct i2c_client *client; 327 struct i2c_msg msg; 328 ssize_t status = 0; 329 unsigned long timeout, write_time; 330 unsigned next_page; 331 332 /* Get corresponding I2C address and adjust offset */ 333 client = at24_translate_offset(at24, &offset); 334 335 /* write_max is at most a page */ 336 if (count > at24->write_max) 337 count = at24->write_max; 338 339 /* Never roll over backwards, to the start of this page */ 340 next_page = roundup(offset + 1, at24->chip.page_size); 341 if (offset + count > next_page) 342 count = next_page - offset; 343 344 /* If we'll use I2C calls for I/O, set up the message */ 345 if (!at24->use_smbus) { 346 int i = 0; 347 348 msg.addr = client->addr; 349 msg.flags = 0; 350 351 /* msg.buf is u8 and casts will mask the values */ 352 msg.buf = at24->writebuf; 353 if (at24->chip.flags & AT24_FLAG_ADDR16) 354 msg.buf[i++] = offset >> 8; 355 356 msg.buf[i++] = offset; 357 memcpy(&msg.buf[i], buf, count); 358 msg.len = i + count; 359 } 360 361 /* 362 * Writes fail if the previous one didn't complete yet. We may 363 * loop a few times until this one succeeds, waiting at least 364 * long enough for one entire page write to work. 365 */ 366 timeout = jiffies + msecs_to_jiffies(write_timeout); 367 do { 368 write_time = jiffies; 369 if (at24->use_smbus_write) { 370 switch (at24->use_smbus_write) { 371 case I2C_SMBUS_I2C_BLOCK_DATA: 372 status = i2c_smbus_write_i2c_block_data(client, 373 offset, count, buf); 374 break; 375 case I2C_SMBUS_BYTE_DATA: 376 status = i2c_smbus_write_byte_data(client, 377 offset, buf[0]); 378 break; 379 } 380 381 if (status == 0) 382 status = count; 383 } else { 384 status = i2c_transfer(client->adapter, &msg, 1); 385 if (status == 1) 386 status = count; 387 } 388 dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n", 389 count, offset, status, jiffies); 390 391 if (status == count) 392 return count; 393 394 /* REVISIT: at HZ=100, this is sloooow */ 395 msleep(1); 396 } while (time_before(write_time, timeout)); 397 398 return -ETIMEDOUT; 399 } 400 401 static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off, 402 size_t count) 403 { 404 ssize_t retval = 0; 405 406 if (unlikely(!count)) 407 return count; 408 409 /* 410 * Write data to chip, protecting against concurrent updates 411 * from this host, but not from other I2C masters. 412 */ 413 mutex_lock(&at24->lock); 414 415 while (count) { 416 ssize_t status; 417 418 status = at24_eeprom_write(at24, buf, off, count); 419 if (status <= 0) { 420 if (retval == 0) 421 retval = status; 422 break; 423 } 424 buf += status; 425 off += status; 426 count -= status; 427 retval += status; 428 } 429 430 mutex_unlock(&at24->lock); 431 432 return retval; 433 } 434 435 static ssize_t at24_bin_write(struct file *filp, struct kobject *kobj, 436 struct bin_attribute *attr, 437 char *buf, loff_t off, size_t count) 438 { 439 struct at24_data *at24; 440 441 at24 = dev_get_drvdata(container_of(kobj, struct device, kobj)); 442 return at24_write(at24, buf, off, count); 443 } 444 445 /*-------------------------------------------------------------------------*/ 446 447 /* 448 * This lets other kernel code access the eeprom data. For example, it 449 * might hold a board's Ethernet address, or board-specific calibration 450 * data generated on the manufacturing floor. 451 */ 452 453 static ssize_t at24_macc_read(struct memory_accessor *macc, char *buf, 454 off_t offset, size_t count) 455 { 456 struct at24_data *at24 = container_of(macc, struct at24_data, macc); 457 458 return at24_read(at24, buf, offset, count); 459 } 460 461 static ssize_t at24_macc_write(struct memory_accessor *macc, const char *buf, 462 off_t offset, size_t count) 463 { 464 struct at24_data *at24 = container_of(macc, struct at24_data, macc); 465 466 return at24_write(at24, buf, offset, count); 467 } 468 469 /*-------------------------------------------------------------------------*/ 470 471 #ifdef CONFIG_OF 472 static void at24_get_ofdata(struct i2c_client *client, 473 struct at24_platform_data *chip) 474 { 475 const __be32 *val; 476 struct device_node *node = client->dev.of_node; 477 478 if (node) { 479 if (of_get_property(node, "read-only", NULL)) 480 chip->flags |= AT24_FLAG_READONLY; 481 val = of_get_property(node, "pagesize", NULL); 482 if (val) 483 chip->page_size = be32_to_cpup(val); 484 } 485 } 486 #else 487 static void at24_get_ofdata(struct i2c_client *client, 488 struct at24_platform_data *chip) 489 { } 490 #endif /* CONFIG_OF */ 491 492 static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) 493 { 494 struct at24_platform_data chip; 495 bool writable; 496 int use_smbus = 0; 497 int use_smbus_write = 0; 498 struct at24_data *at24; 499 int err; 500 unsigned i, num_addresses; 501 kernel_ulong_t magic; 502 503 if (client->dev.platform_data) { 504 chip = *(struct at24_platform_data *)client->dev.platform_data; 505 } else { 506 if (!id->driver_data) 507 return -ENODEV; 508 509 magic = id->driver_data; 510 chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN)); 511 magic >>= AT24_SIZE_BYTELEN; 512 chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS); 513 /* 514 * This is slow, but we can't know all eeproms, so we better 515 * play safe. Specifying custom eeprom-types via platform_data 516 * is recommended anyhow. 517 */ 518 chip.page_size = 1; 519 520 /* update chipdata if OF is present */ 521 at24_get_ofdata(client, &chip); 522 523 chip.setup = NULL; 524 chip.context = NULL; 525 } 526 527 if (!is_power_of_2(chip.byte_len)) 528 dev_warn(&client->dev, 529 "byte_len looks suspicious (no power of 2)!\n"); 530 if (!chip.page_size) { 531 dev_err(&client->dev, "page_size must not be 0!\n"); 532 return -EINVAL; 533 } 534 if (!is_power_of_2(chip.page_size)) 535 dev_warn(&client->dev, 536 "page_size looks suspicious (no power of 2)!\n"); 537 538 /* Use I2C operations unless we're stuck with SMBus extensions. */ 539 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 540 if (chip.flags & AT24_FLAG_ADDR16) 541 return -EPFNOSUPPORT; 542 543 if (i2c_check_functionality(client->adapter, 544 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 545 use_smbus = I2C_SMBUS_I2C_BLOCK_DATA; 546 } else if (i2c_check_functionality(client->adapter, 547 I2C_FUNC_SMBUS_READ_WORD_DATA)) { 548 use_smbus = I2C_SMBUS_WORD_DATA; 549 } else if (i2c_check_functionality(client->adapter, 550 I2C_FUNC_SMBUS_READ_BYTE_DATA)) { 551 use_smbus = I2C_SMBUS_BYTE_DATA; 552 } else { 553 return -EPFNOSUPPORT; 554 } 555 } 556 557 /* Use I2C operations unless we're stuck with SMBus extensions. */ 558 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 559 if (i2c_check_functionality(client->adapter, 560 I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { 561 use_smbus_write = I2C_SMBUS_I2C_BLOCK_DATA; 562 } else if (i2c_check_functionality(client->adapter, 563 I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) { 564 use_smbus_write = I2C_SMBUS_BYTE_DATA; 565 chip.page_size = 1; 566 } 567 } 568 569 if (chip.flags & AT24_FLAG_TAKE8ADDR) 570 num_addresses = 8; 571 else 572 num_addresses = DIV_ROUND_UP(chip.byte_len, 573 (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256); 574 575 at24 = devm_kzalloc(&client->dev, sizeof(struct at24_data) + 576 num_addresses * sizeof(struct i2c_client *), GFP_KERNEL); 577 if (!at24) 578 return -ENOMEM; 579 580 mutex_init(&at24->lock); 581 at24->use_smbus = use_smbus; 582 at24->use_smbus_write = use_smbus_write; 583 at24->chip = chip; 584 at24->num_addresses = num_addresses; 585 586 /* 587 * Export the EEPROM bytes through sysfs, since that's convenient. 588 * By default, only root should see the data (maybe passwords etc) 589 */ 590 sysfs_bin_attr_init(&at24->bin); 591 at24->bin.attr.name = "eeprom"; 592 at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR; 593 at24->bin.read = at24_bin_read; 594 at24->bin.size = chip.byte_len; 595 596 at24->macc.read = at24_macc_read; 597 598 writable = !(chip.flags & AT24_FLAG_READONLY); 599 if (writable) { 600 if (!use_smbus || use_smbus_write) { 601 602 unsigned write_max = chip.page_size; 603 604 at24->macc.write = at24_macc_write; 605 606 at24->bin.write = at24_bin_write; 607 at24->bin.attr.mode |= S_IWUSR; 608 609 if (write_max > io_limit) 610 write_max = io_limit; 611 if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX) 612 write_max = I2C_SMBUS_BLOCK_MAX; 613 at24->write_max = write_max; 614 615 /* buffer (data + address at the beginning) */ 616 at24->writebuf = devm_kzalloc(&client->dev, 617 write_max + 2, GFP_KERNEL); 618 if (!at24->writebuf) 619 return -ENOMEM; 620 } else { 621 dev_warn(&client->dev, 622 "cannot write due to controller restrictions."); 623 } 624 } 625 626 at24->client[0] = client; 627 628 /* use dummy devices for multiple-address chips */ 629 for (i = 1; i < num_addresses; i++) { 630 at24->client[i] = i2c_new_dummy(client->adapter, 631 client->addr + i); 632 if (!at24->client[i]) { 633 dev_err(&client->dev, "address 0x%02x unavailable\n", 634 client->addr + i); 635 err = -EADDRINUSE; 636 goto err_clients; 637 } 638 } 639 640 err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin); 641 if (err) 642 goto err_clients; 643 644 i2c_set_clientdata(client, at24); 645 646 dev_info(&client->dev, "%zu byte %s EEPROM, %s, %u bytes/write\n", 647 at24->bin.size, client->name, 648 writable ? "writable" : "read-only", at24->write_max); 649 if (use_smbus == I2C_SMBUS_WORD_DATA || 650 use_smbus == I2C_SMBUS_BYTE_DATA) { 651 dev_notice(&client->dev, "Falling back to %s reads, " 652 "performance will suffer\n", use_smbus == 653 I2C_SMBUS_WORD_DATA ? "word" : "byte"); 654 } 655 656 /* export data to kernel code */ 657 if (chip.setup) 658 chip.setup(&at24->macc, chip.context); 659 660 return 0; 661 662 err_clients: 663 for (i = 1; i < num_addresses; i++) 664 if (at24->client[i]) 665 i2c_unregister_device(at24->client[i]); 666 667 return err; 668 } 669 670 static int at24_remove(struct i2c_client *client) 671 { 672 struct at24_data *at24; 673 int i; 674 675 at24 = i2c_get_clientdata(client); 676 sysfs_remove_bin_file(&client->dev.kobj, &at24->bin); 677 678 for (i = 1; i < at24->num_addresses; i++) 679 i2c_unregister_device(at24->client[i]); 680 681 return 0; 682 } 683 684 /*-------------------------------------------------------------------------*/ 685 686 static struct i2c_driver at24_driver = { 687 .driver = { 688 .name = "at24", 689 }, 690 .probe = at24_probe, 691 .remove = at24_remove, 692 .id_table = at24_ids, 693 }; 694 695 static int __init at24_init(void) 696 { 697 if (!io_limit) { 698 pr_err("at24: io_limit must not be 0!\n"); 699 return -EINVAL; 700 } 701 702 io_limit = rounddown_pow_of_two(io_limit); 703 return i2c_add_driver(&at24_driver); 704 } 705 module_init(at24_init); 706 707 static void __exit at24_exit(void) 708 { 709 i2c_del_driver(&at24_driver); 710 } 711 module_exit(at24_exit); 712 713 MODULE_DESCRIPTION("Driver for most I2C EEPROMs"); 714 MODULE_AUTHOR("David Brownell and Wolfram Sang"); 715 MODULE_LICENSE("GPL"); 716