Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
adm1275.c
Go to the documentation of this file.
1 /*
2  * Hardware monitoring driver for Analog Devices ADM1275 Hot-Swap Controller
3  * and Digital Power Monitor
4  *
5  * Copyright (c) 2011 Ericsson AB.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  */
17 
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/err.h>
22 #include <linux/slab.h>
23 #include <linux/i2c.h>
24 #include "pmbus.h"
25 
26 enum chips { adm1075, adm1275, adm1276 };
27 
28 #define ADM1275_PEAK_IOUT 0xd0
29 #define ADM1275_PEAK_VIN 0xd1
30 #define ADM1275_PEAK_VOUT 0xd2
31 #define ADM1275_PMON_CONFIG 0xd4
32 
33 #define ADM1275_VIN_VOUT_SELECT (1 << 6)
34 #define ADM1275_VRANGE (1 << 5)
35 #define ADM1075_IRANGE_50 (1 << 4)
36 #define ADM1075_IRANGE_25 (1 << 3)
37 #define ADM1075_IRANGE_MASK ((1 << 3) | (1 << 4))
38 
39 #define ADM1275_IOUT_WARN2_LIMIT 0xd7
40 #define ADM1275_DEVICE_CONFIG 0xd8
41 
42 #define ADM1275_IOUT_WARN2_SELECT (1 << 4)
43 
44 #define ADM1276_PEAK_PIN 0xda
45 
46 #define ADM1275_MFR_STATUS_IOUT_WARN2 (1 << 0)
47 
48 #define ADM1075_READ_VAUX 0xdd
49 #define ADM1075_VAUX_OV_WARN_LIMIT 0xde
50 #define ADM1075_VAUX_UV_WARN_LIMIT 0xdf
51 #define ADM1075_VAUX_STATUS 0xf6
52 
53 #define ADM1075_VAUX_OV_WARN (1<<7)
54 #define ADM1075_VAUX_UV_WARN (1<<6)
55 
56 struct adm1275_data {
57  int id;
58  bool have_oc_fault;
59  struct pmbus_driver_info info;
60 };
61 
62 #define to_adm1275_data(x) container_of(x, struct adm1275_data, info)
63 
64 static int adm1275_read_word_data(struct i2c_client *client, int page, int reg)
65 {
66  const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
67  const struct adm1275_data *data = to_adm1275_data(info);
68  int ret = 0;
69 
70  if (page)
71  return -ENXIO;
72 
73  switch (reg) {
74  case PMBUS_IOUT_UC_FAULT_LIMIT:
75  if (data->have_oc_fault) {
76  ret = -ENXIO;
77  break;
78  }
79  ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
80  break;
81  case PMBUS_IOUT_OC_FAULT_LIMIT:
82  if (!data->have_oc_fault) {
83  ret = -ENXIO;
84  break;
85  }
86  ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
87  break;
88  case PMBUS_VOUT_OV_WARN_LIMIT:
89  if (data->id != adm1075) {
90  ret = -ENODATA;
91  break;
92  }
93  ret = pmbus_read_word_data(client, 0,
94  ADM1075_VAUX_OV_WARN_LIMIT);
95  break;
96  case PMBUS_VOUT_UV_WARN_LIMIT:
97  if (data->id != adm1075) {
98  ret = -ENODATA;
99  break;
100  }
101  ret = pmbus_read_word_data(client, 0,
102  ADM1075_VAUX_UV_WARN_LIMIT);
103  break;
104  case PMBUS_READ_VOUT:
105  if (data->id != adm1075) {
106  ret = -ENODATA;
107  break;
108  }
109  ret = pmbus_read_word_data(client, 0, ADM1075_READ_VAUX);
110  break;
111  case PMBUS_VIRT_READ_IOUT_MAX:
112  ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_IOUT);
113  break;
114  case PMBUS_VIRT_READ_VOUT_MAX:
115  ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VOUT);
116  break;
117  case PMBUS_VIRT_READ_VIN_MAX:
118  ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VIN);
119  break;
120  case PMBUS_VIRT_READ_PIN_MAX:
121  if (data->id == adm1275) {
122  ret = -ENXIO;
123  break;
124  }
125  ret = pmbus_read_word_data(client, 0, ADM1276_PEAK_PIN);
126  break;
127  case PMBUS_VIRT_RESET_IOUT_HISTORY:
128  case PMBUS_VIRT_RESET_VOUT_HISTORY:
129  case PMBUS_VIRT_RESET_VIN_HISTORY:
130  break;
131  case PMBUS_VIRT_RESET_PIN_HISTORY:
132  if (data->id == adm1275)
133  ret = -ENXIO;
134  break;
135  default:
136  ret = -ENODATA;
137  break;
138  }
139  return ret;
140 }
141 
142 static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
143  u16 word)
144 {
145  int ret;
146 
147  if (page)
148  return -ENXIO;
149 
150  switch (reg) {
151  case PMBUS_IOUT_UC_FAULT_LIMIT:
152  case PMBUS_IOUT_OC_FAULT_LIMIT:
153  ret = pmbus_write_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT,
154  word);
155  break;
156  case PMBUS_VIRT_RESET_IOUT_HISTORY:
157  ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_IOUT, 0);
158  break;
159  case PMBUS_VIRT_RESET_VOUT_HISTORY:
160  ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VOUT, 0);
161  break;
162  case PMBUS_VIRT_RESET_VIN_HISTORY:
163  ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VIN, 0);
164  break;
165  case PMBUS_VIRT_RESET_PIN_HISTORY:
166  ret = pmbus_write_word_data(client, 0, ADM1276_PEAK_PIN, 0);
167  break;
168  default:
169  ret = -ENODATA;
170  break;
171  }
172  return ret;
173 }
174 
175 static int adm1275_read_byte_data(struct i2c_client *client, int page, int reg)
176 {
177  const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
178  const struct adm1275_data *data = to_adm1275_data(info);
179  int mfr_status, ret;
180 
181  if (page > 0)
182  return -ENXIO;
183 
184  switch (reg) {
185  case PMBUS_STATUS_IOUT:
186  ret = pmbus_read_byte_data(client, page, PMBUS_STATUS_IOUT);
187  if (ret < 0)
188  break;
189  mfr_status = pmbus_read_byte_data(client, page,
190  PMBUS_STATUS_MFR_SPECIFIC);
191  if (mfr_status < 0) {
192  ret = mfr_status;
193  break;
194  }
195  if (mfr_status & ADM1275_MFR_STATUS_IOUT_WARN2) {
196  ret |= data->have_oc_fault ?
197  PB_IOUT_OC_FAULT : PB_IOUT_UC_FAULT;
198  }
199  break;
200  case PMBUS_STATUS_VOUT:
201  if (data->id != adm1075) {
202  ret = -ENODATA;
203  break;
204  }
205  ret = 0;
206  mfr_status = pmbus_read_byte_data(client, 0,
207  ADM1075_VAUX_STATUS);
208  if (mfr_status & ADM1075_VAUX_OV_WARN)
209  ret |= PB_VOLTAGE_OV_WARNING;
210  if (mfr_status & ADM1075_VAUX_UV_WARN)
211  ret |= PB_VOLTAGE_UV_WARNING;
212  break;
213  default:
214  ret = -ENODATA;
215  break;
216  }
217  return ret;
218 }
219 
220 static const struct i2c_device_id adm1275_id[] = {
221  { "adm1075", adm1075 },
222  { "adm1275", adm1275 },
223  { "adm1276", adm1276 },
224  { }
225 };
226 MODULE_DEVICE_TABLE(i2c, adm1275_id);
227 
228 static int adm1275_probe(struct i2c_client *client,
229  const struct i2c_device_id *id)
230 {
231  u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1];
232  int config, device_config;
233  int ret;
234  struct pmbus_driver_info *info;
235  struct adm1275_data *data;
236  const struct i2c_device_id *mid;
237 
238  if (!i2c_check_functionality(client->adapter,
239  I2C_FUNC_SMBUS_READ_BYTE_DATA
240  | I2C_FUNC_SMBUS_BLOCK_DATA))
241  return -ENODEV;
242 
243  ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, block_buffer);
244  if (ret < 0) {
245  dev_err(&client->dev, "Failed to read Manufacturer ID\n");
246  return ret;
247  }
248  if (ret != 3 || strncmp(block_buffer, "ADI", 3)) {
249  dev_err(&client->dev, "Unsupported Manufacturer ID\n");
250  return -ENODEV;
251  }
252 
253  ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, block_buffer);
254  if (ret < 0) {
255  dev_err(&client->dev, "Failed to read Manufacturer Model\n");
256  return ret;
257  }
258  for (mid = adm1275_id; mid->name[0]; mid++) {
259  if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
260  break;
261  }
262  if (!mid->name[0]) {
263  dev_err(&client->dev, "Unsupported device\n");
264  return -ENODEV;
265  }
266 
267  if (id->driver_data != mid->driver_data)
268  dev_notice(&client->dev,
269  "Device mismatch: Configured %s, detected %s\n",
270  id->name, mid->name);
271 
272  config = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG);
273  if (config < 0)
274  return config;
275 
276  device_config = i2c_smbus_read_byte_data(client, ADM1275_DEVICE_CONFIG);
277  if (device_config < 0)
278  return device_config;
279 
280  data = devm_kzalloc(&client->dev, sizeof(struct adm1275_data),
281  GFP_KERNEL);
282  if (!data)
283  return -ENOMEM;
284 
285  data->id = mid->driver_data;
286 
287  info = &data->info;
288 
289  info->pages = 1;
290  info->format[PSC_VOLTAGE_IN] = direct;
291  info->format[PSC_VOLTAGE_OUT] = direct;
292  info->format[PSC_CURRENT_OUT] = direct;
293  info->m[PSC_CURRENT_OUT] = 807;
294  info->b[PSC_CURRENT_OUT] = 20475;
295  info->R[PSC_CURRENT_OUT] = -1;
296  info->func[0] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
297 
298  info->read_word_data = adm1275_read_word_data;
299  info->read_byte_data = adm1275_read_byte_data;
300  info->write_word_data = adm1275_write_word_data;
301 
302  if (data->id == adm1075) {
303  info->m[PSC_VOLTAGE_IN] = 27169;
304  info->b[PSC_VOLTAGE_IN] = 0;
305  info->R[PSC_VOLTAGE_IN] = -1;
306  info->m[PSC_VOLTAGE_OUT] = 27169;
307  info->b[PSC_VOLTAGE_OUT] = 0;
308  info->R[PSC_VOLTAGE_OUT] = -1;
309  } else if (config & ADM1275_VRANGE) {
310  info->m[PSC_VOLTAGE_IN] = 19199;
311  info->b[PSC_VOLTAGE_IN] = 0;
312  info->R[PSC_VOLTAGE_IN] = -2;
313  info->m[PSC_VOLTAGE_OUT] = 19199;
314  info->b[PSC_VOLTAGE_OUT] = 0;
315  info->R[PSC_VOLTAGE_OUT] = -2;
316  } else {
317  info->m[PSC_VOLTAGE_IN] = 6720;
318  info->b[PSC_VOLTAGE_IN] = 0;
319  info->R[PSC_VOLTAGE_IN] = -1;
320  info->m[PSC_VOLTAGE_OUT] = 6720;
321  info->b[PSC_VOLTAGE_OUT] = 0;
322  info->R[PSC_VOLTAGE_OUT] = -1;
323  }
324 
325  if (device_config & ADM1275_IOUT_WARN2_SELECT)
326  data->have_oc_fault = true;
327 
328  switch (data->id) {
329  case adm1075:
330  info->format[PSC_POWER] = direct;
331  info->b[PSC_POWER] = 0;
332  info->R[PSC_POWER] = -1;
333  switch (config & ADM1075_IRANGE_MASK) {
334  case ADM1075_IRANGE_25:
335  info->m[PSC_POWER] = 8549;
336  info->m[PSC_CURRENT_OUT] = 806;
337  break;
338  case ADM1075_IRANGE_50:
339  info->m[PSC_POWER] = 4279;
340  info->m[PSC_CURRENT_OUT] = 404;
341  break;
342  default:
343  dev_err(&client->dev, "Invalid input current range");
344  info->m[PSC_POWER] = 0;
345  info->m[PSC_CURRENT_OUT] = 0;
346  break;
347  }
348  info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
349  | PMBUS_HAVE_STATUS_INPUT;
350  if (config & ADM1275_VIN_VOUT_SELECT)
351  info->func[0] |=
352  PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
353  break;
354  case adm1275:
355  if (config & ADM1275_VIN_VOUT_SELECT)
356  info->func[0] |=
357  PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
358  else
359  info->func[0] |=
360  PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT;
361  break;
362  case adm1276:
363  info->format[PSC_POWER] = direct;
364  info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
365  | PMBUS_HAVE_STATUS_INPUT;
366  if (config & ADM1275_VIN_VOUT_SELECT)
367  info->func[0] |=
368  PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
369  if (config & ADM1275_VRANGE) {
370  info->m[PSC_POWER] = 6043;
371  info->b[PSC_POWER] = 0;
372  info->R[PSC_POWER] = -2;
373  } else {
374  info->m[PSC_POWER] = 2115;
375  info->b[PSC_POWER] = 0;
376  info->R[PSC_POWER] = -1;
377  }
378  break;
379  }
380 
381  return pmbus_do_probe(client, id, info);
382 }
383 
384 static struct i2c_driver adm1275_driver = {
385  .driver = {
386  .name = "adm1275",
387  },
388  .probe = adm1275_probe,
389  .remove = pmbus_do_remove,
390  .id_table = adm1275_id,
391 };
392 
393 module_i2c_driver(adm1275_driver);
394 
395 MODULE_AUTHOR("Guenter Roeck");
396 MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1275 and compatibles");
397 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 13:35:09 for Linux Kernel by   doxygen 1.8.2