diff options
Diffstat (limited to 'drivers/i2c/i2c-core.c')
-rw-r--r-- | drivers/i2c/i2c-core.c | 364 |
1 files changed, 364 insertions, 0 deletions
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c index 632057a44615..ccfbbab82a15 100644 --- a/drivers/i2c/i2c-core.c +++ b/drivers/i2c/i2c-core.c | |||
@@ -27,6 +27,8 @@ | |||
27 | OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de> | 27 | OF support is copyright (c) 2008 Jochen Friedrich <jochen@scram.de> |
28 | (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and | 28 | (based on a previous patch from Jon Smirl <jonsmirl@gmail.com>) and |
29 | (c) 2013 Wolfram Sang <wsa@the-dreams.de> | 29 | (c) 2013 Wolfram Sang <wsa@the-dreams.de> |
30 | I2C ACPI code Copyright (C) 2014 Intel Corp | ||
31 | Author: Lan Tianyu <tianyu.lan@intel.com> | ||
30 | */ | 32 | */ |
31 | 33 | ||
32 | #include <linux/module.h> | 34 | #include <linux/module.h> |
@@ -78,6 +80,368 @@ void i2c_transfer_trace_unreg(void) | |||
78 | static_key_slow_dec(&i2c_trace_msg); | 80 | static_key_slow_dec(&i2c_trace_msg); |
79 | } | 81 | } |
80 | 82 | ||
83 | #if defined(CONFIG_ACPI) | ||
84 | struct acpi_i2c_handler_data { | ||
85 | struct acpi_connection_info info; | ||
86 | struct i2c_adapter *adapter; | ||
87 | }; | ||
88 | |||
89 | struct gsb_buffer { | ||
90 | u8 status; | ||
91 | u8 len; | ||
92 | union { | ||
93 | u16 wdata; | ||
94 | u8 bdata; | ||
95 | u8 data[0]; | ||
96 | }; | ||
97 | } __packed; | ||
98 | |||
99 | static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data) | ||
100 | { | ||
101 | struct i2c_board_info *info = data; | ||
102 | |||
103 | if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) { | ||
104 | struct acpi_resource_i2c_serialbus *sb; | ||
105 | |||
106 | sb = &ares->data.i2c_serial_bus; | ||
107 | if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) { | ||
108 | info->addr = sb->slave_address; | ||
109 | if (sb->access_mode == ACPI_I2C_10BIT_MODE) | ||
110 | info->flags |= I2C_CLIENT_TEN; | ||
111 | } | ||
112 | } else if (info->irq < 0) { | ||
113 | struct resource r; | ||
114 | |||
115 | if (acpi_dev_resource_interrupt(ares, 0, &r)) | ||
116 | info->irq = r.start; | ||
117 | } | ||
118 | |||
119 | /* Tell the ACPI core to skip this resource */ | ||
120 | return 1; | ||
121 | } | ||
122 | |||
123 | static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level, | ||
124 | void *data, void **return_value) | ||
125 | { | ||
126 | struct i2c_adapter *adapter = data; | ||
127 | struct list_head resource_list; | ||
128 | struct i2c_board_info info; | ||
129 | struct acpi_device *adev; | ||
130 | int ret; | ||
131 | |||
132 | if (acpi_bus_get_device(handle, &adev)) | ||
133 | return AE_OK; | ||
134 | if (acpi_bus_get_status(adev) || !adev->status.present) | ||
135 | return AE_OK; | ||
136 | |||
137 | memset(&info, 0, sizeof(info)); | ||
138 | info.acpi_node.companion = adev; | ||
139 | info.irq = -1; | ||
140 | |||
141 | INIT_LIST_HEAD(&resource_list); | ||
142 | ret = acpi_dev_get_resources(adev, &resource_list, | ||
143 | acpi_i2c_add_resource, &info); | ||
144 | acpi_dev_free_resource_list(&resource_list); | ||
145 | |||
146 | if (ret < 0 || !info.addr) | ||
147 | return AE_OK; | ||
148 | |||
149 | adev->power.flags.ignore_parent = true; | ||
150 | strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type)); | ||
151 | if (!i2c_new_device(adapter, &info)) { | ||
152 | adev->power.flags.ignore_parent = false; | ||
153 | dev_err(&adapter->dev, | ||
154 | "failed to add I2C device %s from ACPI\n", | ||
155 | dev_name(&adev->dev)); | ||
156 | } | ||
157 | |||
158 | return AE_OK; | ||
159 | } | ||
160 | |||
161 | /** | ||
162 | * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter | ||
163 | * @adap: pointer to adapter | ||
164 | * | ||
165 | * Enumerate all I2C slave devices behind this adapter by walking the ACPI | ||
166 | * namespace. When a device is found it will be added to the Linux device | ||
167 | * model and bound to the corresponding ACPI handle. | ||
168 | */ | ||
169 | static void acpi_i2c_register_devices(struct i2c_adapter *adap) | ||
170 | { | ||
171 | acpi_handle handle; | ||
172 | acpi_status status; | ||
173 | |||
174 | if (!adap->dev.parent) | ||
175 | return; | ||
176 | |||
177 | handle = ACPI_HANDLE(adap->dev.parent); | ||
178 | if (!handle) | ||
179 | return; | ||
180 | |||
181 | status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, | ||
182 | acpi_i2c_add_device, NULL, | ||
183 | adap, NULL); | ||
184 | if (ACPI_FAILURE(status)) | ||
185 | dev_warn(&adap->dev, "failed to enumerate I2C slaves\n"); | ||
186 | } | ||
187 | |||
188 | #else /* CONFIG_ACPI */ | ||
189 | static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) { } | ||
190 | #endif /* CONFIG_ACPI */ | ||
191 | |||
192 | #ifdef CONFIG_ACPI_I2C_OPREGION | ||
193 | static int acpi_gsb_i2c_read_bytes(struct i2c_client *client, | ||
194 | u8 cmd, u8 *data, u8 data_len) | ||
195 | { | ||
196 | |||
197 | struct i2c_msg msgs[2]; | ||
198 | int ret; | ||
199 | u8 *buffer; | ||
200 | |||
201 | buffer = kzalloc(data_len, GFP_KERNEL); | ||
202 | if (!buffer) | ||
203 | return AE_NO_MEMORY; | ||
204 | |||
205 | msgs[0].addr = client->addr; | ||
206 | msgs[0].flags = client->flags; | ||
207 | msgs[0].len = 1; | ||
208 | msgs[0].buf = &cmd; | ||
209 | |||
210 | msgs[1].addr = client->addr; | ||
211 | msgs[1].flags = client->flags | I2C_M_RD; | ||
212 | msgs[1].len = data_len; | ||
213 | msgs[1].buf = buffer; | ||
214 | |||
215 | ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); | ||
216 | if (ret < 0) | ||
217 | dev_err(&client->adapter->dev, "i2c read failed\n"); | ||
218 | else | ||
219 | memcpy(data, buffer, data_len); | ||
220 | |||
221 | kfree(buffer); | ||
222 | return ret; | ||
223 | } | ||
224 | |||
225 | static int acpi_gsb_i2c_write_bytes(struct i2c_client *client, | ||
226 | u8 cmd, u8 *data, u8 data_len) | ||
227 | { | ||
228 | |||
229 | struct i2c_msg msgs[1]; | ||
230 | u8 *buffer; | ||
231 | int ret = AE_OK; | ||
232 | |||
233 | buffer = kzalloc(data_len + 1, GFP_KERNEL); | ||
234 | if (!buffer) | ||
235 | return AE_NO_MEMORY; | ||
236 | |||
237 | buffer[0] = cmd; | ||
238 | memcpy(buffer + 1, data, data_len); | ||
239 | |||
240 | msgs[0].addr = client->addr; | ||
241 | msgs[0].flags = client->flags; | ||
242 | msgs[0].len = data_len + 1; | ||
243 | msgs[0].buf = buffer; | ||
244 | |||
245 | ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); | ||
246 | if (ret < 0) | ||
247 | dev_err(&client->adapter->dev, "i2c write failed\n"); | ||
248 | |||
249 | kfree(buffer); | ||
250 | return ret; | ||
251 | } | ||
252 | |||
253 | static acpi_status | ||
254 | acpi_i2c_space_handler(u32 function, acpi_physical_address command, | ||
255 | u32 bits, u64 *value64, | ||
256 | void *handler_context, void *region_context) | ||
257 | { | ||
258 | struct gsb_buffer *gsb = (struct gsb_buffer *)value64; | ||
259 | struct acpi_i2c_handler_data *data = handler_context; | ||
260 | struct acpi_connection_info *info = &data->info; | ||
261 | struct acpi_resource_i2c_serialbus *sb; | ||
262 | struct i2c_adapter *adapter = data->adapter; | ||
263 | struct i2c_client client; | ||
264 | struct acpi_resource *ares; | ||
265 | u32 accessor_type = function >> 16; | ||
266 | u8 action = function & ACPI_IO_MASK; | ||
267 | acpi_status ret = AE_OK; | ||
268 | int status; | ||
269 | |||
270 | ret = acpi_buffer_to_resource(info->connection, info->length, &ares); | ||
271 | if (ACPI_FAILURE(ret)) | ||
272 | return ret; | ||
273 | |||
274 | if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) { | ||
275 | ret = AE_BAD_PARAMETER; | ||
276 | goto err; | ||
277 | } | ||
278 | |||
279 | sb = &ares->data.i2c_serial_bus; | ||
280 | if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) { | ||
281 | ret = AE_BAD_PARAMETER; | ||
282 | goto err; | ||
283 | } | ||
284 | |||
285 | memset(&client, 0, sizeof(client)); | ||
286 | client.adapter = adapter; | ||
287 | client.addr = sb->slave_address; | ||
288 | client.flags = 0; | ||
289 | |||
290 | if (sb->access_mode == ACPI_I2C_10BIT_MODE) | ||
291 | client.flags |= I2C_CLIENT_TEN; | ||
292 | |||
293 | switch (accessor_type) { | ||
294 | case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV: | ||
295 | if (action == ACPI_READ) { | ||
296 | status = i2c_smbus_read_byte(&client); | ||
297 | if (status >= 0) { | ||
298 | gsb->bdata = status; | ||
299 | status = 0; | ||
300 | } | ||
301 | } else { | ||
302 | status = i2c_smbus_write_byte(&client, gsb->bdata); | ||
303 | } | ||
304 | break; | ||
305 | |||
306 | case ACPI_GSB_ACCESS_ATTRIB_BYTE: | ||
307 | if (action == ACPI_READ) { | ||
308 | status = i2c_smbus_read_byte_data(&client, command); | ||
309 | if (status >= 0) { | ||
310 | gsb->bdata = status; | ||
311 | status = 0; | ||
312 | } | ||
313 | } else { | ||
314 | status = i2c_smbus_write_byte_data(&client, command, | ||
315 | gsb->bdata); | ||
316 | } | ||
317 | break; | ||
318 | |||
319 | case ACPI_GSB_ACCESS_ATTRIB_WORD: | ||
320 | if (action == ACPI_READ) { | ||
321 | status = i2c_smbus_read_word_data(&client, command); | ||
322 | if (status >= 0) { | ||
323 | gsb->wdata = status; | ||
324 | status = 0; | ||
325 | } | ||
326 | } else { | ||
327 | status = i2c_smbus_write_word_data(&client, command, | ||
328 | gsb->wdata); | ||
329 | } | ||
330 | break; | ||
331 | |||
332 | case ACPI_GSB_ACCESS_ATTRIB_BLOCK: | ||
333 | if (action == ACPI_READ) { | ||
334 | status = i2c_smbus_read_block_data(&client, command, | ||
335 | gsb->data); | ||
336 | if (status >= 0) { | ||
337 | gsb->len = status; | ||
338 | status = 0; | ||
339 | } | ||
340 | } else { | ||
341 | status = i2c_smbus_write_block_data(&client, command, | ||
342 | gsb->len, gsb->data); | ||
343 | } | ||
344 | break; | ||
345 | |||
346 | case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE: | ||
347 | if (action == ACPI_READ) { | ||
348 | status = acpi_gsb_i2c_read_bytes(&client, command, | ||
349 | gsb->data, info->access_length); | ||
350 | if (status > 0) | ||
351 | status = 0; | ||
352 | } else { | ||
353 | status = acpi_gsb_i2c_write_bytes(&client, command, | ||
354 | gsb->data, info->access_length); | ||
355 | } | ||
356 | break; | ||
357 | |||
358 | default: | ||
359 | pr_info("protocol(0x%02x) is not supported.\n", accessor_type); | ||
360 | ret = AE_BAD_PARAMETER; | ||
361 | goto err; | ||
362 | } | ||
363 | |||
364 | gsb->status = status; | ||
365 | |||
366 | err: | ||
367 | ACPI_FREE(ares); | ||
368 | return ret; | ||
369 | } | ||
370 | |||
371 | |||
372 | static int acpi_i2c_install_space_handler(struct i2c_adapter *adapter) | ||
373 | { | ||
374 | acpi_handle handle; | ||
375 | struct acpi_i2c_handler_data *data; | ||
376 | acpi_status status; | ||
377 | |||
378 | if (!adapter->dev.parent) | ||
379 | return -ENODEV; | ||
380 | |||
381 | handle = ACPI_HANDLE(adapter->dev.parent); | ||
382 | |||
383 | if (!handle) | ||
384 | return -ENODEV; | ||
385 | |||
386 | data = kzalloc(sizeof(struct acpi_i2c_handler_data), | ||
387 | GFP_KERNEL); | ||
388 | if (!data) | ||
389 | return -ENOMEM; | ||
390 | |||
391 | data->adapter = adapter; | ||
392 | status = acpi_bus_attach_private_data(handle, (void *)data); | ||
393 | if (ACPI_FAILURE(status)) { | ||
394 | kfree(data); | ||
395 | return -ENOMEM; | ||
396 | } | ||
397 | |||
398 | status = acpi_install_address_space_handler(handle, | ||
399 | ACPI_ADR_SPACE_GSBUS, | ||
400 | &acpi_i2c_space_handler, | ||
401 | NULL, | ||
402 | data); | ||
403 | if (ACPI_FAILURE(status)) { | ||
404 | dev_err(&adapter->dev, "Error installing i2c space handler\n"); | ||
405 | acpi_bus_detach_private_data(handle); | ||
406 | kfree(data); | ||
407 | return -ENOMEM; | ||
408 | } | ||
409 | |||
410 | return 0; | ||
411 | } | ||
412 | |||
413 | static void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter) | ||
414 | { | ||
415 | acpi_handle handle; | ||
416 | struct acpi_i2c_handler_data *data; | ||
417 | acpi_status status; | ||
418 | |||
419 | if (!adapter->dev.parent) | ||
420 | return; | ||
421 | |||
422 | handle = ACPI_HANDLE(adapter->dev.parent); | ||
423 | |||
424 | if (!handle) | ||
425 | return; | ||
426 | |||
427 | acpi_remove_address_space_handler(handle, | ||
428 | ACPI_ADR_SPACE_GSBUS, | ||
429 | &acpi_i2c_space_handler); | ||
430 | |||
431 | status = acpi_bus_get_private_data(handle, (void **)&data); | ||
432 | if (ACPI_SUCCESS(status)) | ||
433 | kfree(data); | ||
434 | |||
435 | acpi_bus_detach_private_data(handle); | ||
436 | } | ||
437 | #else /* CONFIG_ACPI_I2C_OPREGION */ | ||
438 | static inline void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter) | ||
439 | { } | ||
440 | |||
441 | static inline int acpi_i2c_install_space_handler(struct i2c_adapter *adapter) | ||
442 | { return 0; } | ||
443 | #endif /* CONFIG_ACPI_I2C_OPREGION */ | ||
444 | |||
81 | /* ------------------------------------------------------------------------- */ | 445 | /* ------------------------------------------------------------------------- */ |
82 | 446 | ||
83 | static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id, | 447 | static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id, |