Commit | Line | Data |
---|---|---|
e0b9b7b0 KS |
1 | /* |
2 | * I2C bus driver for Kontron COM modules | |
3 | * | |
4 | * Copyright (c) 2010-2013 Kontron Europe GmbH | |
5 | * Author: Michael Brunner <michael.brunner@kontron.com> | |
6 | * | |
7 | * The driver is based on the i2c-ocores driver by Peter Korsgaard. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License 2 as published | |
11 | * by the Free Software Foundation. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | */ | |
18 | ||
19 | #include <linux/module.h> | |
20 | #include <linux/platform_device.h> | |
21 | #include <linux/i2c.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/mfd/kempld.h> | |
24 | ||
25 | #define KEMPLD_I2C_PRELOW 0x0b | |
26 | #define KEMPLD_I2C_PREHIGH 0x0c | |
27 | #define KEMPLD_I2C_DATA 0x0e | |
28 | ||
29 | #define KEMPLD_I2C_CTRL 0x0d | |
30 | #define I2C_CTRL_IEN 0x40 | |
31 | #define I2C_CTRL_EN 0x80 | |
32 | ||
33 | #define KEMPLD_I2C_STAT 0x0f | |
34 | #define I2C_STAT_IF 0x01 | |
35 | #define I2C_STAT_TIP 0x02 | |
36 | #define I2C_STAT_ARBLOST 0x20 | |
37 | #define I2C_STAT_BUSY 0x40 | |
38 | #define I2C_STAT_NACK 0x80 | |
39 | ||
40 | #define KEMPLD_I2C_CMD 0x0f | |
41 | #define I2C_CMD_START 0x91 | |
42 | #define I2C_CMD_STOP 0x41 | |
43 | #define I2C_CMD_READ 0x21 | |
44 | #define I2C_CMD_WRITE 0x11 | |
45 | #define I2C_CMD_READ_ACK 0x21 | |
46 | #define I2C_CMD_READ_NACK 0x29 | |
47 | #define I2C_CMD_IACK 0x01 | |
48 | ||
49 | #define KEMPLD_I2C_FREQ_MAX 2700 /* 2.7 mHz */ | |
50 | #define KEMPLD_I2C_FREQ_STD 100 /* 100 kHz */ | |
51 | ||
52 | enum { | |
53 | STATE_DONE = 0, | |
54 | STATE_INIT, | |
55 | STATE_ADDR, | |
56 | STATE_ADDR10, | |
57 | STATE_START, | |
58 | STATE_WRITE, | |
59 | STATE_READ, | |
60 | STATE_ERROR, | |
61 | }; | |
62 | ||
63 | struct kempld_i2c_data { | |
64 | struct device *dev; | |
65 | struct kempld_device_data *pld; | |
66 | struct i2c_adapter adap; | |
67 | struct i2c_msg *msg; | |
68 | int pos; | |
69 | int nmsgs; | |
70 | int state; | |
71 | bool was_active; | |
72 | }; | |
73 | ||
74 | static unsigned int bus_frequency = KEMPLD_I2C_FREQ_STD; | |
75 | module_param(bus_frequency, uint, 0); | |
76 | MODULE_PARM_DESC(bus_frequency, "Set I2C bus frequency in kHz (default=" | |
77 | __MODULE_STRING(KEMPLD_I2C_FREQ_STD)")"); | |
78 | ||
79 | static int i2c_bus = -1; | |
80 | module_param(i2c_bus, int, 0); | |
81 | MODULE_PARM_DESC(i2c_bus, "Set I2C bus number (default=-1 for dynamic assignment)"); | |
82 | ||
83 | static bool i2c_gpio_mux; | |
84 | module_param(i2c_gpio_mux, bool, 0); | |
85 | MODULE_PARM_DESC(i2c_gpio_mux, "Enable I2C port on GPIO out (default=false)"); | |
86 | ||
87 | /* | |
88 | * kempld_get_mutex must be called prior to calling this function. | |
89 | */ | |
90 | static int kempld_i2c_process(struct kempld_i2c_data *i2c) | |
91 | { | |
92 | struct kempld_device_data *pld = i2c->pld; | |
93 | u8 stat = kempld_read8(pld, KEMPLD_I2C_STAT); | |
94 | struct i2c_msg *msg = i2c->msg; | |
95 | u8 addr; | |
96 | ||
97 | /* Ready? */ | |
98 | if (stat & I2C_STAT_TIP) | |
99 | return -EBUSY; | |
100 | ||
101 | if (i2c->state == STATE_DONE || i2c->state == STATE_ERROR) { | |
102 | /* Stop has been sent */ | |
103 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_IACK); | |
104 | if (i2c->state == STATE_ERROR) | |
105 | return -EIO; | |
106 | return 0; | |
107 | } | |
108 | ||
109 | /* Error? */ | |
110 | if (stat & I2C_STAT_ARBLOST) { | |
111 | i2c->state = STATE_ERROR; | |
112 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_STOP); | |
113 | return -EAGAIN; | |
114 | } | |
115 | ||
116 | if (i2c->state == STATE_INIT) { | |
117 | if (stat & I2C_STAT_BUSY) | |
118 | return -EBUSY; | |
119 | ||
120 | i2c->state = STATE_ADDR; | |
121 | } | |
122 | ||
123 | if (i2c->state == STATE_ADDR) { | |
124 | /* 10 bit address? */ | |
125 | if (i2c->msg->flags & I2C_M_TEN) { | |
126 | addr = 0xf0 | ((i2c->msg->addr >> 7) & 0x6); | |
127 | i2c->state = STATE_ADDR10; | |
128 | } else { | |
129 | addr = (i2c->msg->addr << 1); | |
130 | i2c->state = STATE_START; | |
131 | } | |
132 | ||
133 | /* Set read bit if necessary */ | |
134 | addr |= (i2c->msg->flags & I2C_M_RD) ? 1 : 0; | |
135 | ||
136 | kempld_write8(pld, KEMPLD_I2C_DATA, addr); | |
137 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_START); | |
138 | ||
139 | return 0; | |
140 | } | |
141 | ||
142 | /* Second part of 10 bit addressing */ | |
143 | if (i2c->state == STATE_ADDR10) { | |
144 | kempld_write8(pld, KEMPLD_I2C_DATA, i2c->msg->addr & 0xff); | |
145 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_WRITE); | |
146 | ||
147 | i2c->state = STATE_START; | |
148 | return 0; | |
149 | } | |
150 | ||
151 | if (i2c->state == STATE_START || i2c->state == STATE_WRITE) { | |
152 | i2c->state = (msg->flags & I2C_M_RD) ? STATE_READ : STATE_WRITE; | |
153 | ||
154 | if (stat & I2C_STAT_NACK) { | |
155 | i2c->state = STATE_ERROR; | |
156 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_STOP); | |
157 | return -ENXIO; | |
158 | } | |
159 | } else { | |
160 | msg->buf[i2c->pos++] = kempld_read8(pld, KEMPLD_I2C_DATA); | |
161 | } | |
162 | ||
163 | if (i2c->pos >= msg->len) { | |
164 | i2c->nmsgs--; | |
165 | i2c->msg++; | |
166 | i2c->pos = 0; | |
167 | msg = i2c->msg; | |
168 | ||
169 | if (i2c->nmsgs) { | |
170 | if (!(msg->flags & I2C_M_NOSTART)) { | |
171 | i2c->state = STATE_ADDR; | |
172 | return 0; | |
173 | } else { | |
174 | i2c->state = (msg->flags & I2C_M_RD) | |
175 | ? STATE_READ : STATE_WRITE; | |
176 | } | |
177 | } else { | |
178 | i2c->state = STATE_DONE; | |
179 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_STOP); | |
180 | return 0; | |
181 | } | |
182 | } | |
183 | ||
184 | if (i2c->state == STATE_READ) { | |
185 | kempld_write8(pld, KEMPLD_I2C_CMD, i2c->pos == (msg->len - 1) ? | |
186 | I2C_CMD_READ_NACK : I2C_CMD_READ_ACK); | |
187 | } else { | |
188 | kempld_write8(pld, KEMPLD_I2C_DATA, msg->buf[i2c->pos++]); | |
189 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_WRITE); | |
190 | } | |
191 | ||
192 | return 0; | |
193 | } | |
194 | ||
195 | static int kempld_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, | |
196 | int num) | |
197 | { | |
198 | struct kempld_i2c_data *i2c = i2c_get_adapdata(adap); | |
199 | struct kempld_device_data *pld = i2c->pld; | |
200 | unsigned long timeout = jiffies + HZ; | |
201 | int ret; | |
202 | ||
203 | i2c->msg = msgs; | |
204 | i2c->pos = 0; | |
205 | i2c->nmsgs = num; | |
206 | i2c->state = STATE_INIT; | |
207 | ||
208 | /* Handle the transfer */ | |
209 | while (time_before(jiffies, timeout)) { | |
210 | kempld_get_mutex(pld); | |
211 | ret = kempld_i2c_process(i2c); | |
212 | kempld_release_mutex(pld); | |
213 | ||
214 | if (i2c->state == STATE_DONE || i2c->state == STATE_ERROR) | |
215 | return (i2c->state == STATE_DONE) ? num : ret; | |
216 | ||
217 | if (ret == 0) | |
218 | timeout = jiffies + HZ; | |
219 | ||
220 | usleep_range(5, 15); | |
221 | } | |
222 | ||
223 | i2c->state = STATE_ERROR; | |
224 | ||
225 | return -ETIMEDOUT; | |
226 | } | |
227 | ||
228 | /* | |
229 | * kempld_get_mutex must be called prior to calling this function. | |
230 | */ | |
231 | static void kempld_i2c_device_init(struct kempld_i2c_data *i2c) | |
232 | { | |
233 | struct kempld_device_data *pld = i2c->pld; | |
234 | u16 prescale_corr; | |
235 | long prescale; | |
236 | u8 ctrl; | |
237 | u8 stat; | |
238 | u8 cfg; | |
239 | ||
240 | /* Make sure the device is disabled */ | |
241 | ctrl = kempld_read8(pld, KEMPLD_I2C_CTRL); | |
242 | ctrl &= ~(I2C_CTRL_EN | I2C_CTRL_IEN); | |
243 | kempld_write8(pld, KEMPLD_I2C_CTRL, ctrl); | |
244 | ||
245 | if (bus_frequency > KEMPLD_I2C_FREQ_MAX) | |
246 | bus_frequency = KEMPLD_I2C_FREQ_MAX; | |
247 | ||
248 | if (pld->info.spec_major == 1) | |
4c715661 | 249 | prescale = pld->pld_clock / (bus_frequency * 5) - 1000; |
e0b9b7b0 | 250 | else |
4c715661 | 251 | prescale = pld->pld_clock / (bus_frequency * 4) - 3000; |
e0b9b7b0 KS |
252 | |
253 | if (prescale < 0) | |
254 | prescale = 0; | |
255 | ||
256 | /* Round to the best matching value */ | |
257 | prescale_corr = prescale / 1000; | |
258 | if (prescale % 1000 >= 500) | |
259 | prescale_corr++; | |
260 | ||
261 | kempld_write8(pld, KEMPLD_I2C_PRELOW, prescale_corr & 0xff); | |
262 | kempld_write8(pld, KEMPLD_I2C_PREHIGH, prescale_corr >> 8); | |
263 | ||
264 | /* Activate I2C bus output on GPIO pins */ | |
265 | cfg = kempld_read8(pld, KEMPLD_CFG); | |
266 | if (i2c_gpio_mux) | |
267 | cfg |= KEMPLD_CFG_GPIO_I2C_MUX; | |
268 | else | |
269 | cfg &= ~KEMPLD_CFG_GPIO_I2C_MUX; | |
270 | kempld_write8(pld, KEMPLD_CFG, cfg); | |
271 | ||
272 | /* Enable the device */ | |
273 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_IACK); | |
274 | ctrl |= I2C_CTRL_EN; | |
275 | kempld_write8(pld, KEMPLD_I2C_CTRL, ctrl); | |
276 | ||
277 | stat = kempld_read8(pld, KEMPLD_I2C_STAT); | |
278 | if (stat & I2C_STAT_BUSY) | |
279 | kempld_write8(pld, KEMPLD_I2C_CMD, I2C_CMD_STOP); | |
280 | } | |
281 | ||
282 | static u32 kempld_i2c_func(struct i2c_adapter *adap) | |
283 | { | |
284 | return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR | I2C_FUNC_SMBUS_EMUL; | |
285 | } | |
286 | ||
287 | static const struct i2c_algorithm kempld_i2c_algorithm = { | |
288 | .master_xfer = kempld_i2c_xfer, | |
289 | .functionality = kempld_i2c_func, | |
290 | }; | |
291 | ||
329430cc | 292 | static const struct i2c_adapter kempld_i2c_adapter = { |
e0b9b7b0 KS |
293 | .owner = THIS_MODULE, |
294 | .name = "i2c-kempld", | |
295 | .class = I2C_CLASS_HWMON | I2C_CLASS_SPD, | |
296 | .algo = &kempld_i2c_algorithm, | |
297 | }; | |
298 | ||
299 | static int kempld_i2c_probe(struct platform_device *pdev) | |
300 | { | |
301 | struct kempld_device_data *pld = dev_get_drvdata(pdev->dev.parent); | |
302 | struct kempld_i2c_data *i2c; | |
303 | int ret; | |
304 | u8 ctrl; | |
305 | ||
306 | i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL); | |
307 | if (!i2c) | |
308 | return -ENOMEM; | |
309 | ||
310 | i2c->pld = pld; | |
311 | i2c->dev = &pdev->dev; | |
312 | i2c->adap = kempld_i2c_adapter; | |
313 | i2c->adap.dev.parent = i2c->dev; | |
314 | i2c_set_adapdata(&i2c->adap, i2c); | |
315 | platform_set_drvdata(pdev, i2c); | |
316 | ||
317 | kempld_get_mutex(pld); | |
318 | ctrl = kempld_read8(pld, KEMPLD_I2C_CTRL); | |
319 | ||
320 | if (ctrl & I2C_CTRL_EN) | |
321 | i2c->was_active = true; | |
322 | ||
323 | kempld_i2c_device_init(i2c); | |
324 | kempld_release_mutex(pld); | |
325 | ||
326 | /* Add I2C adapter to I2C tree */ | |
327 | if (i2c_bus >= -1) | |
328 | i2c->adap.nr = i2c_bus; | |
329 | ret = i2c_add_numbered_adapter(&i2c->adap); | |
330 | if (ret) | |
331 | return ret; | |
332 | ||
333 | dev_info(i2c->dev, "I2C bus initialized at %dkHz\n", | |
334 | bus_frequency); | |
335 | ||
336 | return 0; | |
337 | } | |
338 | ||
339 | static int kempld_i2c_remove(struct platform_device *pdev) | |
340 | { | |
341 | struct kempld_i2c_data *i2c = platform_get_drvdata(pdev); | |
342 | struct kempld_device_data *pld = i2c->pld; | |
343 | u8 ctrl; | |
344 | ||
345 | kempld_get_mutex(pld); | |
346 | /* | |
347 | * Disable I2C logic if it was not activated before the | |
348 | * driver loaded | |
349 | */ | |
350 | if (!i2c->was_active) { | |
351 | ctrl = kempld_read8(pld, KEMPLD_I2C_CTRL); | |
352 | ctrl &= ~I2C_CTRL_EN; | |
353 | kempld_write8(pld, KEMPLD_I2C_CTRL, ctrl); | |
354 | } | |
355 | kempld_release_mutex(pld); | |
356 | ||
357 | i2c_del_adapter(&i2c->adap); | |
358 | ||
359 | return 0; | |
360 | } | |
361 | ||
362 | #ifdef CONFIG_PM | |
363 | static int kempld_i2c_suspend(struct platform_device *pdev, pm_message_t state) | |
364 | { | |
365 | struct kempld_i2c_data *i2c = platform_get_drvdata(pdev); | |
366 | struct kempld_device_data *pld = i2c->pld; | |
367 | u8 ctrl; | |
368 | ||
369 | kempld_get_mutex(pld); | |
370 | ctrl = kempld_read8(pld, KEMPLD_I2C_CTRL); | |
371 | ctrl &= ~I2C_CTRL_EN; | |
372 | kempld_write8(pld, KEMPLD_I2C_CTRL, ctrl); | |
373 | kempld_release_mutex(pld); | |
374 | ||
375 | return 0; | |
376 | } | |
377 | ||
378 | static int kempld_i2c_resume(struct platform_device *pdev) | |
379 | { | |
380 | struct kempld_i2c_data *i2c = platform_get_drvdata(pdev); | |
381 | struct kempld_device_data *pld = i2c->pld; | |
382 | ||
383 | kempld_get_mutex(pld); | |
384 | kempld_i2c_device_init(i2c); | |
385 | kempld_release_mutex(pld); | |
386 | ||
387 | return 0; | |
388 | } | |
389 | #else | |
390 | #define kempld_i2c_suspend NULL | |
391 | #define kempld_i2c_resume NULL | |
392 | #endif | |
393 | ||
394 | static struct platform_driver kempld_i2c_driver = { | |
395 | .driver = { | |
396 | .name = "kempld-i2c", | |
e0b9b7b0 KS |
397 | }, |
398 | .probe = kempld_i2c_probe, | |
399 | .remove = kempld_i2c_remove, | |
400 | .suspend = kempld_i2c_suspend, | |
401 | .resume = kempld_i2c_resume, | |
402 | }; | |
403 | ||
404 | module_platform_driver(kempld_i2c_driver); | |
405 | ||
406 | MODULE_DESCRIPTION("KEM PLD I2C Driver"); | |
407 | MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>"); | |
408 | MODULE_LICENSE("GPL"); | |
409 | MODULE_ALIAS("platform:kempld_i2c"); |