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

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