Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/i2c/busses/i2c-scmi.c

  1 /*
  2  * SMBus driver for ACPI SMBus CMI
  3  *
  4  * Copyright (C) 2009 Crane Cai <crane.cai@amd.com>
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License as published by
  8  * the Free Software Foundation version 2.
  9  */
 10 
 11 #include <linux/module.h>
 12 #include <linux/slab.h>
 13 #include <linux/kernel.h>
 14 #include <linux/stddef.h>
 15 #include <linux/i2c.h>
 16 #include <linux/acpi.h>
 17 
 18 #define ACPI_SMBUS_HC_CLASS             "smbus"
 19 #define ACPI_SMBUS_HC_DEVICE_NAME       "cmi"
 20 
 21 ACPI_MODULE_NAME("smbus_cmi");
 22 
 23 struct smbus_methods_t {
 24         char *mt_info;
 25         char *mt_sbr;
 26         char *mt_sbw;
 27 };
 28 
 29 struct acpi_smbus_cmi {
 30         acpi_handle handle;
 31         struct i2c_adapter adapter;
 32         u8 cap_info:1;
 33         u8 cap_read:1;
 34         u8 cap_write:1;
 35         struct smbus_methods_t *methods;
 36 };
 37 
 38 static const struct smbus_methods_t smbus_methods = {
 39         .mt_info = "_SBI",
 40         .mt_sbr  = "_SBR",
 41         .mt_sbw  = "_SBW",
 42 };
 43 
 44 /* Some IBM BIOSes omit the leading underscore */
 45 static const struct smbus_methods_t ibm_smbus_methods = {
 46         .mt_info = "SBI_",
 47         .mt_sbr  = "SBR_",
 48         .mt_sbw  = "SBW_",
 49 };
 50 
 51 static const struct acpi_device_id acpi_smbus_cmi_ids[] = {
 52         {"SMBUS01", (kernel_ulong_t)&smbus_methods},
 53         {ACPI_SMBUS_IBM_HID, (kernel_ulong_t)&ibm_smbus_methods},
 54         {"", 0}
 55 };
 56 MODULE_DEVICE_TABLE(acpi, acpi_smbus_cmi_ids);
 57 
 58 #define ACPI_SMBUS_STATUS_OK                    0x00
 59 #define ACPI_SMBUS_STATUS_FAIL                  0x07
 60 #define ACPI_SMBUS_STATUS_DNAK                  0x10
 61 #define ACPI_SMBUS_STATUS_DERR                  0x11
 62 #define ACPI_SMBUS_STATUS_CMD_DENY              0x12
 63 #define ACPI_SMBUS_STATUS_UNKNOWN               0x13
 64 #define ACPI_SMBUS_STATUS_ACC_DENY              0x17
 65 #define ACPI_SMBUS_STATUS_TIMEOUT               0x18
 66 #define ACPI_SMBUS_STATUS_NOTSUP                0x19
 67 #define ACPI_SMBUS_STATUS_BUSY                  0x1a
 68 #define ACPI_SMBUS_STATUS_PEC                   0x1f
 69 
 70 #define ACPI_SMBUS_PRTCL_WRITE                  0x00
 71 #define ACPI_SMBUS_PRTCL_READ                   0x01
 72 #define ACPI_SMBUS_PRTCL_QUICK                  0x02
 73 #define ACPI_SMBUS_PRTCL_BYTE                   0x04
 74 #define ACPI_SMBUS_PRTCL_BYTE_DATA              0x06
 75 #define ACPI_SMBUS_PRTCL_WORD_DATA              0x08
 76 #define ACPI_SMBUS_PRTCL_BLOCK_DATA             0x0a
 77 
 78 
 79 static int
 80 acpi_smbus_cmi_access(struct i2c_adapter *adap, u16 addr, unsigned short flags,
 81                    char read_write, u8 command, int size,
 82                    union i2c_smbus_data *data)
 83 {
 84         int result = 0;
 85         struct acpi_smbus_cmi *smbus_cmi = adap->algo_data;
 86         unsigned char protocol;
 87         acpi_status status = 0;
 88         struct acpi_object_list input;
 89         union acpi_object mt_params[5];
 90         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 91         union acpi_object *obj;
 92         union acpi_object *pkg;
 93         char *method;
 94         int len = 0;
 95 
 96         dev_dbg(&adap->dev, "access size: %d %s\n", size,
 97                 (read_write) ? "READ" : "WRITE");
 98         switch (size) {
 99         case I2C_SMBUS_QUICK:
100                 protocol = ACPI_SMBUS_PRTCL_QUICK;
101                 command = 0;
102                 if (read_write == I2C_SMBUS_WRITE) {
103                         mt_params[3].type = ACPI_TYPE_INTEGER;
104                         mt_params[3].integer.value = 0;
105                         mt_params[4].type = ACPI_TYPE_INTEGER;
106                         mt_params[4].integer.value = 0;
107                 }
108                 break;
109 
110         case I2C_SMBUS_BYTE:
111                 protocol = ACPI_SMBUS_PRTCL_BYTE;
112                 if (read_write == I2C_SMBUS_WRITE) {
113                         mt_params[3].type = ACPI_TYPE_INTEGER;
114                         mt_params[3].integer.value = 0;
115                         mt_params[4].type = ACPI_TYPE_INTEGER;
116                         mt_params[4].integer.value = 0;
117                 } else {
118                         command = 0;
119                 }
120                 break;
121 
122         case I2C_SMBUS_BYTE_DATA:
123                 protocol = ACPI_SMBUS_PRTCL_BYTE_DATA;
124                 if (read_write == I2C_SMBUS_WRITE) {
125                         mt_params[3].type = ACPI_TYPE_INTEGER;
126                         mt_params[3].integer.value = 1;
127                         mt_params[4].type = ACPI_TYPE_INTEGER;
128                         mt_params[4].integer.value = data->byte;
129                 }
130                 break;
131 
132         case I2C_SMBUS_WORD_DATA:
133                 protocol = ACPI_SMBUS_PRTCL_WORD_DATA;
134                 if (read_write == I2C_SMBUS_WRITE) {
135                         mt_params[3].type = ACPI_TYPE_INTEGER;
136                         mt_params[3].integer.value = 2;
137                         mt_params[4].type = ACPI_TYPE_INTEGER;
138                         mt_params[4].integer.value = data->word;
139                 }
140                 break;
141 
142         case I2C_SMBUS_BLOCK_DATA:
143                 protocol = ACPI_SMBUS_PRTCL_BLOCK_DATA;
144                 if (read_write == I2C_SMBUS_WRITE) {
145                         len = data->block[0];
146                         if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
147                                 return -EINVAL;
148                         mt_params[3].type = ACPI_TYPE_INTEGER;
149                         mt_params[3].integer.value = len;
150                         mt_params[4].type = ACPI_TYPE_BUFFER;
151                         mt_params[4].buffer.pointer = data->block + 1;
152                 }
153                 break;
154 
155         default:
156                 dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
157                 return -EOPNOTSUPP;
158         }
159 
160         if (read_write == I2C_SMBUS_READ) {
161                 protocol |= ACPI_SMBUS_PRTCL_READ;
162                 method = smbus_cmi->methods->mt_sbr;
163                 input.count = 3;
164         } else {
165                 protocol |= ACPI_SMBUS_PRTCL_WRITE;
166                 method = smbus_cmi->methods->mt_sbw;
167                 input.count = 5;
168         }
169 
170         input.pointer = mt_params;
171         mt_params[0].type = ACPI_TYPE_INTEGER;
172         mt_params[0].integer.value = protocol;
173         mt_params[1].type = ACPI_TYPE_INTEGER;
174         mt_params[1].integer.value = addr;
175         mt_params[2].type = ACPI_TYPE_INTEGER;
176         mt_params[2].integer.value = command;
177 
178         status = acpi_evaluate_object(smbus_cmi->handle, method, &input,
179                                       &buffer);
180         if (ACPI_FAILURE(status)) {
181                 ACPI_ERROR((AE_INFO, "Evaluating %s: %i", method, status));
182                 return -EIO;
183         }
184 
185         pkg = buffer.pointer;
186         if (pkg && pkg->type == ACPI_TYPE_PACKAGE)
187                 obj = pkg->package.elements;
188         else {
189                 ACPI_ERROR((AE_INFO, "Invalid argument type"));
190                 result = -EIO;
191                 goto out;
192         }
193         if (obj == NULL || obj->type != ACPI_TYPE_INTEGER) {
194                 ACPI_ERROR((AE_INFO, "Invalid argument type"));
195                 result = -EIO;
196                 goto out;
197         }
198 
199         result = obj->integer.value;
200         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s return status: %i\n",
201                           method, result));
202 
203         switch (result) {
204         case ACPI_SMBUS_STATUS_OK:
205                 result = 0;
206                 break;
207         case ACPI_SMBUS_STATUS_BUSY:
208                 result = -EBUSY;
209                 goto out;
210         case ACPI_SMBUS_STATUS_TIMEOUT:
211                 result = -ETIMEDOUT;
212                 goto out;
213         case ACPI_SMBUS_STATUS_DNAK:
214                 result = -ENXIO;
215                 goto out;
216         default:
217                 result = -EIO;
218                 goto out;
219         }
220 
221         if (read_write == I2C_SMBUS_WRITE || size == I2C_SMBUS_QUICK)
222                 goto out;
223 
224         obj = pkg->package.elements + 1;
225         if (obj->type != ACPI_TYPE_INTEGER) {
226                 ACPI_ERROR((AE_INFO, "Invalid argument type"));
227                 result = -EIO;
228                 goto out;
229         }
230 
231         len = obj->integer.value;
232         obj = pkg->package.elements + 2;
233         switch (size) {
234         case I2C_SMBUS_BYTE:
235         case I2C_SMBUS_BYTE_DATA:
236         case I2C_SMBUS_WORD_DATA:
237                 if (obj->type != ACPI_TYPE_INTEGER) {
238                         ACPI_ERROR((AE_INFO, "Invalid argument type"));
239                         result = -EIO;
240                         goto out;
241                 }
242                 if (len == 2)
243                         data->word = obj->integer.value;
244                 else
245                         data->byte = obj->integer.value;
246                 break;
247         case I2C_SMBUS_BLOCK_DATA:
248                 if (obj->type != ACPI_TYPE_BUFFER) {
249                         ACPI_ERROR((AE_INFO, "Invalid argument type"));
250                         result = -EIO;
251                         goto out;
252                 }
253                 if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
254                         return -EPROTO;
255                 data->block[0] = len;
256                 memcpy(data->block + 1, obj->buffer.pointer, len);
257                 break;
258         }
259 
260 out:
261         kfree(buffer.pointer);
262         dev_dbg(&adap->dev, "Transaction status: %i\n", result);
263         return result;
264 }
265 
266 static u32 acpi_smbus_cmi_func(struct i2c_adapter *adapter)
267 {
268         struct acpi_smbus_cmi *smbus_cmi = adapter->algo_data;
269         u32 ret;
270 
271         ret = smbus_cmi->cap_read | smbus_cmi->cap_write ?
272                 I2C_FUNC_SMBUS_QUICK : 0;
273 
274         ret |= smbus_cmi->cap_read ?
275                 (I2C_FUNC_SMBUS_READ_BYTE |
276                 I2C_FUNC_SMBUS_READ_BYTE_DATA |
277                 I2C_FUNC_SMBUS_READ_WORD_DATA |
278                 I2C_FUNC_SMBUS_READ_BLOCK_DATA) : 0;
279 
280         ret |= smbus_cmi->cap_write ?
281                 (I2C_FUNC_SMBUS_WRITE_BYTE |
282                 I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
283                 I2C_FUNC_SMBUS_WRITE_WORD_DATA |
284                 I2C_FUNC_SMBUS_WRITE_BLOCK_DATA) : 0;
285 
286         return ret;
287 }
288 
289 static const struct i2c_algorithm acpi_smbus_cmi_algorithm = {
290         .smbus_xfer = acpi_smbus_cmi_access,
291         .functionality = acpi_smbus_cmi_func,
292 };
293 
294 
295 static int acpi_smbus_cmi_add_cap(struct acpi_smbus_cmi *smbus_cmi,
296                                   const char *name)
297 {
298         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
299         union acpi_object *obj;
300         acpi_status status;
301 
302         if (!strcmp(name, smbus_cmi->methods->mt_info)) {
303                 status = acpi_evaluate_object(smbus_cmi->handle,
304                                         smbus_cmi->methods->mt_info,
305                                         NULL, &buffer);
306                 if (ACPI_FAILURE(status)) {
307                         ACPI_ERROR((AE_INFO, "Evaluating %s: %i",
308                                    smbus_cmi->methods->mt_info, status));
309                         return -EIO;
310                 }
311 
312                 obj = buffer.pointer;
313                 if (obj && obj->type == ACPI_TYPE_PACKAGE)
314                         obj = obj->package.elements;
315                 else {
316                         ACPI_ERROR((AE_INFO, "Invalid argument type"));
317                         kfree(buffer.pointer);
318                         return -EIO;
319                 }
320 
321                 if (obj->type != ACPI_TYPE_INTEGER) {
322                         ACPI_ERROR((AE_INFO, "Invalid argument type"));
323                         kfree(buffer.pointer);
324                         return -EIO;
325                 } else
326                         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "SMBus CMI Version %x"
327                                           "\n", (int)obj->integer.value));
328 
329                 kfree(buffer.pointer);
330                 smbus_cmi->cap_info = 1;
331         } else if (!strcmp(name, smbus_cmi->methods->mt_sbr))
332                 smbus_cmi->cap_read = 1;
333         else if (!strcmp(name, smbus_cmi->methods->mt_sbw))
334                 smbus_cmi->cap_write = 1;
335         else
336                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Unsupported CMI method: %s\n",
337                                  name));
338 
339         return 0;
340 }
341 
342 static acpi_status acpi_smbus_cmi_query_methods(acpi_handle handle, u32 level,
343                         void *context, void **return_value)
344 {
345         char node_name[5];
346         struct acpi_buffer buffer = { sizeof(node_name), node_name };
347         struct acpi_smbus_cmi *smbus_cmi = context;
348         acpi_status status;
349 
350         status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
351 
352         if (ACPI_SUCCESS(status))
353                 acpi_smbus_cmi_add_cap(smbus_cmi, node_name);
354 
355         return AE_OK;
356 }
357 
358 static int acpi_smbus_cmi_add(struct acpi_device *device)
359 {
360         struct acpi_smbus_cmi *smbus_cmi;
361         const struct acpi_device_id *id;
362 
363         smbus_cmi = kzalloc(sizeof(struct acpi_smbus_cmi), GFP_KERNEL);
364         if (!smbus_cmi)
365                 return -ENOMEM;
366 
367         smbus_cmi->handle = device->handle;
368         strcpy(acpi_device_name(device), ACPI_SMBUS_HC_DEVICE_NAME);
369         strcpy(acpi_device_class(device), ACPI_SMBUS_HC_CLASS);
370         device->driver_data = smbus_cmi;
371         smbus_cmi->cap_info = 0;
372         smbus_cmi->cap_read = 0;
373         smbus_cmi->cap_write = 0;
374 
375         for (id = acpi_smbus_cmi_ids; id->id[0]; id++)
376                 if (!strcmp(id->id, acpi_device_hid(device)))
377                         smbus_cmi->methods =
378                                 (struct smbus_methods_t *) id->driver_data;
379 
380         acpi_walk_namespace(ACPI_TYPE_METHOD, smbus_cmi->handle, 1,
381                             acpi_smbus_cmi_query_methods, NULL, smbus_cmi, NULL);
382 
383         if (smbus_cmi->cap_info == 0)
384                 goto err;
385 
386         snprintf(smbus_cmi->adapter.name, sizeof(smbus_cmi->adapter.name),
387                 "SMBus CMI adapter %s",
388                 acpi_device_name(device));
389         smbus_cmi->adapter.owner = THIS_MODULE;
390         smbus_cmi->adapter.algo = &acpi_smbus_cmi_algorithm;
391         smbus_cmi->adapter.algo_data = smbus_cmi;
392         smbus_cmi->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
393         smbus_cmi->adapter.dev.parent = &device->dev;
394 
395         if (i2c_add_adapter(&smbus_cmi->adapter)) {
396                 dev_err(&device->dev, "Couldn't register adapter!\n");
397                 goto err;
398         }
399 
400         return 0;
401 
402 err:
403         kfree(smbus_cmi);
404         device->driver_data = NULL;
405         return -EIO;
406 }
407 
408 static int acpi_smbus_cmi_remove(struct acpi_device *device)
409 {
410         struct acpi_smbus_cmi *smbus_cmi = acpi_driver_data(device);
411 
412         i2c_del_adapter(&smbus_cmi->adapter);
413         kfree(smbus_cmi);
414         device->driver_data = NULL;
415 
416         return 0;
417 }
418 
419 static struct acpi_driver acpi_smbus_cmi_driver = {
420         .name = ACPI_SMBUS_HC_DEVICE_NAME,
421         .class = ACPI_SMBUS_HC_CLASS,
422         .ids = acpi_smbus_cmi_ids,
423         .ops = {
424                 .add = acpi_smbus_cmi_add,
425                 .remove = acpi_smbus_cmi_remove,
426         },
427 };
428 module_acpi_driver(acpi_smbus_cmi_driver);
429 
430 MODULE_LICENSE("GPL");
431 MODULE_AUTHOR("Crane Cai <crane.cai@amd.com>");
432 MODULE_DESCRIPTION("ACPI SMBus CMI driver");
433 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us