Various typo fixes.
[linux-2.6.git] / drivers / sbus / char / vfc_i2c.c
1 /*
2  * drivers/sbus/char/vfc_i2c.c
3  *
4  * Driver for the Videopix Frame Grabber.
5  * 
6  * Functions that support the Phillips i2c(I squared C) bus on the vfc
7  *  Documentation for the Phillips I2C bus can be found on the 
8  *  phillips home page
9  *
10  * Copyright (C) 1996 Manish Vachharajani (mvachhar@noc.rutgers.edu)
11  *
12  */
13
14 /* NOTE: It seems to me that the documentation regarding the
15 pcd8584t/pcf8584 does not show the correct way to address the i2c bus.
16 Based on the information on the I2C bus itself and the remainder of
17 the Phillips docs the following algorithms appear to be correct.  I am
18 fairly certain that the flowcharts in the phillips docs are wrong. */
19
20
21 #include <linux/kernel.h>
22 #include <linux/string.h>
23 #include <linux/slab.h>
24 #include <linux/errno.h>
25 #include <linux/sched.h>
26 #include <linux/wait.h>
27 #include <linux/delay.h>
28 #include <asm/openprom.h>
29 #include <asm/oplib.h>
30 #include <asm/io.h>
31 #include <asm/system.h>
32 #include <asm/sbus.h>
33
34 #if 0 
35 #define VFC_I2C_DEBUG
36 #endif
37
38 #include "vfc.h"
39 #include "vfc_i2c.h"
40
41 #define WRITE_S1(__val) \
42         sbus_writel(__val, &dev->regs->i2c_s1)
43 #define WRITE_REG(__val) \
44         sbus_writel(__val, &dev->regs->i2c_reg)
45
46 #define VFC_I2C_READ (0x1)
47 #define VFC_I2C_WRITE (0x0)
48      
49 /****** 
50   The i2c bus controller chip on the VFC is a pcd8584t, but
51   phillips claims it doesn't exist.  As far as I can tell it is
52   identical to the PCF8584 so I treat it like it is the pcf8584.
53   
54   NOTE: The pcf8584 only cares
55   about the msb of the word you feed it 
56 *****/
57
58 int vfc_pcf8584_init(struct vfc_dev *dev) 
59 {
60         /* This will also choose register S0_OWN so we can set it. */
61         WRITE_S1(RESET);
62
63         /* The pcf8584 shifts this value left one bit and uses
64          * it as its i2c bus address.
65          */
66         WRITE_REG(0x55000000);
67
68         /* This will set the i2c bus at the same speed sun uses,
69          * and set another magic bit.
70          */
71         WRITE_S1(SELECT(S2));
72         WRITE_REG(0x14000000);
73         
74         /* Enable the serial port, idle the i2c bus and set
75          * the data reg to s0.
76          */
77         WRITE_S1(CLEAR_I2C_BUS);
78         udelay(100);
79         return 0;
80 }
81
82 void vfc_i2c_delay_no_busy(struct vfc_dev *dev, unsigned long usecs) 
83 {
84         schedule_timeout_uninterruptible(usecs_to_jiffies(usecs));
85 }
86
87 void inline vfc_i2c_delay(struct vfc_dev *dev) 
88
89         vfc_i2c_delay_no_busy(dev, 100);
90 }
91
92 int vfc_init_i2c_bus(struct vfc_dev *dev)
93 {
94         WRITE_S1(ENABLE_SERIAL | SELECT(S0) | ACK);
95         vfc_i2c_reset_bus(dev);
96         return 0;
97 }
98
99 int vfc_i2c_reset_bus(struct vfc_dev *dev) 
100 {
101         VFC_I2C_DEBUG_PRINTK((KERN_DEBUG "vfc%d: Resetting the i2c bus\n",
102                               dev->instance));
103         if(dev == NULL)
104                 return -EINVAL;
105         if(dev->regs == NULL)
106                 return -EINVAL;
107         WRITE_S1(SEND_I2C_STOP);
108         WRITE_S1(SEND_I2C_STOP | ACK);
109         vfc_i2c_delay(dev);
110         WRITE_S1(CLEAR_I2C_BUS);
111         VFC_I2C_DEBUG_PRINTK((KERN_DEBUG "vfc%d: I2C status %x\n",
112                               dev->instance,
113                               sbus_readl(&dev->regs->i2c_s1)));
114         return 0;
115 }
116
117 int vfc_i2c_wait_for_bus(struct vfc_dev *dev) 
118 {
119         int timeout = 1000; 
120
121         while(!(sbus_readl(&dev->regs->i2c_s1) & BB)) {
122                 if(!(timeout--))
123                         return -ETIMEDOUT;
124                 vfc_i2c_delay(dev);
125         }
126         return 0;
127 }
128
129 int vfc_i2c_wait_for_pin(struct vfc_dev *dev, int ack)
130 {
131         int timeout = 1000; 
132         int s1;
133
134         while ((s1 = sbus_readl(&dev->regs->i2c_s1)) & PIN) {
135                 if (!(timeout--))
136                         return -ETIMEDOUT;
137                 vfc_i2c_delay(dev);
138         }
139         if (ack == VFC_I2C_ACK_CHECK) {
140                 if(s1 & LRB)
141                         return -EIO; 
142         }
143         return 0;
144 }
145
146 #define SHIFT(a) ((a) << 24)
147 int vfc_i2c_xmit_addr(struct vfc_dev *dev, unsigned char addr, char mode) 
148
149         int ret, raddr;
150 #if 1
151         WRITE_S1(SEND_I2C_STOP | ACK);
152         WRITE_S1(SELECT(S0) | ENABLE_SERIAL);
153         vfc_i2c_delay(dev);
154 #endif
155
156         switch(mode) {
157         case VFC_I2C_READ:
158                 raddr = SHIFT(((unsigned int)addr | 0x1));
159                 WRITE_REG(raddr);
160                 VFC_I2C_DEBUG_PRINTK(("vfc%d: receiving from i2c addr 0x%x\n",
161                                       dev->instance, addr | 0x1));
162                 break;
163         case VFC_I2C_WRITE:
164                 raddr = SHIFT((unsigned int)addr & ~0x1);
165                 WRITE_REG(raddr);
166                 VFC_I2C_DEBUG_PRINTK(("vfc%d: sending to i2c addr 0x%x\n",
167                                       dev->instance, addr & ~0x1));
168                 break;
169         default:
170                 return -EINVAL;
171         };
172
173         WRITE_S1(SEND_I2C_START);
174         vfc_i2c_delay(dev);
175         ret = vfc_i2c_wait_for_pin(dev,VFC_I2C_ACK_CHECK); /* We wait
176                                                               for the
177                                                               i2c send
178                                                               to finish
179                                                               here but
180                                                               Sun
181                                                               doesn't,
182                                                               hmm */
183         if (ret) {
184                 printk(KERN_ERR "vfc%d: VFC xmit addr timed out or no ack\n",
185                        dev->instance);
186                 return ret;
187         } else if (mode == VFC_I2C_READ) {
188                 if ((ret = sbus_readl(&dev->regs->i2c_reg) & 0xff000000) != raddr) {
189                         printk(KERN_WARNING 
190                                "vfc%d: returned slave address "
191                                "mismatch(%x,%x)\n",
192                                dev->instance, raddr, ret);
193                 }
194         }       
195         return 0;
196 }
197
198 int vfc_i2c_xmit_byte(struct vfc_dev *dev,unsigned char *byte) 
199 {
200         int ret;
201         u32 val = SHIFT((unsigned int)*byte);
202
203         WRITE_REG(val);
204
205         ret = vfc_i2c_wait_for_pin(dev, VFC_I2C_ACK_CHECK); 
206         switch(ret) {
207         case -ETIMEDOUT: 
208                 printk(KERN_ERR "vfc%d: VFC xmit byte timed out or no ack\n",
209                        dev->instance);
210                 break;
211         case -EIO:
212                 ret = XMIT_LAST_BYTE;
213                 break;
214         default:
215                 break;
216         };
217
218         return ret;
219 }
220
221 int vfc_i2c_recv_byte(struct vfc_dev *dev, unsigned char *byte, int last) 
222 {
223         int ret;
224
225         if (last) {
226                 WRITE_REG(NEGATIVE_ACK);
227                 VFC_I2C_DEBUG_PRINTK(("vfc%d: sending negative ack\n",
228                                       dev->instance));
229         } else {
230                 WRITE_S1(ACK);
231         }
232
233         ret = vfc_i2c_wait_for_pin(dev, VFC_I2C_NO_ACK_CHECK);
234         if(ret) {
235                 printk(KERN_ERR "vfc%d: "
236                        "VFC recv byte timed out\n",
237                        dev->instance);
238         }
239         *byte = (sbus_readl(&dev->regs->i2c_reg)) >> 24;
240         return ret;
241 }
242
243 int vfc_i2c_recvbuf(struct vfc_dev *dev, unsigned char addr,
244                     char *buf, int count)
245 {
246         int ret, last;
247
248         if(!(count && buf && dev && dev->regs) )
249                 return -EINVAL;
250
251         if ((ret = vfc_i2c_wait_for_bus(dev))) {
252                 printk(KERN_ERR "vfc%d: VFC I2C bus busy\n", dev->instance);
253                 return ret;
254         }
255
256         if ((ret = vfc_i2c_xmit_addr(dev, addr, VFC_I2C_READ))) {
257                 WRITE_S1(SEND_I2C_STOP);
258                 vfc_i2c_delay(dev);
259                 return ret;
260         }
261         
262         last = 0;
263         while (count--) {
264                 if (!count)
265                         last = 1;
266                 if ((ret = vfc_i2c_recv_byte(dev, buf, last))) {
267                         printk(KERN_ERR "vfc%d: "
268                                "VFC error while receiving byte\n",
269                                dev->instance);
270                         WRITE_S1(SEND_I2C_STOP);
271                         ret = -EINVAL;
272                 }
273                 buf++;
274         }
275         WRITE_S1(SEND_I2C_STOP | ACK);
276         vfc_i2c_delay(dev);
277         return ret;
278 }
279
280 int vfc_i2c_sendbuf(struct vfc_dev *dev, unsigned char addr, 
281                     char *buf, int count) 
282 {
283         int ret;
284         
285         if (!(buf && dev && dev->regs))
286                 return -EINVAL;
287         
288         if ((ret = vfc_i2c_wait_for_bus(dev))) {
289                 printk(KERN_ERR "vfc%d: VFC I2C bus busy\n", dev->instance);
290                 return ret;
291         }
292         
293         if ((ret = vfc_i2c_xmit_addr(dev, addr, VFC_I2C_WRITE))) {
294                 WRITE_S1(SEND_I2C_STOP);
295                 vfc_i2c_delay(dev);
296                 return ret;
297         }
298         
299         while(count--) {
300                 ret = vfc_i2c_xmit_byte(dev, buf);
301                 switch(ret) {
302                 case XMIT_LAST_BYTE:
303                         VFC_I2C_DEBUG_PRINTK(("vfc%d: "
304                                               "Receiver ended transmission with "
305                                               " %d bytes remaining\n",
306                                               dev->instance, count));
307                         ret = 0;
308                         goto done;
309                         break;
310                 case 0:
311                         break;
312                 default:
313                         printk(KERN_ERR "vfc%d: "
314                                "VFC error while sending byte\n", dev->instance);
315                         break;
316                 };
317
318                 buf++;
319         }
320 done:
321         WRITE_S1(SEND_I2C_STOP | ACK);
322         vfc_i2c_delay(dev);
323         return ret;
324 }
325
326
327
328
329
330
331
332
333