firmware/drivers/generic_i2c.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 by Linus Nielsen Feltzing
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "config.h"
  22 #include "cpu.h"
  23 #include <stdbool.h>
  24 #include <stdlib.h>
  25 #include "debug.h"
  26 #include "generic_i2c.h"
  27
  28 #define MAX_I2C_INTERFACES 5
  29
  30 static int i2c_num_ifs = 0;
  31 static const struct i2c_interface *i2c_if[MAX_I2C_INTERFACES];
  32
  33 static void i2c_start(const struct i2c_interface *iface)
  34 {
  35     iface->sda_output();
  36
  37     iface->sda_hi();
  38     iface->scl_hi();
  39     iface->sda_lo();
  40     iface->delay_hd_sta();
  41     iface->scl_lo();
  42 }
  43
  44 static void i2c_stop(const struct i2c_interface *iface)
  45 {
  46     iface->sda_output();
  47
  48     iface->sda_lo();
  49     iface->scl_hi();
  50     iface->delay_su_sto();
  51     iface->sda_hi();
  52 }
  53
  54 static void i2c_ack(const struct i2c_interface *iface, bool ack)
  55 {
  56     iface->sda_output();
  57     iface->scl_lo();
  58     if ( ack )
  59         iface->sda_lo();
  60     else
  61         iface->sda_hi();
  62
  63     iface->delay_su_dat();
  64     iface->scl_hi();
  65     iface->delay_thigh();
  66     iface->scl_lo();
  67 }
  68
  69 static int i2c_getack(const struct i2c_interface *iface)
  70 {
  71     int ret = 1;
  72
  73     iface->sda_input();
  74     iface->delay_su_dat();
  75     iface->scl_hi();
  76
  77     if (iface->sda())
  78         ret = 0; /* ack failed */
  79
  80     iface->delay_thigh();
  81     iface->scl_lo();
  82     iface->sda_hi();
  83     iface->sda_output();
  84     iface->delay_hd_dat();
  85     return ret;
  86 }
  87
  88 static unsigned char i2c_inb(const struct i2c_interface *iface, bool ack)
  89 {
  90     int i;
  91     unsigned char byte = 0;
  92
  93     iface->sda_input();
  94
  95     /* clock in each bit, MSB first */
  96     for ( i=0x80; i; i>>=1 ) {
  97         iface->scl_hi();
  98         iface->delay_thigh();
  99         if (iface->sda())
 100             byte |= i;
 101         iface->scl_lo();
 102         iface->delay_hd_dat();
 103     }
 104
 105     i2c_ack(iface, ack);
 106
 107     return byte;
 108 }
 109
 110 static int i2c_outb(const struct i2c_interface *iface, unsigned char byte)
 111 {
 112     int i;
 113
 114     iface->sda_output();
 115
 116     /* clock out each bit, MSB first */
 117     for (i=0x80; i; i>>=1) {
 118         if (i & byte)
 119             iface->sda_hi();
 120         else
 121             iface->sda_lo();
 122         iface->delay_su_dat();
 123         iface->scl_hi();
 124         iface->delay_thigh();
 125         iface->scl_lo();
 126         iface->delay_hd_dat();
 127    }
 128
 129    iface->sda_hi();
 130
 131    return i2c_getack(iface);
 132 }
 133
 134 int i2c_write_data(int bus_index, int bus_address, int address,
 135                    const unsigned char* buf, int count)
 136 {
 137     int i;
 138     int ret = 0;
 139     const struct i2c_interface *iface = i2c_if[bus_index];
 140
 141     i2c_start(iface);
 142     if (!i2c_outb(iface, bus_address & 0xfe))
 143     {
 144         ret = -2;
 145         goto end;
 146     }
 147
 148     if (address != -1)
 149     {
 150         if (!i2c_outb(iface, address))
 151         {
 152             ret = -3;
 153             goto end;
 154         }
 155     }
 156
 157     for(i = 0;i < count;i++)
 158     {
 159         if (!i2c_outb(iface, buf[i]))
 160         {
 161             ret = -4;
 162             break;
 163         }
 164     }
 165
 166 end:
 167     i2c_stop(iface);
 168     return ret;
 169 }
 170
 171 int i2c_read_data(int bus_index, int bus_address, int address,
 172                   unsigned char* buf, int count)
 173 {
 174     int i;
 175     int ret = 0;
 176     const struct i2c_interface *iface = i2c_if[bus_index];
 177
 178     if (address != -1)
 179     {
 180         i2c_start(iface);
 181         if (!i2c_outb(iface, bus_address & 0xfe))
 182         {
 183             ret = -2;
 184             goto end;
 185         }
 186         if (!i2c_outb(iface, address))
 187         {
 188             ret = -3;
 189             goto end;
 190         }
 191     }
 192
 193     i2c_start(iface);
 194     if (!i2c_outb(iface, bus_address | 1))
 195     {
 196         ret = -4;
 197         goto end;
 198     }
 199
 200     for(i = 0;i < count-1;i++)
 201         buf[i] = i2c_inb(iface, true);
 202
 203     buf[i] = i2c_inb(iface, false);
 204
 205 end:
 206     i2c_stop(iface);
 207     return ret;
 208 }
 209
 210 /* returns bus index which can be used as a handle, or <0 on error */
 211 int i2c_add_node(const struct i2c_interface *iface)
 212 {
 213     int bus_index;
 214
 215     if (i2c_num_ifs == MAX_I2C_INTERFACES)
 216         return -1;
 217
 218     bus_index = i2c_num_ifs++;
 219     i2c_if[bus_index] = iface;
 220
 221     iface->scl_output();
 222
 223     return bus_index;
 224 }