Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
zl6100.c
Go to the documentation of this file.
1 /*
2  * Hardware monitoring driver for ZL6100 and compatibles
3  *
4  * Copyright (c) 2011 Ericsson AB.
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; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20 
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/err.h>
25 #include <linux/slab.h>
26 #include <linux/i2c.h>
27 #include <linux/ktime.h>
28 #include <linux/delay.h>
29 #include "pmbus.h"
30 
33 
34 struct zl6100_data {
35  int id;
36  ktime_t access; /* chip access time */
37  int delay; /* Delay between chip accesses in uS */
39 };
40 
41 #define to_zl6100_data(x) container_of(x, struct zl6100_data, info)
42 
43 #define ZL6100_MFR_CONFIG 0xd0
44 #define ZL6100_DEVICE_ID 0xe4
45 
46 #define ZL6100_MFR_XTEMP_ENABLE (1 << 7)
47 
48 #define ZL6100_WAIT_TIME 1000 /* uS */
49 
51 module_param(delay, ushort, 0644);
52 MODULE_PARM_DESC(delay, "Delay between chip accesses in uS");
53 
54 /* Some chips need a delay between accesses */
55 static inline void zl6100_wait(const struct zl6100_data *data)
56 {
57  if (data->delay) {
58  s64 delta = ktime_us_delta(ktime_get(), data->access);
59  if (delta < data->delay)
60  udelay(data->delay - delta);
61  }
62 }
63 
64 static int zl6100_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  struct zl6100_data *data = to_zl6100_data(info);
68  int ret;
69 
70  if (page || reg >= PMBUS_VIRT_BASE)
71  return -ENXIO;
72 
73  if (data->id == zl2005) {
74  /*
75  * Limit register detection is not reliable on ZL2005.
76  * Make sure registers are not erroneously detected.
77  */
78  switch (reg) {
82  return -ENXIO;
83  }
84  }
85 
86  zl6100_wait(data);
87  ret = pmbus_read_word_data(client, page, reg);
88  data->access = ktime_get();
89 
90  return ret;
91 }
92 
93 static int zl6100_read_byte_data(struct i2c_client *client, int page, int reg)
94 {
95  const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
96  struct zl6100_data *data = to_zl6100_data(info);
97  int ret;
98 
99  if (page > 0)
100  return -ENXIO;
101 
102  zl6100_wait(data);
103  ret = pmbus_read_byte_data(client, page, reg);
104  data->access = ktime_get();
105 
106  return ret;
107 }
108 
109 static int zl6100_write_word_data(struct i2c_client *client, int page, int reg,
110  u16 word)
111 {
112  const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
113  struct zl6100_data *data = to_zl6100_data(info);
114  int ret;
115 
116  if (page || reg >= PMBUS_VIRT_BASE)
117  return -ENXIO;
118 
119  zl6100_wait(data);
120  ret = pmbus_write_word_data(client, page, reg, word);
121  data->access = ktime_get();
122 
123  return ret;
124 }
125 
126 static int zl6100_write_byte(struct i2c_client *client, int page, u8 value)
127 {
128  const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
129  struct zl6100_data *data = to_zl6100_data(info);
130  int ret;
131 
132  if (page > 0)
133  return -ENXIO;
134 
135  zl6100_wait(data);
136  ret = pmbus_write_byte(client, page, value);
137  data->access = ktime_get();
138 
139  return ret;
140 }
141 
142 static const struct i2c_device_id zl6100_id[] = {
143  {"bmr450", zl2005},
144  {"bmr451", zl2005},
145  {"bmr462", zl2008},
146  {"bmr463", zl2008},
147  {"bmr464", zl2008},
148  {"zl2004", zl2004},
149  {"zl2005", zl2005},
150  {"zl2006", zl2006},
151  {"zl2008", zl2008},
152  {"zl2105", zl2105},
153  {"zl2106", zl2106},
154  {"zl6100", zl6100},
155  {"zl6105", zl6105},
156  {"zl9101", zl9101},
157  {"zl9117", zl9117},
158  { }
159 };
160 MODULE_DEVICE_TABLE(i2c, zl6100_id);
161 
162 static int zl6100_probe(struct i2c_client *client,
163  const struct i2c_device_id *id)
164 {
165  int ret;
166  struct zl6100_data *data;
167  struct pmbus_driver_info *info;
169  const struct i2c_device_id *mid;
170 
171  if (!i2c_check_functionality(client->adapter,
174  return -ENODEV;
175 
177  device_id);
178  if (ret < 0) {
179  dev_err(&client->dev, "Failed to read device ID\n");
180  return ret;
181  }
182  device_id[ret] = '\0';
183  dev_info(&client->dev, "Device ID %s\n", device_id);
184 
185  mid = NULL;
186  for (mid = zl6100_id; mid->name[0]; mid++) {
187  if (!strncasecmp(mid->name, device_id, strlen(mid->name)))
188  break;
189  }
190  if (!mid->name[0]) {
191  dev_err(&client->dev, "Unsupported device\n");
192  return -ENODEV;
193  }
194  if (id->driver_data != mid->driver_data)
195  dev_notice(&client->dev,
196  "Device mismatch: Configured %s, detected %s\n",
197  id->name, mid->name);
198 
199  data = devm_kzalloc(&client->dev, sizeof(struct zl6100_data),
200  GFP_KERNEL);
201  if (!data)
202  return -ENOMEM;
203 
204  data->id = mid->driver_data;
205 
206  /*
207  * According to information from the chip vendor, all currently
208  * supported chips are known to require a wait time between I2C
209  * accesses.
210  */
211  data->delay = delay;
212 
213  /*
214  * Since there was a direct I2C device access above, wait before
215  * accessing the chip again.
216  */
217  data->access = ktime_get();
218  zl6100_wait(data);
219 
220  info = &data->info;
221 
222  info->pages = 1;
227 
229  if (ret < 0)
230  return ret;
231 
232  if (ret & ZL6100_MFR_XTEMP_ENABLE)
233  info->func[0] |= PMBUS_HAVE_TEMP2;
234 
235  data->access = ktime_get();
236  zl6100_wait(data);
237 
238  info->read_word_data = zl6100_read_word_data;
239  info->read_byte_data = zl6100_read_byte_data;
240  info->write_word_data = zl6100_write_word_data;
241  info->write_byte = zl6100_write_byte;
242 
243  return pmbus_do_probe(client, mid, info);
244 }
245 
246 static struct i2c_driver zl6100_driver = {
247  .driver = {
248  .name = "zl6100",
249  },
250  .probe = zl6100_probe,
251  .remove = pmbus_do_remove,
252  .id_table = zl6100_id,
253 };
254 
255 module_i2c_driver(zl6100_driver);
256 
257 MODULE_AUTHOR("Guenter Roeck");
258 MODULE_DESCRIPTION("PMBus driver for ZL6100 and compatibles");
259 MODULE_LICENSE("GPL");