workbench/devs/AHI/Drivers/Envy24/I2C.c

   1 /*
   2     Copyright © 2004-2014, Davy Wentzler. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <proto/exec.h>
   7 #include "I2C.h"
   8 #include "DriverData.h"
   9
  10
  11 static int I2C_bit_sendbytes(struct CardData *card, struct I2C *device, unsigned char *bytes, int count);
  12 static int I2C_bit_readbytes(struct CardData *card, struct I2C *device, unsigned char *bytes, int count);
  13 static int I2C_bit_probeaddr(struct CardData *card, unsigned short addr);
  14
  15
  16 struct I2C *AllocI2C(unsigned char addr)
  17 {
  18         struct I2C *device;
  19
  20         device = (struct I2C *) AllocVec(sizeof(struct I2C), MEMF_ANY);
  21         if (device == NULL)
  22                 return NULL;
  23
  24         device->addr = addr;
  25    device->flags = 0;
  26
  27         return device;
  28 }
  29
  30
  31 void FreeI2C(struct I2C *device)
  32 {
  33         FreeVec(device);
  34 }
  35
  36
  37 int WriteBytesI2C(struct CardData *card, struct I2C *device, unsigned char *bytes, int count)
  38 {
  39         return I2C_bit_sendbytes(card, device, bytes, count);
  40 }
  41
  42
  43 int ReadBytesI2C(struct CardData *card, struct I2C *device, unsigned char *bytes, int count)
  44 {
  45         return I2C_bit_readbytes(card, device, bytes, count);
  46 }
  47
  48
  49 int ProbeAddressI2C(struct CardData *card, unsigned short addr)
  50 {
  51         return I2C_bit_probeaddr(card, addr);
  52 }
  53
  54
  55
  56
  57 // Let the specific chip set up GPIO dir and mask for example
  58 // before we start feeding bits and bytes...
  59 static inline void I2C_bit_hw_start(struct CardData *card)
  60 {
  61         if (card->bit_ops->Start)
  62                 card->bit_ops->Start(card);
  63 }
  64
  65
  66 static inline void I2C_bit_hw_stop(struct CardData *card)
  67 {
  68         if (card->bit_ops->Stop)
  69                 card->bit_ops->Stop(card);
  70 }
  71
  72
  73 static void I2C_bit_direction(struct CardData *card, int clock, int data)
  74 {
  75         if (card->bit_ops->SetDir_CLK_SDA)
  76                 card->bit_ops->SetDir_CLK_SDA(card, clock, data);
  77 }
  78
  79
  80 static void I2C_bit_set(struct CardData *card, int clock, int data)
  81 {
  82         card->bit_ops->Write_CLK_SDA(card, clock, data);
  83 }
  84
  85
  86 static int I2C_bit_data(struct CardData *card, int ack)
  87 {
  88         return card->bit_ops->GetData(card, ack);
  89 }
  90
  91
  92
  93 // See page 17 and 18 of the I2C spec, version 2.1 January 2000,
  94 // especially, figure 18 (START byte procedure)
  95 static void I2C_bit_start(struct CardData *card)
  96 {
  97    // chip-specific init
  98         I2C_bit_hw_start(card);
  99
 100    // we're gonna write to both
 101    I2C_bit_direction(card, 1, 1);
 102         I2C_bit_set(card, 1, 1);
 103         I2C_bit_set(card, 1, 0);
 104         I2C_bit_set(card, 0, 0);
 105 }
 106
 107
 108 // see figure 10 and 19
 109 static void I2C_bit_stop(struct CardData *card)
 110 {
 111         I2C_bit_set(card, 0, 0);
 112         I2C_bit_set(card, 1, 0);
 113         I2C_bit_set(card, 1, 1);
 114
 115    // chip-specific stop
 116         I2C_bit_hw_stop(card);
 117 }
 118
 119
 120 // data gets send on high clock
 121 static void I2C_bit_send(struct CardData *card, int data)
 122 {
 123         I2C_bit_set(card, 0, data);
 124         I2C_bit_set(card, 1, data);
 125         I2C_bit_set(card, 0, data);
 126 }
 127
 128
 129 static int I2C_bit_ack(struct CardData *card)
 130 {
 131         int ack;
 132
 133    // figure 7
 134         I2C_bit_set(card, 0, 1);
 135         I2C_bit_set(card, 1, 1);
 136
 137    // then read the ack bit
 138         I2C_bit_direction(card, 1, 0);
 139         ack = I2C_bit_data(card, 1);
 140
 141
 142         I2C_bit_direction(card, 1, 1);
 143         I2C_bit_set(card, 0, 1);
 144
 145         return ack;
 146 }
 147
 148
 149 static int I2C_bit_sendbyte(struct CardData *card, unsigned char data)
 150 {
 151         int i, err;
 152
 153    // send the byte bit for bit, MSB first
 154         for (i = 7; i >= 0; i--)
 155                 I2C_bit_send(card, (data & (1 << i)));
 156
 157         if ((err = I2C_bit_ack(card)) < 0)
 158                 return err;
 159
 160         return 0;
 161 }
 162
 163
 164 static int I2C_bit_readbyte(struct CardData *card, int last)
 165 {
 166         int i;
 167         unsigned char data = 0;
 168
 169         I2C_bit_set(card, 0, 1);
 170         I2C_bit_direction(card, 1, 0);
 171
 172         for (i = 7; i >= 0; i--) {
 173                 I2C_bit_set(card, 1, 1);
 174
 175                 if (I2C_bit_data(card, 0))
 176                         data |= (1 << i);
 177
 178       I2C_bit_set(card, 0, 1);
 179         }
 180
 181         I2C_bit_direction(card, 1, 1);
 182         I2C_bit_send(card, last);
 183
 184         return data;
 185 }
 186
 187
 188 static int I2C_bit_sendbytes(struct CardData *card, struct I2C *device, unsigned char *bytes, int count)
 189 {
 190         int err, res = 0;
 191
 192         I2C_bit_start(card);
 193
 194    // first send address of the I2C chip we want to reach
 195         if ((err = I2C_bit_sendbyte(card, device->addr << 1)) < 0) {
 196                 I2C_bit_hw_stop(card);
 197                 return err;
 198         }
 199
 200    // then send all consecutive bytes with an 'ack' in between
 201    while (count-- > 0) {
 202                 if ((err = I2C_bit_sendbyte(card, *bytes++)) < 0) {
 203                         I2C_bit_hw_stop(card);
 204                         return err;
 205                 }
 206
 207         res++;
 208            }
 209
 210         I2C_bit_stop(card);
 211
 212         return res;
 213 }
 214
 215
 216 static int I2C_bit_readbytes(struct CardData *card, struct I2C *device, unsigned char *bytes, int count)
 217 {
 218         int err, res = 0;
 219
 220         I2C_bit_start(card);
 221
 222    if ((err = I2C_bit_sendbyte(card, (device->addr << 1) | 1)) < 0) {
 223                 I2C_bit_hw_stop(card);
 224                 return err;
 225            }
 226
 227         while (count-- > 0) {
 228                 if ((err = I2C_bit_readbyte(card, count == 0)) < 0) {
 229                         I2C_bit_hw_stop(card);
 230                         return err;
 231                    }
 232
 233         *bytes++ = (unsigned char)err;
 234                 res++;
 235            }
 236
 237         I2C_bit_stop(card);
 238
 239         return res;
 240 }
 241
 242
 243 static int I2C_bit_probeaddr(struct CardData *card, unsigned short addr)
 244 {
 245         int err;
 246
 247         I2C_bit_start(card);
 248         err = I2C_bit_sendbyte(card, addr << 1);
 249         I2C_bit_stop(card);
 250
 251         return err;
 252 }
 253