Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[linux-2.6] / drivers / sbus / char / bbc_i2c.c
1 /* $Id: bbc_i2c.c,v 1.2 2001/04/02 09:59:08 davem Exp $
2  * bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III
3  *            platforms.
4  *
5  * Copyright (C) 2001 David S. Miller (davem@redhat.com)
6  */
7
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/types.h>
11 #include <linux/slab.h>
12 #include <linux/sched.h>
13 #include <linux/wait.h>
14 #include <linux/delay.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <asm/oplib.h>
18 #include <asm/ebus.h>
19 #include <asm/spitfire.h>
20 #include <asm/bbc.h>
21 #include <asm/io.h>
22
23 #include "bbc_i2c.h"
24
25 /* Convert this driver to use i2c bus layer someday... */
26 #define I2C_PCF_PIN     0x80
27 #define I2C_PCF_ESO     0x40
28 #define I2C_PCF_ES1     0x20
29 #define I2C_PCF_ES2     0x10
30 #define I2C_PCF_ENI     0x08
31 #define I2C_PCF_STA     0x04
32 #define I2C_PCF_STO     0x02
33 #define I2C_PCF_ACK     0x01
34
35 #define I2C_PCF_START    (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ENI | I2C_PCF_STA | I2C_PCF_ACK)
36 #define I2C_PCF_STOP     (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK)
37 #define I2C_PCF_REPSTART (              I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK)
38 #define I2C_PCF_IDLE     (I2C_PCF_PIN | I2C_PCF_ESO               | I2C_PCF_ACK)
39
40 #define I2C_PCF_INI 0x40   /* 1 if not initialized */
41 #define I2C_PCF_STS 0x20
42 #define I2C_PCF_BER 0x10
43 #define I2C_PCF_AD0 0x08
44 #define I2C_PCF_LRB 0x08
45 #define I2C_PCF_AAS 0x04
46 #define I2C_PCF_LAB 0x02
47 #define I2C_PCF_BB  0x01
48
49 /* The BBC devices have two I2C controllers.  The first I2C controller
50  * connects mainly to configuration proms (NVRAM, cpu configuration,
51  * dimm types, etc.).  Whereas the second I2C controller connects to
52  * environmental control devices such as fans and temperature sensors.
53  * The second controller also connects to the smartcard reader, if present.
54  */
55
56 #define NUM_CHILDREN    8
57 struct bbc_i2c_bus {
58         struct bbc_i2c_bus              *next;
59         int                             index;
60         spinlock_t                      lock;
61         void                            __iomem *i2c_bussel_reg;
62         void                            __iomem *i2c_control_regs;
63         unsigned char                   own, clock;
64
65         wait_queue_head_t               wq;
66         volatile int                    waiting;
67
68         struct linux_ebus_device        *bus_edev;
69         struct {
70                 struct linux_ebus_child *device;
71                 int                     client_claimed;
72         } devs[NUM_CHILDREN];
73 };
74
75 static struct bbc_i2c_bus *all_bbc_i2c;
76
77 struct bbc_i2c_client {
78         struct bbc_i2c_bus      *bp;
79         struct linux_ebus_child *echild;
80         int                     bus;
81         int                     address;
82 };
83
84 static int find_device(struct bbc_i2c_bus *bp, struct linux_ebus_child *echild)
85 {
86         int i;
87
88         for (i = 0; i < NUM_CHILDREN; i++) {
89                 if (bp->devs[i].device == echild) {
90                         if (bp->devs[i].client_claimed)
91                                 return 0;
92                         return 1;
93                 }
94         }
95         return 0;
96 }
97
98 static void set_device_claimage(struct bbc_i2c_bus *bp, struct linux_ebus_child *echild, int val)
99 {
100         int i;
101
102         for (i = 0; i < NUM_CHILDREN; i++) {
103                 if (bp->devs[i].device == echild) {
104                         bp->devs[i].client_claimed = val;
105                         return;
106                 }
107         }
108 }
109
110 #define claim_device(BP,ECHILD)         set_device_claimage(BP,ECHILD,1)
111 #define release_device(BP,ECHILD)       set_device_claimage(BP,ECHILD,0)
112
113 static struct bbc_i2c_bus *find_bus_for_device(struct linux_ebus_child *echild)
114 {
115         struct bbc_i2c_bus *bp = all_bbc_i2c;
116
117         while (bp != NULL) {
118                 if (find_device(bp, echild) != 0)
119                         break;
120                 bp = bp->next;
121         }
122
123         return bp;
124 }
125
126 struct linux_ebus_child *bbc_i2c_getdev(int index)
127 {
128         struct bbc_i2c_bus *bp = all_bbc_i2c;
129         struct linux_ebus_child *echild = NULL;
130         int curidx = 0;
131
132         while (bp != NULL) {
133                 struct bbc_i2c_bus *next = bp->next;
134                 int i;
135
136                 for (i = 0; i < NUM_CHILDREN; i++) {
137                         if (!(echild = bp->devs[i].device))
138                                 break;
139                         if (curidx == index)
140                                 goto out;
141                         echild = NULL;
142                         curidx++;
143                 }
144                 bp = next;
145         }
146 out:
147         if (curidx == index)
148                 return echild;
149         return NULL;
150 }
151
152 struct bbc_i2c_client *bbc_i2c_attach(struct linux_ebus_child *echild)
153 {
154         struct bbc_i2c_bus *bp = find_bus_for_device(echild);
155         struct bbc_i2c_client *client;
156
157         if (!bp)
158                 return NULL;
159         client = kmalloc(sizeof(*client), GFP_KERNEL);
160         if (!client)
161                 return NULL;
162         memset(client, 0, sizeof(*client));
163         client->bp = bp;
164         client->echild = echild;
165         client->bus = echild->resource[0].start;
166         client->address = echild->resource[1].start;
167
168         claim_device(bp, echild);
169
170         return client;
171 }
172
173 void bbc_i2c_detach(struct bbc_i2c_client *client)
174 {
175         struct bbc_i2c_bus *bp = client->bp;
176         struct linux_ebus_child *echild = client->echild;
177
178         release_device(bp, echild);
179         kfree(client);
180 }
181
182 static int wait_for_pin(struct bbc_i2c_bus *bp, u8 *status)
183 {
184         DECLARE_WAITQUEUE(wait, current);
185         int limit = 32;
186         int ret = 1;
187
188         bp->waiting = 1;
189         add_wait_queue(&bp->wq, &wait);
190         while (limit-- > 0) {
191                 unsigned long val;
192
193                 val = wait_event_interruptible_timeout(
194                                 bp->wq,
195                                 (((*status = readb(bp->i2c_control_regs + 0))
196                                   & I2C_PCF_PIN) == 0),
197                                 msecs_to_jiffies(250));
198                 if (val > 0) {
199                         ret = 0;
200                         break;
201                 }
202         }
203         remove_wait_queue(&bp->wq, &wait);
204         bp->waiting = 0;
205
206         return ret;
207 }
208
209 int bbc_i2c_writeb(struct bbc_i2c_client *client, unsigned char val, int off)
210 {
211         struct bbc_i2c_bus *bp = client->bp;
212         int address = client->address;
213         u8 status;
214         int ret = -1;
215
216         if (bp->i2c_bussel_reg != NULL)
217                 writeb(client->bus, bp->i2c_bussel_reg);
218
219         writeb(address, bp->i2c_control_regs + 0x1);
220         writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
221         if (wait_for_pin(bp, &status))
222                 goto out;
223
224         writeb(off, bp->i2c_control_regs + 0x1);
225         if (wait_for_pin(bp, &status) ||
226             (status & I2C_PCF_LRB) != 0)
227                 goto out;
228
229         writeb(val, bp->i2c_control_regs + 0x1);
230         if (wait_for_pin(bp, &status))
231                 goto out;
232
233         ret = 0;
234
235 out:
236         writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
237         return ret;
238 }
239
240 int bbc_i2c_readb(struct bbc_i2c_client *client, unsigned char *byte, int off)
241 {
242         struct bbc_i2c_bus *bp = client->bp;
243         unsigned char address = client->address, status;
244         int ret = -1;
245
246         if (bp->i2c_bussel_reg != NULL)
247                 writeb(client->bus, bp->i2c_bussel_reg);
248
249         writeb(address, bp->i2c_control_regs + 0x1);
250         writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
251         if (wait_for_pin(bp, &status))
252                 goto out;
253
254         writeb(off, bp->i2c_control_regs + 0x1);
255         if (wait_for_pin(bp, &status) ||
256             (status & I2C_PCF_LRB) != 0)
257                 goto out;
258
259         writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
260
261         address |= 0x1; /* READ */
262
263         writeb(address, bp->i2c_control_regs + 0x1);
264         writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
265         if (wait_for_pin(bp, &status))
266                 goto out;
267
268         /* Set PIN back to one so the device sends the first
269          * byte.
270          */
271         (void) readb(bp->i2c_control_regs + 0x1);
272         if (wait_for_pin(bp, &status))
273                 goto out;
274
275         writeb(I2C_PCF_ESO | I2C_PCF_ENI, bp->i2c_control_regs + 0x0);
276         *byte = readb(bp->i2c_control_regs + 0x1);
277         if (wait_for_pin(bp, &status))
278                 goto out;
279
280         ret = 0;
281
282 out:
283         writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
284         (void) readb(bp->i2c_control_regs + 0x1);
285
286         return ret;
287 }
288
289 int bbc_i2c_write_buf(struct bbc_i2c_client *client,
290                       char *buf, int len, int off)
291 {
292         int ret = 0;
293
294         while (len > 0) {
295                 int err = bbc_i2c_writeb(client, *buf, off);
296
297                 if (err < 0) {
298                         ret = err;
299                         break;
300                 }
301
302                 len--;
303                 buf++;
304                 off++;
305         }
306         return ret;
307 }
308
309 int bbc_i2c_read_buf(struct bbc_i2c_client *client,
310                      char *buf, int len, int off)
311 {
312         int ret = 0;
313
314         while (len > 0) {
315                 int err = bbc_i2c_readb(client, buf, off);
316                 if (err < 0) {
317                         ret = err;
318                         break;
319                 }
320                 len--;
321                 buf++;
322                 off++;
323         }
324
325         return ret;
326 }
327
328 EXPORT_SYMBOL(bbc_i2c_getdev);
329 EXPORT_SYMBOL(bbc_i2c_attach);
330 EXPORT_SYMBOL(bbc_i2c_detach);
331 EXPORT_SYMBOL(bbc_i2c_writeb);
332 EXPORT_SYMBOL(bbc_i2c_readb);
333 EXPORT_SYMBOL(bbc_i2c_write_buf);
334 EXPORT_SYMBOL(bbc_i2c_read_buf);
335
336 static irqreturn_t bbc_i2c_interrupt(int irq, void *dev_id)
337 {
338         struct bbc_i2c_bus *bp = dev_id;
339
340         /* PIN going from set to clear is the only event which
341          * makes the i2c assert an interrupt.
342          */
343         if (bp->waiting &&
344             !(readb(bp->i2c_control_regs + 0x0) & I2C_PCF_PIN))
345                 wake_up_interruptible(&bp->wq);
346
347         return IRQ_HANDLED;
348 }
349
350 static void __init reset_one_i2c(struct bbc_i2c_bus *bp)
351 {
352         writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
353         writeb(bp->own, bp->i2c_control_regs + 0x1);
354         writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
355         writeb(bp->clock, bp->i2c_control_regs + 0x1);
356         writeb(I2C_PCF_IDLE, bp->i2c_control_regs + 0x0);
357 }
358
359 static int __init attach_one_i2c(struct linux_ebus_device *edev, int index)
360 {
361         struct bbc_i2c_bus *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
362         struct linux_ebus_child *echild;
363         int entry;
364
365         if (!bp)
366                 return -ENOMEM;
367         memset(bp, 0, sizeof(*bp));
368
369         bp->i2c_control_regs = ioremap(edev->resource[0].start, 0x2);
370         if (!bp->i2c_control_regs)
371                 goto fail;
372
373         if (edev->num_addrs == 2) {
374                 bp->i2c_bussel_reg = ioremap(edev->resource[1].start, 0x1);
375                 if (!bp->i2c_bussel_reg)
376                         goto fail;
377         }
378
379         bp->waiting = 0;
380         init_waitqueue_head(&bp->wq);
381         if (request_irq(edev->irqs[0], bbc_i2c_interrupt,
382                         IRQF_SHARED, "bbc_i2c", bp))
383                 goto fail;
384
385         bp->index = index;
386         bp->bus_edev = edev;
387
388         spin_lock_init(&bp->lock);
389         bp->next = all_bbc_i2c;
390         all_bbc_i2c = bp;
391
392         entry = 0;
393         for (echild = edev->children;
394              echild && entry < 8;
395              echild = echild->next, entry++) {
396                 bp->devs[entry].device = echild;
397                 bp->devs[entry].client_claimed = 0;
398         }
399
400         writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
401         bp->own = readb(bp->i2c_control_regs + 0x01);
402         writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
403         bp->clock = readb(bp->i2c_control_regs + 0x01);
404
405         printk(KERN_INFO "i2c-%d: Regs at %p, %d devices, own %02x, clock %02x.\n",
406                bp->index, bp->i2c_control_regs, entry, bp->own, bp->clock);
407
408         reset_one_i2c(bp);
409
410         return 0;
411
412 fail:
413         if (bp->i2c_bussel_reg)
414                 iounmap(bp->i2c_bussel_reg);
415         if (bp->i2c_control_regs)
416                 iounmap(bp->i2c_control_regs);
417         kfree(bp);
418         return -EINVAL;
419 }
420
421 static int __init bbc_present(void)
422 {
423         struct linux_ebus *ebus = NULL;
424         struct linux_ebus_device *edev = NULL;
425
426         for_each_ebus(ebus) {
427                 for_each_ebusdev(edev, ebus) {
428                         if (!strcmp(edev->prom_node->name, "bbc"))
429                                 return 1;
430                 }
431         }
432         return 0;
433 }
434
435 extern int bbc_envctrl_init(void);
436 extern void bbc_envctrl_cleanup(void);
437 static void bbc_i2c_cleanup(void);
438
439 static int __init bbc_i2c_init(void)
440 {
441         struct linux_ebus *ebus = NULL;
442         struct linux_ebus_device *edev = NULL;
443         int err, index = 0;
444
445         if ((tlb_type != cheetah && tlb_type != cheetah_plus) ||
446             !bbc_present())
447                 return -ENODEV;
448
449         for_each_ebus(ebus) {
450                 for_each_ebusdev(edev, ebus) {
451                         if (!strcmp(edev->prom_node->name, "i2c")) {
452                                 if (!attach_one_i2c(edev, index))
453                                         index++;
454                         }
455                 }
456         }
457
458         if (!index)
459                 return -ENODEV;
460
461         err = bbc_envctrl_init();
462         if (err)
463                 bbc_i2c_cleanup();
464         return err;
465 }
466
467 static void bbc_i2c_cleanup(void)
468 {
469         struct bbc_i2c_bus *bp = all_bbc_i2c;
470
471         bbc_envctrl_cleanup();
472
473         while (bp != NULL) {
474                 struct bbc_i2c_bus *next = bp->next;
475
476                 free_irq(bp->bus_edev->irqs[0], bp);
477
478                 if (bp->i2c_bussel_reg)
479                         iounmap(bp->i2c_bussel_reg);
480                 if (bp->i2c_control_regs)
481                         iounmap(bp->i2c_control_regs);
482
483                 kfree(bp);
484
485                 bp = next;
486         }
487         all_bbc_i2c = NULL;
488 }
489
490 module_init(bbc_i2c_init);
491 module_exit(bbc_i2c_cleanup);
492 MODULE_LICENSE("GPL");