blob: 614a5e114a19a1f37eed1d4ab2ea1e510300c6b7 [file] [log] [blame]
David S. Millere21e2452008-08-29 22:34:14 -07001/* bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * platforms.
3 *
David S. Millere21e2452008-08-29 22:34:14 -07004 * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 */
6
7#include <linux/module.h>
8#include <linux/kernel.h>
9#include <linux/types.h>
10#include <linux/slab.h>
11#include <linux/sched.h>
12#include <linux/wait.h>
13#include <linux/delay.h>
14#include <linux/init.h>
15#include <linux/interrupt.h>
David S. Millere21e2452008-08-29 22:34:14 -070016#include <linux/of.h>
17#include <linux/of_device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <asm/bbc.h>
David S. Miller4b5dff72007-05-13 22:22:13 -070019#include <asm/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
21#include "bbc_i2c.h"
22
23/* Convert this driver to use i2c bus layer someday... */
24#define I2C_PCF_PIN 0x80
25#define I2C_PCF_ESO 0x40
26#define I2C_PCF_ES1 0x20
27#define I2C_PCF_ES2 0x10
28#define I2C_PCF_ENI 0x08
29#define I2C_PCF_STA 0x04
30#define I2C_PCF_STO 0x02
31#define I2C_PCF_ACK 0x01
32
33#define I2C_PCF_START (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ENI | I2C_PCF_STA | I2C_PCF_ACK)
34#define I2C_PCF_STOP (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK)
35#define I2C_PCF_REPSTART ( I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK)
36#define I2C_PCF_IDLE (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ACK)
37
38#define I2C_PCF_INI 0x40 /* 1 if not initialized */
39#define I2C_PCF_STS 0x20
40#define I2C_PCF_BER 0x10
41#define I2C_PCF_AD0 0x08
42#define I2C_PCF_LRB 0x08
43#define I2C_PCF_AAS 0x04
44#define I2C_PCF_LAB 0x02
45#define I2C_PCF_BB 0x01
46
47/* The BBC devices have two I2C controllers. The first I2C controller
48 * connects mainly to configuration proms (NVRAM, cpu configuration,
49 * dimm types, etc.). Whereas the second I2C controller connects to
50 * environmental control devices such as fans and temperature sensors.
51 * The second controller also connects to the smartcard reader, if present.
52 */
53
Grant Likely2dc11582010-08-06 09:25:50 -060054static void set_device_claimage(struct bbc_i2c_bus *bp, struct platform_device *op, int val)
Linus Torvalds1da177e2005-04-16 15:20:36 -070055{
56 int i;
57
58 for (i = 0; i < NUM_CHILDREN; i++) {
David S. Millere21e2452008-08-29 22:34:14 -070059 if (bp->devs[i].device == op) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 bp->devs[i].client_claimed = val;
61 return;
62 }
63 }
64}
65
66#define claim_device(BP,ECHILD) set_device_claimage(BP,ECHILD,1)
67#define release_device(BP,ECHILD) set_device_claimage(BP,ECHILD,0)
68
Grant Likely2dc11582010-08-06 09:25:50 -060069struct platform_device *bbc_i2c_getdev(struct bbc_i2c_bus *bp, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Grant Likely2dc11582010-08-06 09:25:50 -060071 struct platform_device *op = NULL;
David S. Millere21e2452008-08-29 22:34:14 -070072 int curidx = 0, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
David S. Millere21e2452008-08-29 22:34:14 -070074 for (i = 0; i < NUM_CHILDREN; i++) {
75 if (!(op = bp->devs[i].device))
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 break;
David S. Millere21e2452008-08-29 22:34:14 -070077 if (curidx == index)
78 goto out;
79 op = NULL;
80 curidx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 }
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083out:
84 if (curidx == index)
David S. Millere21e2452008-08-29 22:34:14 -070085 return op;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 return NULL;
87}
88
Grant Likely2dc11582010-08-06 09:25:50 -060089struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct platform_device *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 struct bbc_i2c_client *client;
David S. Millere21e2452008-08-29 22:34:14 -070092 const u32 *reg;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Yoann Padioleaudd00cc42007-07-19 01:49:03 -070094 client = kzalloc(sizeof(*client), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 if (!client)
96 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 client->bp = bp;
David S. Millere21e2452008-08-29 22:34:14 -070098 client->op = op;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Grant Likely61c7a082010-04-13 16:12:29 -0700100 reg = of_get_property(op->dev.of_node, "reg", NULL);
David S. Millere21e2452008-08-29 22:34:14 -0700101 if (!reg) {
102 kfree(client);
103 return NULL;
104 }
105
106 client->bus = reg[0];
107 client->address = reg[1];
108
109 claim_device(bp, op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111 return client;
112}
113
114void bbc_i2c_detach(struct bbc_i2c_client *client)
115{
116 struct bbc_i2c_bus *bp = client->bp;
Grant Likely2dc11582010-08-06 09:25:50 -0600117 struct platform_device *op = client->op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
David S. Millere21e2452008-08-29 22:34:14 -0700119 release_device(bp, op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 kfree(client);
121}
122
123static int wait_for_pin(struct bbc_i2c_bus *bp, u8 *status)
124{
125 DECLARE_WAITQUEUE(wait, current);
126 int limit = 32;
127 int ret = 1;
128
129 bp->waiting = 1;
130 add_wait_queue(&bp->wq, &wait);
131 while (limit-- > 0) {
Roel Kluinf4c13632009-03-04 00:19:28 -0800132 long val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
David S. Miller3b36fb82007-02-26 10:11:35 -0800134 val = wait_event_interruptible_timeout(
135 bp->wq,
136 (((*status = readb(bp->i2c_control_regs + 0))
137 & I2C_PCF_PIN) == 0),
138 msecs_to_jiffies(250));
139 if (val > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 ret = 0;
141 break;
142 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 }
144 remove_wait_queue(&bp->wq, &wait);
145 bp->waiting = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
147 return ret;
148}
149
150int bbc_i2c_writeb(struct bbc_i2c_client *client, unsigned char val, int off)
151{
152 struct bbc_i2c_bus *bp = client->bp;
153 int address = client->address;
154 u8 status;
155 int ret = -1;
156
157 if (bp->i2c_bussel_reg != NULL)
158 writeb(client->bus, bp->i2c_bussel_reg);
159
160 writeb(address, bp->i2c_control_regs + 0x1);
161 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
162 if (wait_for_pin(bp, &status))
163 goto out;
164
165 writeb(off, bp->i2c_control_regs + 0x1);
166 if (wait_for_pin(bp, &status) ||
167 (status & I2C_PCF_LRB) != 0)
168 goto out;
169
170 writeb(val, bp->i2c_control_regs + 0x1);
171 if (wait_for_pin(bp, &status))
172 goto out;
173
174 ret = 0;
175
176out:
177 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
178 return ret;
179}
180
181int bbc_i2c_readb(struct bbc_i2c_client *client, unsigned char *byte, int off)
182{
183 struct bbc_i2c_bus *bp = client->bp;
184 unsigned char address = client->address, status;
185 int ret = -1;
186
187 if (bp->i2c_bussel_reg != NULL)
188 writeb(client->bus, bp->i2c_bussel_reg);
189
190 writeb(address, bp->i2c_control_regs + 0x1);
191 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
192 if (wait_for_pin(bp, &status))
193 goto out;
194
195 writeb(off, bp->i2c_control_regs + 0x1);
196 if (wait_for_pin(bp, &status) ||
197 (status & I2C_PCF_LRB) != 0)
198 goto out;
199
200 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
201
202 address |= 0x1; /* READ */
203
204 writeb(address, bp->i2c_control_regs + 0x1);
205 writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
206 if (wait_for_pin(bp, &status))
207 goto out;
208
209 /* Set PIN back to one so the device sends the first
210 * byte.
211 */
212 (void) readb(bp->i2c_control_regs + 0x1);
213 if (wait_for_pin(bp, &status))
214 goto out;
215
216 writeb(I2C_PCF_ESO | I2C_PCF_ENI, bp->i2c_control_regs + 0x0);
217 *byte = readb(bp->i2c_control_regs + 0x1);
218 if (wait_for_pin(bp, &status))
219 goto out;
220
221 ret = 0;
222
223out:
224 writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
225 (void) readb(bp->i2c_control_regs + 0x1);
226
227 return ret;
228}
229
230int bbc_i2c_write_buf(struct bbc_i2c_client *client,
231 char *buf, int len, int off)
232{
233 int ret = 0;
234
235 while (len > 0) {
236 int err = bbc_i2c_writeb(client, *buf, off);
237
238 if (err < 0) {
239 ret = err;
240 break;
241 }
242
243 len--;
244 buf++;
245 off++;
246 }
247 return ret;
248}
249
250int bbc_i2c_read_buf(struct bbc_i2c_client *client,
251 char *buf, int len, int off)
252{
253 int ret = 0;
254
255 while (len > 0) {
256 int err = bbc_i2c_readb(client, buf, off);
257 if (err < 0) {
258 ret = err;
259 break;
260 }
261 len--;
262 buf++;
263 off++;
264 }
265
266 return ret;
267}
268
269EXPORT_SYMBOL(bbc_i2c_getdev);
270EXPORT_SYMBOL(bbc_i2c_attach);
271EXPORT_SYMBOL(bbc_i2c_detach);
272EXPORT_SYMBOL(bbc_i2c_writeb);
273EXPORT_SYMBOL(bbc_i2c_readb);
274EXPORT_SYMBOL(bbc_i2c_write_buf);
275EXPORT_SYMBOL(bbc_i2c_read_buf);
276
David Howells7d12e782006-10-05 14:55:46 +0100277static irqreturn_t bbc_i2c_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278{
279 struct bbc_i2c_bus *bp = dev_id;
280
281 /* PIN going from set to clear is the only event which
282 * makes the i2c assert an interrupt.
283 */
284 if (bp->waiting &&
285 !(readb(bp->i2c_control_regs + 0x0) & I2C_PCF_PIN))
David S. Miller3b36fb82007-02-26 10:11:35 -0800286 wake_up_interruptible(&bp->wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 return IRQ_HANDLED;
289}
290
291static void __init reset_one_i2c(struct bbc_i2c_bus *bp)
292{
293 writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
294 writeb(bp->own, bp->i2c_control_regs + 0x1);
295 writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
296 writeb(bp->clock, bp->i2c_control_regs + 0x1);
297 writeb(I2C_PCF_IDLE, bp->i2c_control_regs + 0x0);
298}
299
Grant Likely2dc11582010-08-06 09:25:50 -0600300static struct bbc_i2c_bus * __init attach_one_i2c(struct platform_device *op, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301{
Mariusz Kozlowski50aa4852007-07-31 14:04:57 -0700302 struct bbc_i2c_bus *bp;
David S. Millere21e2452008-08-29 22:34:14 -0700303 struct device_node *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 int entry;
305
Mariusz Kozlowski50aa4852007-07-31 14:04:57 -0700306 bp = kzalloc(sizeof(*bp), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 if (!bp)
David S. Millere21e2452008-08-29 22:34:14 -0700308 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
David S. Millere21e2452008-08-29 22:34:14 -0700310 bp->i2c_control_regs = of_ioremap(&op->resource[0], 0, 0x2, "bbc_i2c_regs");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 if (!bp->i2c_control_regs)
312 goto fail;
313
David S. Millere21e2452008-08-29 22:34:14 -0700314 bp->i2c_bussel_reg = of_ioremap(&op->resource[1], 0, 0x1, "bbc_i2c_bussel");
315 if (!bp->i2c_bussel_reg)
316 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
318 bp->waiting = 0;
319 init_waitqueue_head(&bp->wq);
Grant Likely1636f8a2010-06-18 11:09:58 -0600320 if (request_irq(op->archdata.irqs[0], bbc_i2c_interrupt,
Thomas Gleixnerdace1452006-07-01 19:29:38 -0700321 IRQF_SHARED, "bbc_i2c", bp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 goto fail;
323
324 bp->index = index;
David S. Millere21e2452008-08-29 22:34:14 -0700325 bp->op = op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 spin_lock_init(&bp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
329 entry = 0;
Grant Likely61c7a082010-04-13 16:12:29 -0700330 for (dp = op->dev.of_node->child;
David S. Millere21e2452008-08-29 22:34:14 -0700331 dp && entry < 8;
332 dp = dp->sibling, entry++) {
Grant Likely2dc11582010-08-06 09:25:50 -0600333 struct platform_device *child_op;
David S. Millere21e2452008-08-29 22:34:14 -0700334
335 child_op = of_find_device_by_node(dp);
336 bp->devs[entry].device = child_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 bp->devs[entry].client_claimed = 0;
338 }
339
340 writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
341 bp->own = readb(bp->i2c_control_regs + 0x01);
342 writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
343 bp->clock = readb(bp->i2c_control_regs + 0x01);
344
345 printk(KERN_INFO "i2c-%d: Regs at %p, %d devices, own %02x, clock %02x.\n",
346 bp->index, bp->i2c_control_regs, entry, bp->own, bp->clock);
347
348 reset_one_i2c(bp);
349
David S. Millere21e2452008-08-29 22:34:14 -0700350 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352fail:
353 if (bp->i2c_bussel_reg)
David S. Millere21e2452008-08-29 22:34:14 -0700354 of_iounmap(&op->resource[1], bp->i2c_bussel_reg, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 if (bp->i2c_control_regs)
David S. Millere21e2452008-08-29 22:34:14 -0700356 of_iounmap(&op->resource[0], bp->i2c_control_regs, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 kfree(bp);
David S. Millere21e2452008-08-29 22:34:14 -0700358 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
David S. Millere21e2452008-08-29 22:34:14 -0700361extern int bbc_envctrl_init(struct bbc_i2c_bus *bp);
362extern void bbc_envctrl_cleanup(struct bbc_i2c_bus *bp);
363
Grant Likely2dc11582010-08-06 09:25:50 -0600364static int __devinit bbc_i2c_probe(struct platform_device *op,
David S. Millere21e2452008-08-29 22:34:14 -0700365 const struct of_device_id *match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
David S. Millere21e2452008-08-29 22:34:14 -0700367 struct bbc_i2c_bus *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 int err, index = 0;
369
David S. Millere21e2452008-08-29 22:34:14 -0700370 bp = attach_one_i2c(op, index);
371 if (!bp)
372 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
David S. Millere21e2452008-08-29 22:34:14 -0700374 err = bbc_envctrl_init(bp);
375 if (err) {
Grant Likely1636f8a2010-06-18 11:09:58 -0600376 free_irq(op->archdata.irqs[0], bp);
David S. Millere21e2452008-08-29 22:34:14 -0700377 if (bp->i2c_bussel_reg)
378 of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
379 if (bp->i2c_control_regs)
380 of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
381 kfree(bp);
382 } else {
383 dev_set_drvdata(&op->dev, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 }
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 return err;
387}
388
Grant Likely2dc11582010-08-06 09:25:50 -0600389static int __devexit bbc_i2c_remove(struct platform_device *op)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390{
David S. Millere21e2452008-08-29 22:34:14 -0700391 struct bbc_i2c_bus *bp = dev_get_drvdata(&op->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
David S. Millere21e2452008-08-29 22:34:14 -0700393 bbc_envctrl_cleanup(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
Grant Likely1636f8a2010-06-18 11:09:58 -0600395 free_irq(op->archdata.irqs[0], bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
David S. Millere21e2452008-08-29 22:34:14 -0700397 if (bp->i2c_bussel_reg)
398 of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
399 if (bp->i2c_control_regs)
400 of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
David S. Millere21e2452008-08-29 22:34:14 -0700402 kfree(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
David S. Millere21e2452008-08-29 22:34:14 -0700404 return 0;
405}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
David S. Millerfd098312008-08-31 01:23:17 -0700407static const struct of_device_id bbc_i2c_match[] = {
David S. Millere21e2452008-08-29 22:34:14 -0700408 {
409 .name = "i2c",
410 .compatible = "SUNW,bbc-i2c",
411 },
412 {},
413};
414MODULE_DEVICE_TABLE(of, bbc_i2c_match);
415
416static struct of_platform_driver bbc_i2c_driver = {
Grant Likely40182942010-04-13 16:13:02 -0700417 .driver = {
418 .name = "bbc_i2c",
419 .owner = THIS_MODULE,
420 .of_match_table = bbc_i2c_match,
421 },
David S. Millere21e2452008-08-29 22:34:14 -0700422 .probe = bbc_i2c_probe,
Linus Torvalds33b07db2008-12-01 07:55:14 -0800423 .remove = __devexit_p(bbc_i2c_remove),
David S. Millere21e2452008-08-29 22:34:14 -0700424};
425
426static int __init bbc_i2c_init(void)
427{
Grant Likely1ab1d632010-06-24 15:14:37 -0600428 return of_register_platform_driver(&bbc_i2c_driver);
David S. Millere21e2452008-08-29 22:34:14 -0700429}
430
431static void __exit bbc_i2c_exit(void)
432{
Grant Likely1ab1d632010-06-24 15:14:37 -0600433 of_unregister_platform_driver(&bbc_i2c_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434}
435
436module_init(bbc_i2c_init);
David S. Millere21e2452008-08-29 22:34:14 -0700437module_exit(bbc_i2c_exit);
438
David S. Millerb5e7ae52006-03-17 13:23:56 -0800439MODULE_LICENSE("GPL");