i2c-algo-pcf: Add adapter hooks around xfer begin and end
[linux-2.6.git] / drivers / i2c / algos / i2c-algo-sgi.c
1 /*
2  * i2c-algo-sgi.c: i2c driver algorithm used by the VINO (SGI Indy) and
3  * MACE (SGI O2) chips.
4  *
5  * This file is subject to the terms and conditions of the GNU General Public
6  * License version 2 as published by the Free Software Foundation.
7  *
8  * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
9  */
10
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/errno.h>
15 #include <linux/delay.h>
16
17 #include <linux/i2c.h>
18 #include <linux/i2c-algo-sgi.h>
19
20
21 #define SGI_I2C_FORCE_IDLE      (0 << 0)
22 #define SGI_I2C_NOT_IDLE        (1 << 0)
23 #define SGI_I2C_WRITE           (0 << 1)
24 #define SGI_I2C_READ            (1 << 1)
25 #define SGI_I2C_RELEASE_BUS     (0 << 2)
26 #define SGI_I2C_HOLD_BUS        (1 << 2)
27 #define SGI_I2C_XFER_DONE       (0 << 4)
28 #define SGI_I2C_XFER_BUSY       (1 << 4)
29 #define SGI_I2C_ACK             (0 << 5)
30 #define SGI_I2C_NACK            (1 << 5)
31 #define SGI_I2C_BUS_OK          (0 << 7)
32 #define SGI_I2C_BUS_ERR         (1 << 7)
33
34 #define get_control()           adap->getctrl(adap->data)
35 #define set_control(val)        adap->setctrl(adap->data, val)
36 #define read_data()             adap->rdata(adap->data)
37 #define write_data(val)         adap->wdata(adap->data, val)
38
39
40 static int wait_xfer_done(struct i2c_algo_sgi_data *adap)
41 {
42         int i;
43
44         for (i = 0; i < adap->xfer_timeout; i++) {
45                 if ((get_control() & SGI_I2C_XFER_BUSY) == 0)
46                         return 0;
47                 udelay(1);
48         }
49
50         return -ETIMEDOUT;
51 }
52
53 static int wait_ack(struct i2c_algo_sgi_data *adap)
54 {
55         int i;
56
57         if (wait_xfer_done(adap))
58                 return -ETIMEDOUT;
59         for (i = 0; i < adap->ack_timeout; i++) {
60                 if ((get_control() & SGI_I2C_NACK) == 0)
61                         return 0;
62                 udelay(1);
63         }
64
65         return -ETIMEDOUT;
66 }
67
68 static int force_idle(struct i2c_algo_sgi_data *adap)
69 {
70         int i;
71
72         set_control(SGI_I2C_FORCE_IDLE);
73         for (i = 0; i < adap->xfer_timeout; i++) {
74                 if ((get_control() & SGI_I2C_NOT_IDLE) == 0)
75                         goto out;
76                 udelay(1);
77         }
78         return -ETIMEDOUT;
79 out:
80         if (get_control() & SGI_I2C_BUS_ERR)
81                 return -EIO;
82         return 0;
83 }
84
85 static int do_address(struct i2c_algo_sgi_data *adap, unsigned int addr,
86                       int rd)
87 {
88         if (rd)
89                 set_control(SGI_I2C_NOT_IDLE);
90         /* Check if bus is idle, eventually force it to do so */
91         if (get_control() & SGI_I2C_NOT_IDLE)
92                 if (force_idle(adap))
93                         return -EIO;
94         /* Write out the i2c chip address and specify operation */
95         set_control(SGI_I2C_HOLD_BUS | SGI_I2C_WRITE | SGI_I2C_NOT_IDLE);
96         if (rd)
97                 addr |= 1;
98         write_data(addr);
99         if (wait_ack(adap))
100                 return -EIO;
101         return 0;
102 }
103
104 static int i2c_read(struct i2c_algo_sgi_data *adap, unsigned char *buf,
105                     unsigned int len)
106 {
107         int i;
108
109         set_control(SGI_I2C_HOLD_BUS | SGI_I2C_READ | SGI_I2C_NOT_IDLE);
110         for (i = 0; i < len; i++) {
111                 if (wait_xfer_done(adap))
112                         return -EIO;
113                 buf[i] = read_data();
114         }
115         set_control(SGI_I2C_RELEASE_BUS | SGI_I2C_FORCE_IDLE);
116
117         return 0;
118
119 }
120
121 static int i2c_write(struct i2c_algo_sgi_data *adap, unsigned char *buf,
122                      unsigned int len)
123 {
124         int i;
125
126         /* We are already in write state */
127         for (i = 0; i < len; i++) {
128                 write_data(buf[i]);
129                 if (wait_ack(adap))
130                         return -EIO;
131         }
132         return 0;
133 }
134
135 static int sgi_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs,
136                     int num)
137 {
138         struct i2c_algo_sgi_data *adap = i2c_adap->algo_data;
139         struct i2c_msg *p;
140         int i, err = 0;
141
142         for (i = 0; !err && i < num; i++) {
143                 p = &msgs[i];
144                 err = do_address(adap, p->addr, p->flags & I2C_M_RD);
145                 if (err || !p->len)
146                         continue;
147                 if (p->flags & I2C_M_RD)
148                         err = i2c_read(adap, p->buf, p->len);
149                 else
150                         err = i2c_write(adap, p->buf, p->len);
151         }
152
153         return (err < 0) ? err : i;
154 }
155
156 static u32 sgi_func(struct i2c_adapter *adap)
157 {
158         return I2C_FUNC_SMBUS_EMUL;
159 }
160
161 static const struct i2c_algorithm sgi_algo = {
162         .master_xfer    = sgi_xfer,
163         .functionality  = sgi_func,
164 };
165
166 /*
167  * registering functions to load algorithms at runtime
168  */
169 int i2c_sgi_add_bus(struct i2c_adapter *adap)
170 {
171         adap->algo = &sgi_algo;
172
173         return i2c_add_adapter(adap);
174 }
175 EXPORT_SYMBOL(i2c_sgi_add_bus);
176
177 MODULE_AUTHOR("Ladislav Michl <ladis@linux-mips.org>");
178 MODULE_DESCRIPTION("I2C-Bus SGI algorithm");
179 MODULE_LICENSE("GPL");