git.oblomov.eu Git - linux-2.6/blob - 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 algorithims apper 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_wakeup(struct vfc_dev *dev)
  83 {
  84         /* Used to profile code and eliminate too many delays */
  85         VFC_I2C_DEBUG_PRINTK(("vfc%d: Delaying\n", dev->instance));
  86         wake_up(&dev->poll_wait);
  87 }
  88
  89 void vfc_i2c_delay_no_busy(struct vfc_dev *dev, unsigned long usecs)
  90 {
  91         DEFINE_WAIT(wait);
  92         init_timer(&dev->poll_timer);
  93         dev->poll_timer.expires = jiffies + usecs_to_jiffies(usecs);
  94         dev->poll_timer.data=(unsigned long)dev;
  95         dev->poll_timer.function=(void *)(unsigned long)vfc_i2c_delay_wakeup;
  96         add_timer(&dev->poll_timer);
  97         prepare_to_wait(&dev->poll_wait, &wait, TASK_UNINTERRUPTIBLE);
  98         schedule();
  99         del_timer(&dev->poll_timer);
 100         finish_wait(&dev->poll_wait, &wait);
 101 }
 102
 103 void inline vfc_i2c_delay(struct vfc_dev *dev)
 104 {
 105         vfc_i2c_delay_no_busy(dev, 100);
 106 }
 107
 108 int vfc_init_i2c_bus(struct vfc_dev *dev)
 109 {
 110         WRITE_S1(ENABLE_SERIAL | SELECT(S0) | ACK);
 111         vfc_i2c_reset_bus(dev);
 112         return 0;
 113 }
 114
 115 int vfc_i2c_reset_bus(struct vfc_dev *dev)
 116 {
 117         VFC_I2C_DEBUG_PRINTK((KERN_DEBUG "vfc%d: Resetting the i2c bus\n",
 118                               dev->instance));
 119         if(dev == NULL)
 120                 return -EINVAL;
 121         if(dev->regs == NULL)
 122                 return -EINVAL;
 123         WRITE_S1(SEND_I2C_STOP);
 124         WRITE_S1(SEND_I2C_STOP | ACK);
 125         vfc_i2c_delay(dev);
 126         WRITE_S1(CLEAR_I2C_BUS);
 127         VFC_I2C_DEBUG_PRINTK((KERN_DEBUG "vfc%d: I2C status %x\n",
 128                               dev->instance,
 129                               sbus_readl(&dev->regs->i2c_s1)));
 130         return 0;
 131 }
 132
 133 int vfc_i2c_wait_for_bus(struct vfc_dev *dev)
 134 {
 135         int timeout = 1000;
 136
 137         while(!(sbus_readl(&dev->regs->i2c_s1) & BB)) {
 138                 if(!(timeout--))
 139                         return -ETIMEDOUT;
 140                 vfc_i2c_delay(dev);
 141         }
 142         return 0;
 143 }
 144
 145 int vfc_i2c_wait_for_pin(struct vfc_dev *dev, int ack)
 146 {
 147         int timeout = 1000;
 148         int s1;
 149
 150         while ((s1 = sbus_readl(&dev->regs->i2c_s1)) & PIN) {
 151                 if (!(timeout--))
 152                         return -ETIMEDOUT;
 153                 vfc_i2c_delay(dev);
 154         }
 155         if (ack == VFC_I2C_ACK_CHECK) {
 156                 if(s1 & LRB)
 157                         return -EIO;
 158         }
 159         return 0;
 160 }
 161
 162 #define SHIFT(a) ((a) << 24)
 163 int vfc_i2c_xmit_addr(struct vfc_dev *dev, unsigned char addr, char mode)
 164 {
 165         int ret, raddr;
 166 #if 1
 167         WRITE_S1(SEND_I2C_STOP | ACK);
 168         WRITE_S1(SELECT(S0) | ENABLE_SERIAL);
 169         vfc_i2c_delay(dev);
 170 #endif
 171
 172         switch(mode) {
 173         case VFC_I2C_READ:
 174                 raddr = SHIFT(((unsigned int)addr | 0x1));
 175                 WRITE_REG(raddr);
 176                 VFC_I2C_DEBUG_PRINTK(("vfc%d: receiving from i2c addr 0x%x\n",
 177                                       dev->instance, addr | 0x1));
 178                 break;
 179         case VFC_I2C_WRITE:
 180                 raddr = SHIFT((unsigned int)addr & ~0x1);
 181                 WRITE_REG(raddr);
 182                 VFC_I2C_DEBUG_PRINTK(("vfc%d: sending to i2c addr 0x%x\n",
 183                                       dev->instance, addr & ~0x1));
 184                 break;
 185         default:
 186                 return -EINVAL;
 187         };
 188
 189         WRITE_S1(SEND_I2C_START);
 190         vfc_i2c_delay(dev);
 191         ret = vfc_i2c_wait_for_pin(dev,VFC_I2C_ACK_CHECK); /* We wait
 192                                                               for the
 193                                                               i2c send
 194                                                               to finish
 195                                                               here but
 196                                                               Sun
 197                                                               doesn't,
 198                                                               hmm */
 199         if (ret) {
 200                 printk(KERN_ERR "vfc%d: VFC xmit addr timed out or no ack\n",
 201                        dev->instance);
 202                 return ret;
 203         } else if (mode == VFC_I2C_READ) {
 204                 if ((ret = sbus_readl(&dev->regs->i2c_reg) & 0xff000000) != raddr) {
 205                         printk(KERN_WARNING
 206                                "vfc%d: returned slave address "
 207                                "mismatch(%x,%x)\n",
 208                                dev->instance, raddr, ret);
 209                 }
 210         }
 211         return 0;
 212 }
 213
 214 int vfc_i2c_xmit_byte(struct vfc_dev *dev,unsigned char *byte)
 215 {
 216         int ret;
 217         u32 val = SHIFT((unsigned int)*byte);
 218
 219         WRITE_REG(val);
 220
 221         ret = vfc_i2c_wait_for_pin(dev, VFC_I2C_ACK_CHECK);
 222         switch(ret) {
 223         case -ETIMEDOUT:
 224                 printk(KERN_ERR "vfc%d: VFC xmit byte timed out or no ack\n",
 225                        dev->instance);
 226                 break;
 227         case -EIO:
 228                 ret = XMIT_LAST_BYTE;
 229                 break;
 230         default:
 231                 break;
 232         };
 233
 234         return ret;
 235 }
 236
 237 int vfc_i2c_recv_byte(struct vfc_dev *dev, unsigned char *byte, int last)
 238 {
 239         int ret;
 240
 241         if (last) {
 242                 WRITE_REG(NEGATIVE_ACK);
 243                 VFC_I2C_DEBUG_PRINTK(("vfc%d: sending negative ack\n",
 244                                       dev->instance));
 245         } else {
 246                 WRITE_S1(ACK);
 247         }
 248
 249         ret = vfc_i2c_wait_for_pin(dev, VFC_I2C_NO_ACK_CHECK);
 250         if(ret) {
 251                 printk(KERN_ERR "vfc%d: "
 252                        "VFC recv byte timed out\n",
 253                        dev->instance);
 254         }
 255         *byte = (sbus_readl(&dev->regs->i2c_reg)) >> 24;
 256         return ret;
 257 }
 258
 259 int vfc_i2c_recvbuf(struct vfc_dev *dev, unsigned char addr,
 260                     char *buf, int count)
 261 {
 262         int ret, last;
 263
 264         if(!(count && buf && dev && dev->regs) )
 265                 return -EINVAL;
 266
 267         if ((ret = vfc_i2c_wait_for_bus(dev))) {
 268                 printk(KERN_ERR "vfc%d: VFC I2C bus busy\n", dev->instance);
 269                 return ret;
 270         }
 271
 272         if ((ret = vfc_i2c_xmit_addr(dev, addr, VFC_I2C_READ))) {
 273                 WRITE_S1(SEND_I2C_STOP);
 274                 vfc_i2c_delay(dev);
 275                 return ret;
 276         }
 277
 278         last = 0;
 279         while (count--) {
 280                 if (!count)
 281                         last = 1;
 282                 if ((ret = vfc_i2c_recv_byte(dev, buf, last))) {
 283                         printk(KERN_ERR "vfc%d: "
 284                                "VFC error while receiving byte\n",
 285                                dev->instance);
 286                         WRITE_S1(SEND_I2C_STOP);
 287                         ret = -EINVAL;
 288                 }
 289                 buf++;
 290         }
 291         WRITE_S1(SEND_I2C_STOP | ACK);
 292         vfc_i2c_delay(dev);
 293         return ret;
 294 }
 295
 296 int vfc_i2c_sendbuf(struct vfc_dev *dev, unsigned char addr,
 297                     char *buf, int count)
 298 {
 299         int ret;
 300
 301         if (!(buf && dev && dev->regs))
 302                 return -EINVAL;
 303
 304         if ((ret = vfc_i2c_wait_for_bus(dev))) {
 305                 printk(KERN_ERR "vfc%d: VFC I2C bus busy\n", dev->instance);
 306                 return ret;
 307         }
 308
 309         if ((ret = vfc_i2c_xmit_addr(dev, addr, VFC_I2C_WRITE))) {
 310                 WRITE_S1(SEND_I2C_STOP);
 311                 vfc_i2c_delay(dev);
 312                 return ret;
 313         }
 314
 315         while(count--) {
 316                 ret = vfc_i2c_xmit_byte(dev, buf);
 317                 switch(ret) {
 318                 case XMIT_LAST_BYTE:
 319                         VFC_I2C_DEBUG_PRINTK(("vfc%d: "
 320                                               "Receiver ended transmission with "
 321                                               " %d bytes remaining\n",
 322                                               dev->instance, count));
 323                         ret = 0;
 324                         goto done;
 325                         break;
 326                 case 0:
 327                         break;
 328                 default:
 329                         printk(KERN_ERR "vfc%d: "
 330                                "VFC error while sending byte\n", dev->instance);
 331                         break;
 332                 };
 333
 334                 buf++;
 335         }
 336 done:
 337         WRITE_S1(SEND_I2C_STOP | ACK);
 338         vfc_i2c_delay(dev);
 339         return ret;
 340 }
 341
 342
 343
 344
 345
 346
 347
 348
 349