1
2
3
4
5
6
7
8
9
10
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/i2c/at24.h>
26
27
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
55struct at24_data {
56 struct at24_platform_data chip;
57 struct memory_accessor macc;
58 int use_smbus;
59
60
61
62
63
64 struct mutex lock;
65 struct bin_attribute bin;
66
67 u8 *writebuf;
68 unsigned write_max;
69 unsigned num_addresses;
70
71
72
73
74
75 struct i2c_client *client[];
76};
77
78
79
80
81
82
83
84
85
86
87static unsigned io_limit = 128;
88module_param(io_limit, uint, 0);
89MODULE_PARM_DESC(io_limit, "Maximum bytes per I/O (default 128)");
90
91
92
93
94
95static unsigned write_timeout = 25;
96module_param(write_timeout, uint, 0);
97MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)");
98
99#define AT24_SIZE_BYTELEN 5
100#define AT24_SIZE_FLAGS 8
101
102#define AT24_BITMASK(x) (BIT(x) - 1)
103
104
105#define AT24_DEVICE_MAGIC(_len, _flags) \
106 ((1 << AT24_SIZE_FLAGS | (_flags)) \
107 << AT24_SIZE_BYTELEN | ilog2(_len))
108
109static const struct i2c_device_id at24_ids[] = {
110
111 { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) },
112
113 { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) },
114 { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) },
115
116 { "spd", AT24_DEVICE_MAGIC(2048 / 8,
117 AT24_FLAG_READONLY | AT24_FLAG_IRUGO) },
118 { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) },
119
120 { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) },
121 { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) },
122 { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) },
123 { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) },
124 { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) },
125 { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) },
126 { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) },
127 { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) },
128 { "at24", 0 },
129 { }
130};
131MODULE_DEVICE_TABLE(i2c, at24_ids);
132
133
134
135
136
137
138
139
140static struct i2c_client *at24_translate_offset(struct at24_data *at24,
141 unsigned *offset)
142{
143 unsigned i;
144
145 if (at24->chip.flags & AT24_FLAG_ADDR16) {
146 i = *offset >> 16;
147 *offset &= 0xffff;
148 } else {
149 i = *offset >> 8;
150 *offset &= 0xff;
151 }
152
153 return at24->client[i];
154}
155
156static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,
157 unsigned offset, size_t count)
158{
159 struct i2c_msg msg[2];
160 u8 msgbuf[2];
161 struct i2c_client *client;
162 unsigned long timeout, read_time;
163 int status, i;
164
165 memset(msg, 0, sizeof(msg));
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183 client = at24_translate_offset(at24, &offset);
184
185 if (count > io_limit)
186 count = io_limit;
187
188 switch (at24->use_smbus) {
189 case I2C_SMBUS_I2C_BLOCK_DATA:
190
191 if (count > I2C_SMBUS_BLOCK_MAX)
192 count = I2C_SMBUS_BLOCK_MAX;
193 break;
194 case I2C_SMBUS_WORD_DATA:
195 count = 2;
196 break;
197 case I2C_SMBUS_BYTE_DATA:
198 count = 1;
199 break;
200 default:
201
202
203
204
205
206
207
208 i = 0;
209 if (at24->chip.flags & AT24_FLAG_ADDR16)
210 msgbuf[i++] = offset >> 8;
211 msgbuf[i++] = offset;
212
213 msg[0].addr = client->addr;
214 msg[0].buf = msgbuf;
215 msg[0].len = i;
216
217 msg[1].addr = client->addr;
218 msg[1].flags = I2C_M_RD;
219 msg[1].buf = buf;
220 msg[1].len = count;
221 }
222
223
224
225
226
227
228 timeout = jiffies + msecs_to_jiffies(write_timeout);
229 do {
230 read_time = jiffies;
231 switch (at24->use_smbus) {
232 case I2C_SMBUS_I2C_BLOCK_DATA:
233 status = i2c_smbus_read_i2c_block_data(client, offset,
234 count, buf);
235 break;
236 case I2C_SMBUS_WORD_DATA:
237 status = i2c_smbus_read_word_data(client, offset);
238 if (status >= 0) {
239 buf[0] = status & 0xff;
240 buf[1] = status >> 8;
241 status = count;
242 }
243 break;
244 case I2C_SMBUS_BYTE_DATA:
245 status = i2c_smbus_read_byte_data(client, offset);
246 if (status >= 0) {
247 buf[0] = status;
248 status = count;
249 }
250 break;
251 default:
252 status = i2c_transfer(client->adapter, msg, 2);
253 if (status == 2)
254 status = count;
255 }
256 dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n",
257 count, offset, status, jiffies);
258
259 if (status == count)
260 return count;
261
262
263 msleep(1);
264 } while (time_before(read_time, timeout));
265
266 return -ETIMEDOUT;
267}
268
269static ssize_t at24_read(struct at24_data *at24,
270 char *buf, loff_t off, size_t count)
271{
272 ssize_t retval = 0;
273
274 if (unlikely(!count))
275 return count;
276
277
278
279
280
281 mutex_lock(&at24->lock);
282
283 while (count) {
284 ssize_t status;
285
286 status = at24_eeprom_read(at24, buf, off, count);
287 if (status <= 0) {
288 if (retval == 0)
289 retval = status;
290 break;
291 }
292 buf += status;
293 off += status;
294 count -= status;
295 retval += status;
296 }
297
298 mutex_unlock(&at24->lock);
299
300 return retval;
301}
302
303static ssize_t at24_bin_read(struct file *filp, struct kobject *kobj,
304 struct bin_attribute *attr,
305 char *buf, loff_t off, size_t count)
306{
307 struct at24_data *at24;
308
309 at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));
310 return at24_read(at24, buf, off, count);
311}
312
313
314
315
316
317
318
319
320
321
322static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf,
323 unsigned offset, size_t count)
324{
325 struct i2c_client *client;
326 struct i2c_msg msg;
327 ssize_t status;
328 unsigned long timeout, write_time;
329 unsigned next_page;
330
331
332 client = at24_translate_offset(at24, &offset);
333
334
335 if (count > at24->write_max)
336 count = at24->write_max;
337
338
339 next_page = roundup(offset + 1, at24->chip.page_size);
340 if (offset + count > next_page)
341 count = next_page - offset;
342
343
344 if (!at24->use_smbus) {
345 int i = 0;
346
347 msg.addr = client->addr;
348 msg.flags = 0;
349
350
351 msg.buf = at24->writebuf;
352 if (at24->chip.flags & AT24_FLAG_ADDR16)
353 msg.buf[i++] = offset >> 8;
354
355 msg.buf[i++] = offset;
356 memcpy(&msg.buf[i], buf, count);
357 msg.len = i + count;
358 }
359
360
361
362
363
364
365 timeout = jiffies + msecs_to_jiffies(write_timeout);
366 do {
367 write_time = jiffies;
368 if (at24->use_smbus) {
369 status = i2c_smbus_write_i2c_block_data(client,
370 offset, count, buf);
371 if (status == 0)
372 status = count;
373 } else {
374 status = i2c_transfer(client->adapter, &msg, 1);
375 if (status == 1)
376 status = count;
377 }
378 dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n",
379 count, offset, status, jiffies);
380
381 if (status == count)
382 return count;
383
384
385 msleep(1);
386 } while (time_before(write_time, timeout));
387
388 return -ETIMEDOUT;
389}
390
391static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,
392 size_t count)
393{
394 ssize_t retval = 0;
395
396 if (unlikely(!count))
397 return count;
398
399
400
401
402
403 mutex_lock(&at24->lock);
404
405 while (count) {
406 ssize_t status;
407
408 status = at24_eeprom_write(at24, buf, off, count);
409 if (status <= 0) {
410 if (retval == 0)
411 retval = status;
412 break;
413 }
414 buf += status;
415 off += status;
416 count -= status;
417 retval += status;
418 }
419
420 mutex_unlock(&at24->lock);
421
422 return retval;
423}
424
425static ssize_t at24_bin_write(struct file *filp, struct kobject *kobj,
426 struct bin_attribute *attr,
427 char *buf, loff_t off, size_t count)
428{
429 struct at24_data *at24;
430
431 at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));
432 return at24_write(at24, buf, off, count);
433}
434
435
436
437
438
439
440
441
442
443static ssize_t at24_macc_read(struct memory_accessor *macc, char *buf,
444 off_t offset, size_t count)
445{
446 struct at24_data *at24 = container_of(macc, struct at24_data, macc);
447
448 return at24_read(at24, buf, offset, count);
449}
450
451static ssize_t at24_macc_write(struct memory_accessor *macc, const char *buf,
452 off_t offset, size_t count)
453{
454 struct at24_data *at24 = container_of(macc, struct at24_data, macc);
455
456 return at24_write(at24, buf, offset, count);
457}
458
459
460
461#ifdef CONFIG_OF
462static void at24_get_ofdata(struct i2c_client *client,
463 struct at24_platform_data *chip)
464{
465 const __be32 *val;
466 struct device_node *node = client->dev.of_node;
467
468 if (node) {
469 if (of_get_property(node, "read-only", NULL))
470 chip->flags |= AT24_FLAG_READONLY;
471 val = of_get_property(node, "pagesize", NULL);
472 if (val)
473 chip->page_size = be32_to_cpup(val);
474 }
475}
476#else
477static void at24_get_ofdata(struct i2c_client *client,
478 struct at24_platform_data *chip)
479{ }
480#endif
481
482static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
483{
484 struct at24_platform_data chip;
485 bool writable;
486 int use_smbus = 0;
487 struct at24_data *at24;
488 int err;
489 unsigned i, num_addresses;
490 kernel_ulong_t magic;
491
492 if (client->dev.platform_data) {
493 chip = *(struct at24_platform_data *)client->dev.platform_data;
494 } else {
495 if (!id->driver_data)
496 return -ENODEV;
497
498 magic = id->driver_data;
499 chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN));
500 magic >>= AT24_SIZE_BYTELEN;
501 chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS);
502
503
504
505
506
507 chip.page_size = 1;
508
509
510 at24_get_ofdata(client, &chip);
511
512 chip.setup = NULL;
513 chip.context = NULL;
514 }
515
516 if (!is_power_of_2(chip.byte_len))
517 dev_warn(&client->dev,
518 "byte_len looks suspicious (no power of 2)!\n");
519 if (!chip.page_size) {
520 dev_err(&client->dev, "page_size must not be 0!\n");
521 return -EINVAL;
522 }
523 if (!is_power_of_2(chip.page_size))
524 dev_warn(&client->dev,
525 "page_size looks suspicious (no power of 2)!\n");
526
527
528 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
529 if (chip.flags & AT24_FLAG_ADDR16)
530 return -EPFNOSUPPORT;
531
532 if (i2c_check_functionality(client->adapter,
533 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
534 use_smbus = I2C_SMBUS_I2C_BLOCK_DATA;
535 } else if (i2c_check_functionality(client->adapter,
536 I2C_FUNC_SMBUS_READ_WORD_DATA)) {
537 use_smbus = I2C_SMBUS_WORD_DATA;
538 } else if (i2c_check_functionality(client->adapter,
539 I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
540 use_smbus = I2C_SMBUS_BYTE_DATA;
541 } else {
542 return -EPFNOSUPPORT;
543 }
544 }
545
546 if (chip.flags & AT24_FLAG_TAKE8ADDR)
547 num_addresses = 8;
548 else
549 num_addresses = DIV_ROUND_UP(chip.byte_len,
550 (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256);
551
552 at24 = devm_kzalloc(&client->dev, sizeof(struct at24_data) +
553 num_addresses * sizeof(struct i2c_client *), GFP_KERNEL);
554 if (!at24)
555 return -ENOMEM;
556
557 mutex_init(&at24->lock);
558 at24->use_smbus = use_smbus;
559 at24->chip = chip;
560 at24->num_addresses = num_addresses;
561
562
563
564
565
566 sysfs_bin_attr_init(&at24->bin);
567 at24->bin.attr.name = "eeprom";
568 at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;
569 at24->bin.read = at24_bin_read;
570 at24->bin.size = chip.byte_len;
571
572 at24->macc.read = at24_macc_read;
573
574 writable = !(chip.flags & AT24_FLAG_READONLY);
575 if (writable) {
576 if (!use_smbus || i2c_check_functionality(client->adapter,
577 I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
578
579 unsigned write_max = chip.page_size;
580
581 at24->macc.write = at24_macc_write;
582
583 at24->bin.write = at24_bin_write;
584 at24->bin.attr.mode |= S_IWUSR;
585
586 if (write_max > io_limit)
587 write_max = io_limit;
588 if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX)
589 write_max = I2C_SMBUS_BLOCK_MAX;
590 at24->write_max = write_max;
591
592
593 at24->writebuf = devm_kzalloc(&client->dev,
594 write_max + 2, GFP_KERNEL);
595 if (!at24->writebuf)
596 return -ENOMEM;
597 } else {
598 dev_warn(&client->dev,
599 "cannot write due to controller restrictions.");
600 }
601 }
602
603 at24->client[0] = client;
604
605
606 for (i = 1; i < num_addresses; i++) {
607 at24->client[i] = i2c_new_dummy(client->adapter,
608 client->addr + i);
609 if (!at24->client[i]) {
610 dev_err(&client->dev, "address 0x%02x unavailable\n",
611 client->addr + i);
612 err = -EADDRINUSE;
613 goto err_clients;
614 }
615 }
616
617 err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin);
618 if (err)
619 goto err_clients;
620
621 i2c_set_clientdata(client, at24);
622
623 dev_info(&client->dev, "%zu byte %s EEPROM, %s, %u bytes/write\n",
624 at24->bin.size, client->name,
625 writable ? "writable" : "read-only", at24->write_max);
626 if (use_smbus == I2C_SMBUS_WORD_DATA ||
627 use_smbus == I2C_SMBUS_BYTE_DATA) {
628 dev_notice(&client->dev, "Falling back to %s reads, "
629 "performance will suffer\n", use_smbus ==
630 I2C_SMBUS_WORD_DATA ? "word" : "byte");
631 }
632
633
634 if (chip.setup)
635 chip.setup(&at24->macc, chip.context);
636
637 return 0;
638
639err_clients:
640 for (i = 1; i < num_addresses; i++)
641 if (at24->client[i])
642 i2c_unregister_device(at24->client[i]);
643
644 return err;
645}
646
647static int at24_remove(struct i2c_client *client)
648{
649 struct at24_data *at24;
650 int i;
651
652 at24 = i2c_get_clientdata(client);
653 sysfs_remove_bin_file(&client->dev.kobj, &at24->bin);
654
655 for (i = 1; i < at24->num_addresses; i++)
656 i2c_unregister_device(at24->client[i]);
657
658 return 0;
659}
660
661
662
663static struct i2c_driver at24_driver = {
664 .driver = {
665 .name = "at24",
666 .owner = THIS_MODULE,
667 },
668 .probe = at24_probe,
669 .remove = at24_remove,
670 .id_table = at24_ids,
671};
672
673static int __init at24_init(void)
674{
675 if (!io_limit) {
676 pr_err("at24: io_limit must not be 0!\n");
677 return -EINVAL;
678 }
679
680 io_limit = rounddown_pow_of_two(io_limit);
681 return i2c_add_driver(&at24_driver);
682}
683module_init(at24_init);
684
685static void __exit at24_exit(void)
686{
687 i2c_del_driver(&at24_driver);
688}
689module_exit(at24_exit);
690
691MODULE_DESCRIPTION("Driver for most I2C EEPROMs");
692MODULE_AUTHOR("David Brownell and Wolfram Sang");
693MODULE_LICENSE("GPL");
694