GNU Linux-libre 4.9.309-gnu1
[releases.git] / drivers / sbus / char / bbc_i2c.c
1 /* bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III
2  *            platforms.
3  *
4  * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
5  */
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/interrupt.h>
15 #include <linux/of.h>
16 #include <linux/of_device.h>
17 #include <asm/bbc.h>
18 #include <asm/io.h>
19
20 #include "bbc_i2c.h"
21
22 /* Convert this driver to use i2c bus layer someday... */
23 #define I2C_PCF_PIN     0x80
24 #define I2C_PCF_ESO     0x40
25 #define I2C_PCF_ES1     0x20
26 #define I2C_PCF_ES2     0x10
27 #define I2C_PCF_ENI     0x08
28 #define I2C_PCF_STA     0x04
29 #define I2C_PCF_STO     0x02
30 #define I2C_PCF_ACK     0x01
31
32 #define I2C_PCF_START    (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ENI | I2C_PCF_STA | I2C_PCF_ACK)
33 #define I2C_PCF_STOP     (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK)
34 #define I2C_PCF_REPSTART (              I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK)
35 #define I2C_PCF_IDLE     (I2C_PCF_PIN | I2C_PCF_ESO               | I2C_PCF_ACK)
36
37 #define I2C_PCF_INI 0x40   /* 1 if not initialized */
38 #define I2C_PCF_STS 0x20
39 #define I2C_PCF_BER 0x10
40 #define I2C_PCF_AD0 0x08
41 #define I2C_PCF_LRB 0x08
42 #define I2C_PCF_AAS 0x04
43 #define I2C_PCF_LAB 0x02
44 #define I2C_PCF_BB  0x01
45
46 /* The BBC devices have two I2C controllers.  The first I2C controller
47  * connects mainly to configuration proms (NVRAM, cpu configuration,
48  * dimm types, etc.).  Whereas the second I2C controller connects to
49  * environmental control devices such as fans and temperature sensors.
50  * The second controller also connects to the smartcard reader, if present.
51  */
52
53 static void set_device_claimage(struct bbc_i2c_bus *bp, struct platform_device *op, int val)
54 {
55         int i;
56
57         for (i = 0; i < NUM_CHILDREN; i++) {
58                 if (bp->devs[i].device == op) {
59                         bp->devs[i].client_claimed = val;
60                         return;
61                 }
62         }
63 }
64
65 #define claim_device(BP,ECHILD)         set_device_claimage(BP,ECHILD,1)
66 #define release_device(BP,ECHILD)       set_device_claimage(BP,ECHILD,0)
67
68 struct platform_device *bbc_i2c_getdev(struct bbc_i2c_bus *bp, int index)
69 {
70         struct platform_device *op = NULL;
71         int curidx = 0, i;
72
73         for (i = 0; i < NUM_CHILDREN; i++) {
74                 if (!(op = bp->devs[i].device))
75                         break;
76                 if (curidx == index)
77                         goto out;
78                 op = NULL;
79                 curidx++;
80         }
81
82 out:
83         if (curidx == index)
84                 return op;
85         return NULL;
86 }
87
88 struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct platform_device *op)
89 {
90         struct bbc_i2c_client *client;
91         const u32 *reg;
92
93         client = kzalloc(sizeof(*client), GFP_KERNEL);
94         if (!client)
95                 return NULL;
96         client->bp = bp;
97         client->op = op;
98
99         reg = of_get_property(op->dev.of_node, "reg", NULL);
100         if (!reg) {
101                 kfree(client);
102                 return NULL;
103         }
104
105         client->bus = reg[0];
106         client->address = reg[1];
107
108         claim_device(bp, op);
109
110         return client;
111 }
112
113 void bbc_i2c_detach(struct bbc_i2c_client *client)
114 {
115         struct bbc_i2c_bus *bp = client->bp;
116         struct platform_device *op = client->op;
117
118         release_device(bp, op);
119         kfree(client);
120 }
121
122 static int wait_for_pin(struct bbc_i2c_bus *bp, u8 *status)
123 {
124         DECLARE_WAITQUEUE(wait, current);
125         int limit = 32;
126         int ret = 1;
127
128         bp->waiting = 1;
129         add_wait_queue(&bp->wq, &wait);
130         while (limit-- > 0) {
131                 long val;
132
133                 val = wait_event_interruptible_timeout(
134                                 bp->wq,
135                                 (((*status = readb(bp->i2c_control_regs + 0))
136                                   & I2C_PCF_PIN) == 0),
137                                 msecs_to_jiffies(250));
138                 if (val > 0) {
139                         ret = 0;
140                         break;
141                 }
142         }
143         remove_wait_queue(&bp->wq, &wait);
144         bp->waiting = 0;
145
146         return ret;
147 }
148
149 int bbc_i2c_writeb(struct bbc_i2c_client *client, unsigned char val, int off)
150 {
151         struct bbc_i2c_bus *bp = client->bp;
152         int address = client->address;
153         u8 status;
154         int ret = -1;
155
156         if (bp->i2c_bussel_reg != NULL)
157                 writeb(client->bus, bp->i2c_bussel_reg);
158
159         writeb(address, bp->i2c_control_regs + 0x1);
160         writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
161         if (wait_for_pin(bp, &status))
162                 goto out;
163
164         writeb(off, bp->i2c_control_regs + 0x1);
165         if (wait_for_pin(bp, &status) ||
166             (status & I2C_PCF_LRB) != 0)
167                 goto out;
168
169         writeb(val, bp->i2c_control_regs + 0x1);
170         if (wait_for_pin(bp, &status))
171                 goto out;
172
173         ret = 0;
174
175 out:
176         writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
177         return ret;
178 }
179
180 int bbc_i2c_readb(struct bbc_i2c_client *client, unsigned char *byte, int off)
181 {
182         struct bbc_i2c_bus *bp = client->bp;
183         unsigned char address = client->address, status;
184         int ret = -1;
185
186         if (bp->i2c_bussel_reg != NULL)
187                 writeb(client->bus, bp->i2c_bussel_reg);
188
189         writeb(address, bp->i2c_control_regs + 0x1);
190         writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
191         if (wait_for_pin(bp, &status))
192                 goto out;
193
194         writeb(off, bp->i2c_control_regs + 0x1);
195         if (wait_for_pin(bp, &status) ||
196             (status & I2C_PCF_LRB) != 0)
197                 goto out;
198
199         writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
200
201         address |= 0x1; /* READ */
202
203         writeb(address, bp->i2c_control_regs + 0x1);
204         writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
205         if (wait_for_pin(bp, &status))
206                 goto out;
207
208         /* Set PIN back to one so the device sends the first
209          * byte.
210          */
211         (void) readb(bp->i2c_control_regs + 0x1);
212         if (wait_for_pin(bp, &status))
213                 goto out;
214
215         writeb(I2C_PCF_ESO | I2C_PCF_ENI, bp->i2c_control_regs + 0x0);
216         *byte = readb(bp->i2c_control_regs + 0x1);
217         if (wait_for_pin(bp, &status))
218                 goto out;
219
220         ret = 0;
221
222 out:
223         writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
224         (void) readb(bp->i2c_control_regs + 0x1);
225
226         return ret;
227 }
228
229 int bbc_i2c_write_buf(struct bbc_i2c_client *client,
230                       char *buf, int len, int off)
231 {
232         int ret = 0;
233
234         while (len > 0) {
235                 ret = bbc_i2c_writeb(client, *buf, off);
236                 if (ret < 0)
237                         break;
238                 len--;
239                 buf++;
240                 off++;
241         }
242         return ret;
243 }
244
245 int bbc_i2c_read_buf(struct bbc_i2c_client *client,
246                      char *buf, int len, int off)
247 {
248         int ret = 0;
249
250         while (len > 0) {
251                 ret = bbc_i2c_readb(client, buf, off);
252                 if (ret < 0)
253                         break;
254                 len--;
255                 buf++;
256                 off++;
257         }
258
259         return ret;
260 }
261
262 EXPORT_SYMBOL(bbc_i2c_getdev);
263 EXPORT_SYMBOL(bbc_i2c_attach);
264 EXPORT_SYMBOL(bbc_i2c_detach);
265 EXPORT_SYMBOL(bbc_i2c_writeb);
266 EXPORT_SYMBOL(bbc_i2c_readb);
267 EXPORT_SYMBOL(bbc_i2c_write_buf);
268 EXPORT_SYMBOL(bbc_i2c_read_buf);
269
270 static irqreturn_t bbc_i2c_interrupt(int irq, void *dev_id)
271 {
272         struct bbc_i2c_bus *bp = dev_id;
273
274         /* PIN going from set to clear is the only event which
275          * makes the i2c assert an interrupt.
276          */
277         if (bp->waiting &&
278             !(readb(bp->i2c_control_regs + 0x0) & I2C_PCF_PIN))
279                 wake_up_interruptible(&bp->wq);
280
281         return IRQ_HANDLED;
282 }
283
284 static void reset_one_i2c(struct bbc_i2c_bus *bp)
285 {
286         writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
287         writeb(bp->own, bp->i2c_control_regs + 0x1);
288         writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
289         writeb(bp->clock, bp->i2c_control_regs + 0x1);
290         writeb(I2C_PCF_IDLE, bp->i2c_control_regs + 0x0);
291 }
292
293 static struct bbc_i2c_bus * attach_one_i2c(struct platform_device *op, int index)
294 {
295         struct bbc_i2c_bus *bp;
296         struct device_node *dp;
297         int entry;
298
299         bp = kzalloc(sizeof(*bp), GFP_KERNEL);
300         if (!bp)
301                 return NULL;
302
303         INIT_LIST_HEAD(&bp->temps);
304         INIT_LIST_HEAD(&bp->fans);
305
306         bp->i2c_control_regs = of_ioremap(&op->resource[0], 0, 0x2, "bbc_i2c_regs");
307         if (!bp->i2c_control_regs)
308                 goto fail;
309
310         if (op->num_resources == 2) {
311                 bp->i2c_bussel_reg = of_ioremap(&op->resource[1], 0, 0x1, "bbc_i2c_bussel");
312                 if (!bp->i2c_bussel_reg)
313                         goto fail;
314         }
315
316         bp->waiting = 0;
317         init_waitqueue_head(&bp->wq);
318         if (request_irq(op->archdata.irqs[0], bbc_i2c_interrupt,
319                         IRQF_SHARED, "bbc_i2c", bp))
320                 goto fail;
321
322         bp->index = index;
323         bp->op = op;
324
325         spin_lock_init(&bp->lock);
326
327         entry = 0;
328         for (dp = op->dev.of_node->child;
329              dp && entry < 8;
330              dp = dp->sibling, entry++) {
331                 struct platform_device *child_op;
332
333                 child_op = of_find_device_by_node(dp);
334                 bp->devs[entry].device = child_op;
335                 bp->devs[entry].client_claimed = 0;
336         }
337
338         writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
339         bp->own = readb(bp->i2c_control_regs + 0x01);
340         writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
341         bp->clock = readb(bp->i2c_control_regs + 0x01);
342
343         printk(KERN_INFO "i2c-%d: Regs at %p, %d devices, own %02x, clock %02x.\n",
344                bp->index, bp->i2c_control_regs, entry, bp->own, bp->clock);
345
346         reset_one_i2c(bp);
347
348         return bp;
349
350 fail:
351         if (bp->i2c_bussel_reg)
352                 of_iounmap(&op->resource[1], bp->i2c_bussel_reg, 1);
353         if (bp->i2c_control_regs)
354                 of_iounmap(&op->resource[0], bp->i2c_control_regs, 2);
355         kfree(bp);
356         return NULL;
357 }
358
359 extern int bbc_envctrl_init(struct bbc_i2c_bus *bp);
360 extern void bbc_envctrl_cleanup(struct bbc_i2c_bus *bp);
361
362 static int bbc_i2c_probe(struct platform_device *op)
363 {
364         struct bbc_i2c_bus *bp;
365         int err, index = 0;
366
367         bp = attach_one_i2c(op, index);
368         if (!bp)
369                 return -EINVAL;
370
371         err = bbc_envctrl_init(bp);
372         if (err) {
373                 free_irq(op->archdata.irqs[0], bp);
374                 if (bp->i2c_bussel_reg)
375                         of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
376                 if (bp->i2c_control_regs)
377                         of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
378                 kfree(bp);
379         } else {
380                 dev_set_drvdata(&op->dev, bp);
381         }
382
383         return err;
384 }
385
386 static int bbc_i2c_remove(struct platform_device *op)
387 {
388         struct bbc_i2c_bus *bp = dev_get_drvdata(&op->dev);
389
390         bbc_envctrl_cleanup(bp);
391
392         free_irq(op->archdata.irqs[0], bp);
393
394         if (bp->i2c_bussel_reg)
395                 of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
396         if (bp->i2c_control_regs)
397                 of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
398
399         kfree(bp);
400
401         return 0;
402 }
403
404 static const struct of_device_id bbc_i2c_match[] = {
405         {
406                 .name = "i2c",
407                 .compatible = "SUNW,bbc-i2c",
408         },
409         {},
410 };
411 MODULE_DEVICE_TABLE(of, bbc_i2c_match);
412
413 static struct platform_driver bbc_i2c_driver = {
414         .driver = {
415                 .name = "bbc_i2c",
416                 .of_match_table = bbc_i2c_match,
417         },
418         .probe          = bbc_i2c_probe,
419         .remove         = bbc_i2c_remove,
420 };
421
422 module_platform_driver(bbc_i2c_driver);
423
424 MODULE_LICENSE("GPL");