Commit | Line | Data |
---|---|---|
b886d83c | 1 | // SPDX-License-Identifier: GPL-2.0-only |
389be323 WS |
2 | /* |
3 | * I2C slave mode EEPROM simulator | |
4 | * | |
5 | * Copyright (C) 2014 by Wolfram Sang, Sang Engineering <wsa@sang-engineering.com> | |
6 | * Copyright (C) 2014 by Renesas Electronics Corporation | |
7 | * | |
389be323 WS |
8 | * Because most IP blocks can only detect one I2C slave address anyhow, this |
9 | * driver does not support simulating EEPROM types which take more than one | |
10 | * address. It is prepared to simulate bigger EEPROMs with an internal 16 bit | |
11 | * pointer, yet implementation is deferred until the need actually arises. | |
12 | */ | |
13 | ||
fe050f99 BA |
14 | /* |
15 | * FIXME: What to do if only 8 bits of a 16 bit address are sent? | |
16 | * The ST-M24C64 sends only 0xff then. Needs verification with other | |
17 | * EEPROMs, though. We currently use the 8 bit as a valid address. | |
18 | */ | |
19 | ||
82d51481 | 20 | #include <linux/bitfield.h> |
389be323 WS |
21 | #include <linux/i2c.h> |
22 | #include <linux/init.h> | |
23 | #include <linux/module.h> | |
24 | #include <linux/of.h> | |
25 | #include <linux/slab.h> | |
26 | #include <linux/spinlock.h> | |
27 | #include <linux/sysfs.h> | |
28 | ||
29 | struct eeprom_data { | |
30 | struct bin_attribute bin; | |
389be323 | 31 | spinlock_t buffer_lock; |
82d51481 BA |
32 | u16 buffer_idx; |
33 | u16 address_mask; | |
34 | u8 num_address_bytes; | |
35 | u8 idx_write_cnt; | |
11af27f4 | 36 | bool read_only; |
389be323 WS |
37 | u8 buffer[]; |
38 | }; | |
39 | ||
82d51481 BA |
40 | #define I2C_SLAVE_BYTELEN GENMASK(15, 0) |
41 | #define I2C_SLAVE_FLAG_ADDR16 BIT(16) | |
11af27f4 | 42 | #define I2C_SLAVE_FLAG_RO BIT(17) |
82d51481 BA |
43 | #define I2C_SLAVE_DEVICE_MAGIC(_len, _flags) ((_flags) | (_len)) |
44 | ||
389be323 WS |
45 | static int i2c_slave_eeprom_slave_cb(struct i2c_client *client, |
46 | enum i2c_slave_event event, u8 *val) | |
47 | { | |
48 | struct eeprom_data *eeprom = i2c_get_clientdata(client); | |
49 | ||
50 | switch (event) { | |
5b77d162 | 51 | case I2C_SLAVE_WRITE_RECEIVED: |
82d51481 BA |
52 | if (eeprom->idx_write_cnt < eeprom->num_address_bytes) { |
53 | if (eeprom->idx_write_cnt == 0) | |
54 | eeprom->buffer_idx = 0; | |
55 | eeprom->buffer_idx = *val | (eeprom->buffer_idx << 8); | |
56 | eeprom->idx_write_cnt++; | |
389be323 | 57 | } else { |
11af27f4 BA |
58 | if (!eeprom->read_only) { |
59 | spin_lock(&eeprom->buffer_lock); | |
60 | eeprom->buffer[eeprom->buffer_idx++ & eeprom->address_mask] = *val; | |
61 | spin_unlock(&eeprom->buffer_lock); | |
62 | } | |
389be323 WS |
63 | } |
64 | break; | |
65 | ||
5b77d162 | 66 | case I2C_SLAVE_READ_PROCESSED: |
98e982b3 | 67 | /* The previous byte made it to the bus, get next one */ |
5b77d162 WS |
68 | eeprom->buffer_idx++; |
69 | /* fallthrough */ | |
70 | case I2C_SLAVE_READ_REQUESTED: | |
389be323 | 71 | spin_lock(&eeprom->buffer_lock); |
82d51481 | 72 | *val = eeprom->buffer[eeprom->buffer_idx & eeprom->address_mask]; |
389be323 | 73 | spin_unlock(&eeprom->buffer_lock); |
98e982b3 WS |
74 | /* |
75 | * Do not increment buffer_idx here, because we don't know if | |
76 | * this byte will be actually used. Read Linux I2C slave docs | |
77 | * for details. | |
78 | */ | |
389be323 WS |
79 | break; |
80 | ||
389be323 | 81 | case I2C_SLAVE_STOP: |
5b77d162 | 82 | case I2C_SLAVE_WRITE_REQUESTED: |
82d51481 | 83 | eeprom->idx_write_cnt = 0; |
389be323 WS |
84 | break; |
85 | ||
86 | default: | |
87 | break; | |
88 | } | |
89 | ||
90 | return 0; | |
91 | } | |
92 | ||
93 | static ssize_t i2c_slave_eeprom_bin_read(struct file *filp, struct kobject *kobj, | |
94 | struct bin_attribute *attr, char *buf, loff_t off, size_t count) | |
95 | { | |
96 | struct eeprom_data *eeprom; | |
97 | unsigned long flags; | |
98 | ||
389be323 WS |
99 | eeprom = dev_get_drvdata(container_of(kobj, struct device, kobj)); |
100 | ||
101 | spin_lock_irqsave(&eeprom->buffer_lock, flags); | |
102 | memcpy(buf, &eeprom->buffer[off], count); | |
103 | spin_unlock_irqrestore(&eeprom->buffer_lock, flags); | |
104 | ||
105 | return count; | |
106 | } | |
107 | ||
108 | static ssize_t i2c_slave_eeprom_bin_write(struct file *filp, struct kobject *kobj, | |
109 | struct bin_attribute *attr, char *buf, loff_t off, size_t count) | |
110 | { | |
111 | struct eeprom_data *eeprom; | |
112 | unsigned long flags; | |
113 | ||
389be323 WS |
114 | eeprom = dev_get_drvdata(container_of(kobj, struct device, kobj)); |
115 | ||
116 | spin_lock_irqsave(&eeprom->buffer_lock, flags); | |
117 | memcpy(&eeprom->buffer[off], buf, count); | |
118 | spin_unlock_irqrestore(&eeprom->buffer_lock, flags); | |
119 | ||
120 | return count; | |
121 | } | |
122 | ||
123 | static int i2c_slave_eeprom_probe(struct i2c_client *client, const struct i2c_device_id *id) | |
124 | { | |
125 | struct eeprom_data *eeprom; | |
126 | int ret; | |
82d51481 BA |
127 | unsigned int size = FIELD_GET(I2C_SLAVE_BYTELEN, id->driver_data); |
128 | unsigned int flag_addr16 = FIELD_GET(I2C_SLAVE_FLAG_ADDR16, id->driver_data); | |
389be323 WS |
129 | |
130 | eeprom = devm_kzalloc(&client->dev, sizeof(struct eeprom_data) + size, GFP_KERNEL); | |
131 | if (!eeprom) | |
132 | return -ENOMEM; | |
133 | ||
82d51481 BA |
134 | eeprom->idx_write_cnt = 0; |
135 | eeprom->num_address_bytes = flag_addr16 ? 2 : 1; | |
136 | eeprom->address_mask = size - 1; | |
11af27f4 | 137 | eeprom->read_only = FIELD_GET(I2C_SLAVE_FLAG_RO, id->driver_data); |
389be323 WS |
138 | spin_lock_init(&eeprom->buffer_lock); |
139 | i2c_set_clientdata(client, eeprom); | |
140 | ||
141 | sysfs_bin_attr_init(&eeprom->bin); | |
142 | eeprom->bin.attr.name = "slave-eeprom"; | |
143 | eeprom->bin.attr.mode = S_IRUSR | S_IWUSR; | |
144 | eeprom->bin.read = i2c_slave_eeprom_bin_read; | |
145 | eeprom->bin.write = i2c_slave_eeprom_bin_write; | |
146 | eeprom->bin.size = size; | |
147 | ||
148 | ret = sysfs_create_bin_file(&client->dev.kobj, &eeprom->bin); | |
149 | if (ret) | |
150 | return ret; | |
151 | ||
152 | ret = i2c_slave_register(client, i2c_slave_eeprom_slave_cb); | |
153 | if (ret) { | |
154 | sysfs_remove_bin_file(&client->dev.kobj, &eeprom->bin); | |
155 | return ret; | |
156 | } | |
157 | ||
158 | return 0; | |
159 | }; | |
160 | ||
161 | static int i2c_slave_eeprom_remove(struct i2c_client *client) | |
162 | { | |
163 | struct eeprom_data *eeprom = i2c_get_clientdata(client); | |
164 | ||
165 | i2c_slave_unregister(client); | |
166 | sysfs_remove_bin_file(&client->dev.kobj, &eeprom->bin); | |
167 | ||
168 | return 0; | |
169 | } | |
170 | ||
171 | static const struct i2c_device_id i2c_slave_eeprom_id[] = { | |
82d51481 | 172 | { "slave-24c02", I2C_SLAVE_DEVICE_MAGIC(2048 / 8, 0) }, |
11af27f4 | 173 | { "slave-24c02ro", I2C_SLAVE_DEVICE_MAGIC(2048 / 8, I2C_SLAVE_FLAG_RO) }, |
82d51481 | 174 | { "slave-24c32", I2C_SLAVE_DEVICE_MAGIC(32768 / 8, I2C_SLAVE_FLAG_ADDR16) }, |
11af27f4 | 175 | { "slave-24c32ro", I2C_SLAVE_DEVICE_MAGIC(32768 / 8, I2C_SLAVE_FLAG_ADDR16 | I2C_SLAVE_FLAG_RO) }, |
82d51481 | 176 | { "slave-24c64", I2C_SLAVE_DEVICE_MAGIC(65536 / 8, I2C_SLAVE_FLAG_ADDR16) }, |
11af27f4 | 177 | { "slave-24c64ro", I2C_SLAVE_DEVICE_MAGIC(65536 / 8, I2C_SLAVE_FLAG_ADDR16 | I2C_SLAVE_FLAG_RO) }, |
389be323 WS |
178 | { } |
179 | }; | |
180 | MODULE_DEVICE_TABLE(i2c, i2c_slave_eeprom_id); | |
181 | ||
182 | static struct i2c_driver i2c_slave_eeprom_driver = { | |
183 | .driver = { | |
184 | .name = "i2c-slave-eeprom", | |
389be323 WS |
185 | }, |
186 | .probe = i2c_slave_eeprom_probe, | |
187 | .remove = i2c_slave_eeprom_remove, | |
188 | .id_table = i2c_slave_eeprom_id, | |
189 | }; | |
190 | module_i2c_driver(i2c_slave_eeprom_driver); | |
191 | ||
192 | MODULE_AUTHOR("Wolfram Sang <wsa@sang-engineering.com>"); | |
193 | MODULE_DESCRIPTION("I2C slave mode EEPROM simulator"); | |
194 | MODULE_LICENSE("GPL v2"); |