1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * ee1004 - driver for DDR4 SPD EEPROMs |
4 | * |
5 | * Copyright (C) 2017-2019 Jean Delvare |
6 | * |
7 | * Based on the at24 driver: |
8 | * Copyright (C) 2005-2007 David Brownell |
9 | * Copyright (C) 2008 Wolfram Sang, Pengutronix |
10 | */ |
11 | |
12 | #include <linux/i2c.h> |
13 | #include <linux/init.h> |
14 | #include <linux/kernel.h> |
15 | #include <linux/mod_devicetable.h> |
16 | #include <linux/module.h> |
17 | #include <linux/mutex.h> |
18 | |
19 | /* |
20 | * DDR4 memory modules use special EEPROMs following the Jedec EE1004 |
21 | * specification. These are 512-byte EEPROMs using a single I2C address |
22 | * in the 0x50-0x57 range for data. One of two 256-byte page is selected |
23 | * by writing a command to I2C address 0x36 or 0x37 on the same I2C bus. |
24 | * |
25 | * Therefore we need to request these 2 additional addresses, and serialize |
26 | * access to all such EEPROMs with a single mutex. |
27 | * |
28 | * We assume it is safe to read up to 32 bytes at once from these EEPROMs. |
29 | * We use SMBus access even if I2C is available, these EEPROMs are small |
30 | * enough, and reading from them infrequent enough, that we favor simplicity |
31 | * over performance. |
32 | */ |
33 | |
34 | #define EE1004_MAX_BUSSES 8 |
35 | #define EE1004_ADDR_SET_PAGE 0x36 |
36 | #define EE1004_NUM_PAGES 2 |
37 | #define EE1004_PAGE_SIZE 256 |
38 | #define EE1004_PAGE_SHIFT 8 |
39 | #define EE1004_EEPROM_SIZE (EE1004_PAGE_SIZE * EE1004_NUM_PAGES) |
40 | |
41 | /* |
42 | * Mutex protects ee1004_set_page and ee1004_dev_count, and must be held |
43 | * from page selection to end of read. |
44 | */ |
45 | static DEFINE_MUTEX(ee1004_bus_lock); |
46 | |
47 | static struct ee1004_bus_data { |
48 | struct i2c_adapter *adap; |
49 | struct i2c_client *set_page[EE1004_NUM_PAGES]; |
50 | unsigned int dev_count; |
51 | int current_page; |
52 | } ee1004_bus_data[EE1004_MAX_BUSSES]; |
53 | |
54 | static const struct i2c_device_id ee1004_ids[] = { |
55 | { "ee1004" , 0 }, |
56 | { } |
57 | }; |
58 | MODULE_DEVICE_TABLE(i2c, ee1004_ids); |
59 | |
60 | /*-------------------------------------------------------------------------*/ |
61 | |
62 | static struct ee1004_bus_data *ee1004_get_bus_data(struct i2c_adapter *adap) |
63 | { |
64 | int i; |
65 | |
66 | for (i = 0; i < EE1004_MAX_BUSSES; i++) |
67 | if (ee1004_bus_data[i].adap == adap) |
68 | return ee1004_bus_data + i; |
69 | |
70 | /* If not existent yet, create new entry */ |
71 | for (i = 0; i < EE1004_MAX_BUSSES; i++) |
72 | if (!ee1004_bus_data[i].adap) { |
73 | ee1004_bus_data[i].adap = adap; |
74 | return ee1004_bus_data + i; |
75 | } |
76 | |
77 | return NULL; |
78 | } |
79 | |
80 | static int ee1004_get_current_page(struct ee1004_bus_data *bd) |
81 | { |
82 | int err; |
83 | |
84 | err = i2c_smbus_read_byte(client: bd->set_page[0]); |
85 | if (err == -ENXIO) { |
86 | /* Nack means page 1 is selected */ |
87 | return 1; |
88 | } |
89 | if (err < 0) { |
90 | /* Anything else is a real error, bail out */ |
91 | return err; |
92 | } |
93 | |
94 | /* Ack means page 0 is selected, returned value meaningless */ |
95 | return 0; |
96 | } |
97 | |
98 | static int ee1004_set_current_page(struct i2c_client *client, int page) |
99 | { |
100 | struct ee1004_bus_data *bd = i2c_get_clientdata(client); |
101 | int ret; |
102 | |
103 | if (page == bd->current_page) |
104 | return 0; |
105 | |
106 | /* Data is ignored */ |
107 | ret = i2c_smbus_write_byte(client: bd->set_page[page], value: 0x00); |
108 | /* |
109 | * Don't give up just yet. Some memory modules will select the page |
110 | * but not ack the command. Check which page is selected now. |
111 | */ |
112 | if (ret == -ENXIO && ee1004_get_current_page(bd) == page) |
113 | ret = 0; |
114 | if (ret < 0) { |
115 | dev_err(&client->dev, "Failed to select page %d (%d)\n" , page, ret); |
116 | return ret; |
117 | } |
118 | |
119 | dev_dbg(&client->dev, "Selected page %d\n" , page); |
120 | bd->current_page = page; |
121 | |
122 | return 0; |
123 | } |
124 | |
125 | static ssize_t ee1004_eeprom_read(struct i2c_client *client, char *buf, |
126 | unsigned int offset, size_t count) |
127 | { |
128 | int status, page; |
129 | |
130 | page = offset >> EE1004_PAGE_SHIFT; |
131 | offset &= (1 << EE1004_PAGE_SHIFT) - 1; |
132 | |
133 | status = ee1004_set_current_page(client, page); |
134 | if (status) |
135 | return status; |
136 | |
137 | /* Can't cross page boundaries */ |
138 | if (offset + count > EE1004_PAGE_SIZE) |
139 | count = EE1004_PAGE_SIZE - offset; |
140 | |
141 | if (count > I2C_SMBUS_BLOCK_MAX) |
142 | count = I2C_SMBUS_BLOCK_MAX; |
143 | |
144 | return i2c_smbus_read_i2c_block_data_or_emulated(client, command: offset, length: count, values: buf); |
145 | } |
146 | |
147 | static ssize_t eeprom_read(struct file *filp, struct kobject *kobj, |
148 | struct bin_attribute *bin_attr, |
149 | char *buf, loff_t off, size_t count) |
150 | { |
151 | struct i2c_client *client = kobj_to_i2c_client(kobj); |
152 | size_t requested = count; |
153 | int ret = 0; |
154 | |
155 | /* |
156 | * Read data from chip, protecting against concurrent access to |
157 | * other EE1004 SPD EEPROMs on the same adapter. |
158 | */ |
159 | mutex_lock(&ee1004_bus_lock); |
160 | |
161 | while (count) { |
162 | ret = ee1004_eeprom_read(client, buf, offset: off, count); |
163 | if (ret < 0) |
164 | goto out; |
165 | |
166 | buf += ret; |
167 | off += ret; |
168 | count -= ret; |
169 | } |
170 | out: |
171 | mutex_unlock(lock: &ee1004_bus_lock); |
172 | |
173 | return ret < 0 ? ret : requested; |
174 | } |
175 | |
176 | static BIN_ATTR_RO(eeprom, EE1004_EEPROM_SIZE); |
177 | |
178 | static struct bin_attribute *ee1004_attrs[] = { |
179 | &bin_attr_eeprom, |
180 | NULL |
181 | }; |
182 | |
183 | BIN_ATTRIBUTE_GROUPS(ee1004); |
184 | |
185 | static void ee1004_probe_temp_sensor(struct i2c_client *client) |
186 | { |
187 | struct i2c_board_info info = { .type = "jc42" }; |
188 | u8 byte14; |
189 | int ret; |
190 | |
191 | /* byte 14, bit 7 is set if temp sensor is present */ |
192 | ret = ee1004_eeprom_read(client, buf: &byte14, offset: 14, count: 1); |
193 | if (ret != 1 || !(byte14 & BIT(7))) |
194 | return; |
195 | |
196 | info.addr = 0x18 | (client->addr & 7); |
197 | |
198 | i2c_new_client_device(adap: client->adapter, info: &info); |
199 | } |
200 | |
201 | static void ee1004_cleanup(int idx, struct ee1004_bus_data *bd) |
202 | { |
203 | if (--bd->dev_count == 0) { |
204 | while (--idx >= 0) |
205 | i2c_unregister_device(client: bd->set_page[idx]); |
206 | memset(bd, 0, sizeof(struct ee1004_bus_data)); |
207 | } |
208 | } |
209 | |
210 | static int ee1004_probe(struct i2c_client *client) |
211 | { |
212 | struct ee1004_bus_data *bd; |
213 | int err, cnr = 0; |
214 | |
215 | /* Make sure we can operate on this adapter */ |
216 | if (!i2c_check_functionality(adap: client->adapter, |
217 | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_READ_I2C_BLOCK) && |
218 | !i2c_check_functionality(adap: client->adapter, |
219 | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_READ_BYTE_DATA)) |
220 | return -EPFNOSUPPORT; |
221 | |
222 | mutex_lock(&ee1004_bus_lock); |
223 | |
224 | bd = ee1004_get_bus_data(adap: client->adapter); |
225 | if (!bd) { |
226 | mutex_unlock(lock: &ee1004_bus_lock); |
227 | return dev_err_probe(dev: &client->dev, err: -ENOSPC, |
228 | fmt: "Only %d busses supported" , EE1004_MAX_BUSSES); |
229 | } |
230 | |
231 | i2c_set_clientdata(client, data: bd); |
232 | |
233 | if (++bd->dev_count == 1) { |
234 | /* Use 2 dummy devices for page select command */ |
235 | for (cnr = 0; cnr < EE1004_NUM_PAGES; cnr++) { |
236 | struct i2c_client *cl; |
237 | |
238 | cl = i2c_new_dummy_device(adapter: client->adapter, EE1004_ADDR_SET_PAGE + cnr); |
239 | if (IS_ERR(ptr: cl)) { |
240 | err = PTR_ERR(ptr: cl); |
241 | goto err_clients; |
242 | } |
243 | bd->set_page[cnr] = cl; |
244 | } |
245 | |
246 | /* Remember current page to avoid unneeded page select */ |
247 | err = ee1004_get_current_page(bd); |
248 | if (err < 0) |
249 | goto err_clients; |
250 | dev_dbg(&client->dev, "Currently selected page: %d\n" , err); |
251 | bd->current_page = err; |
252 | } |
253 | |
254 | ee1004_probe_temp_sensor(client); |
255 | |
256 | mutex_unlock(lock: &ee1004_bus_lock); |
257 | |
258 | dev_info(&client->dev, |
259 | "%u byte EE1004-compliant SPD EEPROM, read-only\n" , |
260 | EE1004_EEPROM_SIZE); |
261 | |
262 | return 0; |
263 | |
264 | err_clients: |
265 | ee1004_cleanup(idx: cnr, bd); |
266 | mutex_unlock(lock: &ee1004_bus_lock); |
267 | |
268 | return err; |
269 | } |
270 | |
271 | static void ee1004_remove(struct i2c_client *client) |
272 | { |
273 | struct ee1004_bus_data *bd = i2c_get_clientdata(client); |
274 | |
275 | /* Remove page select clients if this is the last device */ |
276 | mutex_lock(&ee1004_bus_lock); |
277 | ee1004_cleanup(EE1004_NUM_PAGES, bd); |
278 | mutex_unlock(lock: &ee1004_bus_lock); |
279 | } |
280 | |
281 | /*-------------------------------------------------------------------------*/ |
282 | |
283 | static struct i2c_driver ee1004_driver = { |
284 | .driver = { |
285 | .name = "ee1004" , |
286 | .dev_groups = ee1004_groups, |
287 | }, |
288 | .probe = ee1004_probe, |
289 | .remove = ee1004_remove, |
290 | .id_table = ee1004_ids, |
291 | }; |
292 | module_i2c_driver(ee1004_driver); |
293 | |
294 | MODULE_DESCRIPTION("Driver for EE1004-compliant DDR4 SPD EEPROMs" ); |
295 | MODULE_AUTHOR("Jean Delvare" ); |
296 | MODULE_LICENSE("GPL" ); |
297 | |