blob: 3651ba4871efe49222a58dc380315c36117e43b8 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass20142012014-12-10 08:55:54 -07002/*
3 * Copyright (c) 2014 Google, Inc
Simon Glass20142012014-12-10 08:55:54 -07004 */
5
6#include <common.h>
Simon Glasscb3ef682019-11-14 12:57:50 -07007#include <eeprom.h>
Simon Glassc05ed002020-05-10 11:40:11 -06008#include <linux/delay.h>
Masahiro Yamadaee5ee872014-12-18 20:00:26 +09009#include <linux/err.h>
Baruch Siach84c80c62019-04-07 12:38:49 +030010#include <linux/kernel.h>
Simon Glass20142012014-12-10 08:55:54 -070011#include <dm.h>
Robert Beckett1a59cb42019-10-28 18:29:05 +000012#include <dm/device-internal.h>
Simon Glass20142012014-12-10 08:55:54 -070013#include <i2c.h>
14#include <i2c_eeprom.h>
15
Robert Beckett033e18b2019-10-28 18:29:06 +000016struct i2c_eeprom_drv_data {
17 u32 size; /* size in bytes */
Masahiro Yamada0c17bb12020-02-28 22:04:14 +090018 u32 pagesize; /* page size in bytes */
Robert Beckett821c9822020-01-31 15:07:52 +020019 u32 addr_offset_mask; /* bits in addr used for offset overflow */
20 u32 offset_len; /* size in bytes of offset */
Eugen Hristevb24dc832020-05-07 11:53:18 +030021 u32 start_offset; /* valid start offset inside memory, by default 0 */
Robert Beckett033e18b2019-10-28 18:29:06 +000022};
23
Jonas Karlman8880efb2017-04-22 08:57:41 +000024int i2c_eeprom_read(struct udevice *dev, int offset, uint8_t *buf, int size)
25{
26 const struct i2c_eeprom_ops *ops = device_get_ops(dev);
27
28 if (!ops->read)
29 return -ENOSYS;
30
31 return ops->read(dev, offset, buf, size);
32}
33
34int i2c_eeprom_write(struct udevice *dev, int offset, uint8_t *buf, int size)
35{
36 const struct i2c_eeprom_ops *ops = device_get_ops(dev);
37
38 if (!ops->write)
39 return -ENOSYS;
40
41 return ops->write(dev, offset, buf, size);
42}
43
Robert Beckett033e18b2019-10-28 18:29:06 +000044int i2c_eeprom_size(struct udevice *dev)
45{
46 const struct i2c_eeprom_ops *ops = device_get_ops(dev);
47
48 if (!ops->size)
49 return -ENOSYS;
50
51 return ops->size(dev);
52}
53
Jonas Karlman8880efb2017-04-22 08:57:41 +000054static int i2c_eeprom_std_read(struct udevice *dev, int offset, uint8_t *buf,
55 int size)
Simon Glass20142012014-12-10 08:55:54 -070056{
mario.six@gdsys.ccd7e28912016-06-22 15:14:16 +020057 return dm_i2c_read(dev, offset, buf, size);
Simon Glass20142012014-12-10 08:55:54 -070058}
59
Jonas Karlman8880efb2017-04-22 08:57:41 +000060static int i2c_eeprom_std_write(struct udevice *dev, int offset,
61 const uint8_t *buf, int size)
Simon Glass20142012014-12-10 08:55:54 -070062{
Baruch Siach84c80c62019-04-07 12:38:49 +030063 struct i2c_eeprom *priv = dev_get_priv(dev);
64 int ret;
65
66 while (size > 0) {
67 int write_size = min_t(int, size, priv->pagesize);
68
69 ret = dm_i2c_write(dev, offset, buf, write_size);
70 if (ret)
71 return ret;
72
73 offset += write_size;
74 buf += write_size;
75 size -= write_size;
76
77 udelay(10000);
78 }
79
80 return 0;
Simon Glass20142012014-12-10 08:55:54 -070081}
82
Robert Beckett033e18b2019-10-28 18:29:06 +000083static int i2c_eeprom_std_size(struct udevice *dev)
84{
85 struct i2c_eeprom *priv = dev_get_priv(dev);
86
87 return priv->size;
88}
89
Masahiro Yamada5e75ea12017-06-22 16:51:22 +090090static const struct i2c_eeprom_ops i2c_eeprom_std_ops = {
Jonas Karlman8880efb2017-04-22 08:57:41 +000091 .read = i2c_eeprom_std_read,
92 .write = i2c_eeprom_std_write,
Robert Beckett033e18b2019-10-28 18:29:06 +000093 .size = i2c_eeprom_std_size,
Simon Glass20142012014-12-10 08:55:54 -070094};
95
mario.six@gdsys.ccd7e28912016-06-22 15:14:16 +020096static int i2c_eeprom_std_ofdata_to_platdata(struct udevice *dev)
97{
98 struct i2c_eeprom *priv = dev_get_priv(dev);
Robert Beckett033e18b2019-10-28 18:29:06 +000099 struct i2c_eeprom_drv_data *data =
100 (struct i2c_eeprom_drv_data *)dev_get_driver_data(dev);
Baruch Siacha29034d2019-04-07 12:38:48 +0300101 u32 pagesize;
Robert Beckett033e18b2019-10-28 18:29:06 +0000102 u32 size;
Baruch Siacha29034d2019-04-07 12:38:48 +0300103
Masahiro Yamadaed6dd4e2020-02-28 22:04:13 +0900104 if (dev_read_u32(dev, "pagesize", &pagesize) == 0)
Baruch Siacha29034d2019-04-07 12:38:48 +0300105 priv->pagesize = pagesize;
Masahiro Yamadaed6dd4e2020-02-28 22:04:13 +0900106 else
Robert Beckett033e18b2019-10-28 18:29:06 +0000107 /* 6 bit -> page size of up to 2^63 (should be sufficient) */
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900108 priv->pagesize = data->pagesize;
mario.six@gdsys.ccd7e28912016-06-22 15:14:16 +0200109
Robert Beckett033e18b2019-10-28 18:29:06 +0000110 if (dev_read_u32(dev, "size", &size) == 0)
111 priv->size = size;
112 else
113 priv->size = data->size;
mario.six@gdsys.ccd7e28912016-06-22 15:14:16 +0200114
115 return 0;
116}
117
Robert Beckett1a59cb42019-10-28 18:29:05 +0000118static int i2c_eeprom_std_bind(struct udevice *dev)
119{
120 ofnode partitions = ofnode_find_subnode(dev_ofnode(dev), "partitions");
121 ofnode partition;
122 const char *name;
123
124 if (!ofnode_valid(partitions))
125 return 0;
126 if (!ofnode_device_is_compatible(partitions, "fixed-partitions"))
127 return -ENOTSUPP;
128
129 ofnode_for_each_subnode(partition, partitions) {
130 name = ofnode_get_name(partition);
131 if (!name)
132 continue;
133
134 device_bind_ofnode(dev, DM_GET_DRIVER(i2c_eeprom_partition),
135 name, NULL, partition, NULL);
136 }
137
138 return 0;
139}
140
Masahiro Yamada5e75ea12017-06-22 16:51:22 +0900141static int i2c_eeprom_std_probe(struct udevice *dev)
Simon Glass20142012014-12-10 08:55:54 -0700142{
Baruch Siach5ae84862019-08-05 09:03:30 +0300143 u8 test_byte;
144 int ret;
Robert Beckett821c9822020-01-31 15:07:52 +0200145 struct i2c_eeprom_drv_data *data =
146 (struct i2c_eeprom_drv_data *)dev_get_driver_data(dev);
147
148 i2c_set_chip_offset_len(dev, data->offset_len);
149 i2c_set_chip_addr_offset_mask(dev, data->addr_offset_mask);
Baruch Siach5ae84862019-08-05 09:03:30 +0300150
151 /* Verify that the chip is functional */
Eugen Hristevb24dc832020-05-07 11:53:18 +0300152 /*
153 * Not all eeproms start from offset 0. Valid offset is available
154 * in the platform data struct.
155 */
156 ret = i2c_eeprom_read(dev, data->start_offset, &test_byte, 1);
Baruch Siach5ae84862019-08-05 09:03:30 +0300157 if (ret)
158 return -ENODEV;
159
Simon Glass20142012014-12-10 08:55:54 -0700160 return 0;
161}
162
Robert Beckett033e18b2019-10-28 18:29:06 +0000163static const struct i2c_eeprom_drv_data eeprom_data = {
164 .size = 0,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900165 .pagesize = 1,
Robert Beckett821c9822020-01-31 15:07:52 +0200166 .addr_offset_mask = 0,
167 .offset_len = 1,
Robert Beckett033e18b2019-10-28 18:29:06 +0000168};
169
170static const struct i2c_eeprom_drv_data mc24aa02e48_data = {
171 .size = 256,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900172 .pagesize = 8,
Robert Beckett821c9822020-01-31 15:07:52 +0200173 .addr_offset_mask = 0,
174 .offset_len = 1,
Robert Beckett033e18b2019-10-28 18:29:06 +0000175};
176
177static const struct i2c_eeprom_drv_data atmel24c01a_data = {
178 .size = 128,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900179 .pagesize = 8,
Robert Beckett821c9822020-01-31 15:07:52 +0200180 .addr_offset_mask = 0,
181 .offset_len = 1,
Robert Beckett033e18b2019-10-28 18:29:06 +0000182};
183
184static const struct i2c_eeprom_drv_data atmel24c02_data = {
185 .size = 256,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900186 .pagesize = 8,
Robert Beckett821c9822020-01-31 15:07:52 +0200187 .addr_offset_mask = 0,
188 .offset_len = 1,
Robert Beckett033e18b2019-10-28 18:29:06 +0000189};
190
191static const struct i2c_eeprom_drv_data atmel24c04_data = {
192 .size = 512,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900193 .pagesize = 16,
Robert Beckett821c9822020-01-31 15:07:52 +0200194 .addr_offset_mask = 0x1,
195 .offset_len = 1,
Robert Beckett033e18b2019-10-28 18:29:06 +0000196};
197
198static const struct i2c_eeprom_drv_data atmel24c08_data = {
199 .size = 1024,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900200 .pagesize = 16,
Robert Beckett821c9822020-01-31 15:07:52 +0200201 .addr_offset_mask = 0x3,
202 .offset_len = 1,
Robert Beckett033e18b2019-10-28 18:29:06 +0000203};
204
205static const struct i2c_eeprom_drv_data atmel24c08a_data = {
206 .size = 1024,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900207 .pagesize = 16,
Robert Beckett821c9822020-01-31 15:07:52 +0200208 .addr_offset_mask = 0x3,
209 .offset_len = 1,
Robert Beckett033e18b2019-10-28 18:29:06 +0000210};
211
212static const struct i2c_eeprom_drv_data atmel24c16a_data = {
213 .size = 2048,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900214 .pagesize = 16,
Robert Beckett821c9822020-01-31 15:07:52 +0200215 .addr_offset_mask = 0x7,
216 .offset_len = 1,
Robert Beckett033e18b2019-10-28 18:29:06 +0000217};
218
219static const struct i2c_eeprom_drv_data atmel24mac402_data = {
220 .size = 256,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900221 .pagesize = 16,
Robert Beckett821c9822020-01-31 15:07:52 +0200222 .addr_offset_mask = 0,
223 .offset_len = 1,
Eugen Hristevb24dc832020-05-07 11:53:18 +0300224 .start_offset = 0x80,
Robert Beckett033e18b2019-10-28 18:29:06 +0000225};
226
227static const struct i2c_eeprom_drv_data atmel24c32_data = {
228 .size = 4096,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900229 .pagesize = 32,
Robert Beckett821c9822020-01-31 15:07:52 +0200230 .addr_offset_mask = 0,
231 .offset_len = 2,
Robert Beckett033e18b2019-10-28 18:29:06 +0000232};
233
234static const struct i2c_eeprom_drv_data atmel24c64_data = {
235 .size = 8192,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900236 .pagesize = 32,
Robert Beckett821c9822020-01-31 15:07:52 +0200237 .addr_offset_mask = 0,
238 .offset_len = 2,
Robert Beckett033e18b2019-10-28 18:29:06 +0000239};
240
241static const struct i2c_eeprom_drv_data atmel24c128_data = {
242 .size = 16384,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900243 .pagesize = 64,
Robert Beckett821c9822020-01-31 15:07:52 +0200244 .addr_offset_mask = 0,
245 .offset_len = 2,
Robert Beckett033e18b2019-10-28 18:29:06 +0000246};
247
248static const struct i2c_eeprom_drv_data atmel24c256_data = {
249 .size = 32768,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900250 .pagesize = 64,
Robert Beckett821c9822020-01-31 15:07:52 +0200251 .addr_offset_mask = 0,
252 .offset_len = 2,
Robert Beckett033e18b2019-10-28 18:29:06 +0000253};
254
255static const struct i2c_eeprom_drv_data atmel24c512_data = {
256 .size = 65536,
Masahiro Yamada0c17bb12020-02-28 22:04:14 +0900257 .pagesize = 64,
Robert Beckett821c9822020-01-31 15:07:52 +0200258 .addr_offset_mask = 0,
259 .offset_len = 2,
Robert Beckett033e18b2019-10-28 18:29:06 +0000260};
261
Simon Glass20142012014-12-10 08:55:54 -0700262static const struct udevice_id i2c_eeprom_std_ids[] = {
Robert Beckett033e18b2019-10-28 18:29:06 +0000263 { .compatible = "i2c-eeprom", (ulong)&eeprom_data },
264 { .compatible = "microchip,24aa02e48", (ulong)&mc24aa02e48_data },
265 { .compatible = "atmel,24c01a", (ulong)&atmel24c01a_data },
266 { .compatible = "atmel,24c02", (ulong)&atmel24c02_data },
267 { .compatible = "atmel,24c04", (ulong)&atmel24c04_data },
268 { .compatible = "atmel,24c08", (ulong)&atmel24c08_data },
269 { .compatible = "atmel,24c08a", (ulong)&atmel24c08a_data },
270 { .compatible = "atmel,24c16a", (ulong)&atmel24c16a_data },
271 { .compatible = "atmel,24mac402", (ulong)&atmel24mac402_data },
272 { .compatible = "atmel,24c32", (ulong)&atmel24c32_data },
273 { .compatible = "atmel,24c64", (ulong)&atmel24c64_data },
274 { .compatible = "atmel,24c128", (ulong)&atmel24c128_data },
275 { .compatible = "atmel,24c256", (ulong)&atmel24c256_data },
276 { .compatible = "atmel,24c512", (ulong)&atmel24c512_data },
Simon Glass20142012014-12-10 08:55:54 -0700277 { }
278};
279
280U_BOOT_DRIVER(i2c_eeprom_std) = {
mario.six@gdsys.ccd7e28912016-06-22 15:14:16 +0200281 .name = "i2c_eeprom",
282 .id = UCLASS_I2C_EEPROM,
283 .of_match = i2c_eeprom_std_ids,
Robert Beckett1a59cb42019-10-28 18:29:05 +0000284 .bind = i2c_eeprom_std_bind,
mario.six@gdsys.ccd7e28912016-06-22 15:14:16 +0200285 .probe = i2c_eeprom_std_probe,
286 .ofdata_to_platdata = i2c_eeprom_std_ofdata_to_platdata,
287 .priv_auto_alloc_size = sizeof(struct i2c_eeprom),
288 .ops = &i2c_eeprom_std_ops,
Simon Glass20142012014-12-10 08:55:54 -0700289};
290
Robert Beckett1a59cb42019-10-28 18:29:05 +0000291struct i2c_eeprom_partition {
292 u32 offset;
293 u32 size;
294};
295
296static int i2c_eeprom_partition_probe(struct udevice *dev)
297{
298 return 0;
299}
300
301static int i2c_eeprom_partition_ofdata_to_platdata(struct udevice *dev)
302{
303 struct i2c_eeprom_partition *priv = dev_get_priv(dev);
Michal Simekf692b472020-05-28 11:48:55 +0200304 u32 reg[2];
Robert Beckett1a59cb42019-10-28 18:29:05 +0000305 int ret;
306
Michal Simekf692b472020-05-28 11:48:55 +0200307 ret = dev_read_u32_array(dev, "reg", reg, 2);
Robert Beckett1a59cb42019-10-28 18:29:05 +0000308 if (ret)
309 return ret;
310
Michal Simekf692b472020-05-28 11:48:55 +0200311 if (!reg[1])
312 return -EINVAL;
Robert Beckett1a59cb42019-10-28 18:29:05 +0000313
Michal Simekf692b472020-05-28 11:48:55 +0200314 priv->offset = reg[0];
315 priv->size = reg[1];
316
317 debug("%s: base %x, size %x\n", __func__, priv->offset, priv->size);
Robert Beckett1a59cb42019-10-28 18:29:05 +0000318
319 return 0;
320}
321
322static int i2c_eeprom_partition_read(struct udevice *dev, int offset,
323 u8 *buf, int size)
324{
325 struct i2c_eeprom_partition *priv = dev_get_priv(dev);
326 struct udevice *parent = dev_get_parent(dev);
327
328 if (!parent)
329 return -ENODEV;
330 if (offset + size > priv->size)
331 return -EINVAL;
332
333 return i2c_eeprom_read(parent, offset + priv->offset, buf, size);
334}
335
336static int i2c_eeprom_partition_write(struct udevice *dev, int offset,
337 const u8 *buf, int size)
338{
339 struct i2c_eeprom_partition *priv = dev_get_priv(dev);
340 struct udevice *parent = dev_get_parent(dev);
341
342 if (!parent)
343 return -ENODEV;
344 if (offset + size > priv->size)
345 return -EINVAL;
346
347 return i2c_eeprom_write(parent, offset + priv->offset, (uint8_t *)buf,
348 size);
349}
350
Robert Beckett033e18b2019-10-28 18:29:06 +0000351static int i2c_eeprom_partition_size(struct udevice *dev)
352{
353 struct i2c_eeprom_partition *priv = dev_get_priv(dev);
354
355 return priv->size;
356}
357
Robert Beckett1a59cb42019-10-28 18:29:05 +0000358static const struct i2c_eeprom_ops i2c_eeprom_partition_ops = {
359 .read = i2c_eeprom_partition_read,
360 .write = i2c_eeprom_partition_write,
Robert Beckett033e18b2019-10-28 18:29:06 +0000361 .size = i2c_eeprom_partition_size,
Robert Beckett1a59cb42019-10-28 18:29:05 +0000362};
363
364U_BOOT_DRIVER(i2c_eeprom_partition) = {
365 .name = "i2c_eeprom_partition",
366 .id = UCLASS_I2C_EEPROM,
367 .probe = i2c_eeprom_partition_probe,
368 .ofdata_to_platdata = i2c_eeprom_partition_ofdata_to_platdata,
369 .priv_auto_alloc_size = sizeof(struct i2c_eeprom_partition),
370 .ops = &i2c_eeprom_partition_ops,
371};
372
Simon Glass20142012014-12-10 08:55:54 -0700373UCLASS_DRIVER(i2c_eeprom) = {
374 .id = UCLASS_I2C_EEPROM,
375 .name = "i2c_eeprom",
376};