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