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