drivers/i2c/i2c_core.c

   1 /*
   2  * Copyright (C) 2009 Sergey Kubushyn <ksi@koi8.net>
   3  *
   4  * (C) Copyright 2012
   5  * Heiko Schocher, DENX Software Engineering, hs@denx.de.
   6  *
   7  * Multibus/multiadapter I2C core functions (wrappers)
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23 #include <common.h>
  24 #include <i2c.h>
  25
  26 struct i2c_adapter *i2c_get_adapter(int index)
  27 {
  28         struct i2c_adapter *i2c_adap_p = ll_entry_start(struct i2c_adapter,
  29                                                 i2c);
  30         int max = ll_entry_count(struct i2c_adapter, i2c);
  31         int i;
  32
  33         if (index >= max) {
  34                 printf("Error, wrong i2c adapter %d max %d possible\n",
  35                        index, max);
  36                 return i2c_adap_p;
  37         }
  38         if (index == 0)
  39                 return i2c_adap_p;
  40
  41         for (i = 0; i < index; i++)
  42                 i2c_adap_p++;
  43
  44         return i2c_adap_p;
  45 }
  46
  47 #if !defined(CONFIG_SYS_I2C_DIRECT_BUS)
  48 struct i2c_bus_hose i2c_bus[CONFIG_SYS_NUM_I2C_BUSES] =
  49                         CONFIG_SYS_I2C_BUSES;
  50 #endif
  51
  52 DECLARE_GLOBAL_DATA_PTR;
  53
  54 void i2c_reloc_fixup(void)
  55 {
  56 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
  57         struct i2c_adapter *i2c_adap_p = ll_entry_start(struct i2c_adapter,
  58                                                 i2c);
  59         struct i2c_adapter *tmp = i2c_adap_p;
  60         int max = ll_entry_count(struct i2c_adapter, i2c);
  61         int             i;
  62         unsigned long   addr;
  63
  64         if (gd->reloc_off == 0)
  65                 return;
  66
  67         for (i = 0; i < max; i++) {
  68                 /* adapter itself */
  69                 addr = (unsigned long)i2c_adap_p;
  70                 addr += gd->reloc_off;
  71                 i2c_adap_p = (struct i2c_adapter *)addr;
  72                 /* i2c_init() */
  73                 addr = (unsigned long)i2c_adap_p->init;
  74                 addr += gd->reloc_off;
  75                 i2c_adap_p->init = (void (*)(int, int))addr;
  76                 /* i2c_probe() */
  77                 addr = (unsigned long)i2c_adap_p->probe;
  78                 addr += gd->reloc_off;
  79                 i2c_adap_p->probe = (int (*)(uint8_t))addr;
  80                 /* i2c_read() */
  81                 addr = (unsigned long)i2c_adap_p->read;
  82                 addr += gd->reloc_off;
  83                 i2c_adap_p->read = (int (*)(uint8_t, uint, int, uint8_t *,
  84                                         int))addr;
  85                 /* i2c_write() */
  86                 addr = (unsigned long)i2c_adap_p->write;
  87                 addr += gd->reloc_off;
  88                 i2c_adap_p->write = (int (*)(uint8_t, uint, int, uint8_t *,
  89                                         int))addr;
  90                 /* i2c_set_bus_speed() */
  91                 addr = (unsigned long)i2c_adap_p->set_bus_speed;
  92                 addr += gd->reloc_off;
  93                 i2c_adap_p->set_bus_speed = (uint (*)(uint))addr;
  94                 /* name */
  95                 addr = (unsigned long)i2c_adap_p->name;
  96                 addr += gd->reloc_off;
  97                 i2c_adap_p->name = (char *)addr;
  98                 tmp++;
  99                 i2c_adap_p = tmp;
 100         }
 101 #endif
 102 }
 103
 104 #ifndef CONFIG_SYS_I2C_DIRECT_BUS
 105 /*
 106  * i2c_mux_set()
 107  * -------------
 108  *
 109  * This turns on the given channel on I2C multiplexer chip connected to
 110  * a given I2C adapter directly or via other multiplexers. In the latter
 111  * case the entire multiplexer chain must be initialized first starting
 112  * with the one connected directly to the adapter. When disabling a chain
 113  * muxes must be programmed in reverse order, starting with the one
 114  * farthest from the adapter.
 115  *
 116  * mux_id is the multiplexer chip type from defined in i2c.h. So far only
 117  * NXP (Philips) PCA954x multiplexers are supported. Switches are NOT
 118  * supported (anybody uses them?)
 119  */
 120
 121 static int i2c_mux_set(struct i2c_adapter *adap, int mux_id, int chip,
 122                         int channel)
 123 {
 124         uint8_t buf;
 125         int ret;
 126
 127         /* channel < 0 - turn off the mux */
 128         if (channel < 0) {
 129                 buf = 0;
 130                 ret = adap->write(adap, chip, 0, 0, &buf, 1);
 131                 if (ret)
 132                         printf("%s: Could not turn off the mux.\n", __func__);
 133                 return ret;
 134         }
 135
 136         switch (mux_id) {
 137         case I2C_MUX_PCA9540_ID:
 138         case I2C_MUX_PCA9542_ID:
 139                 if (channel > 1)
 140                         return -1;
 141                 buf = (uint8_t)((channel & 0x01) | (1 << 2));
 142                 break;
 143         case I2C_MUX_PCA9544_ID:
 144                 if (channel > 3)
 145                         return -1;
 146                 buf = (uint8_t)((channel & 0x03) | (1 << 2));
 147                 break;
 148         case I2C_MUX_PCA9547_ID:
 149                 if (channel > 7)
 150                         return -1;
 151                 buf = (uint8_t)((channel & 0x07) | (1 << 3));
 152                 break;
 153         default:
 154                 printf("%s: wrong mux id: %d\n", __func__, mux_id);
 155                 return -1;
 156         }
 157
 158         ret = adap->write(adap, chip, 0, 0, &buf, 1);
 159         if (ret)
 160                 printf("%s: could not set mux: id: %d chip: %x channel: %d\n",
 161                        __func__, mux_id, chip, channel);
 162         return ret;
 163 }
 164
 165 static int i2c_mux_set_all(void)
 166 {
 167         struct i2c_bus_hose *i2c_bus_tmp = &i2c_bus[I2C_BUS];
 168         int i;
 169
 170         /* Connect requested bus if behind muxes */
 171         if (i2c_bus_tmp->next_hop[0].chip != 0) {
 172                 /* Set all muxes along the path to that bus */
 173                 for (i = 0; i < CONFIG_SYS_I2C_MAX_HOPS; i++) {
 174                         int     ret;
 175
 176                         if (i2c_bus_tmp->next_hop[i].chip == 0)
 177                                 break;
 178
 179                         ret = i2c_mux_set(I2C_ADAP,
 180                                         i2c_bus_tmp->next_hop[i].mux.id,
 181                                         i2c_bus_tmp->next_hop[i].chip,
 182                                         i2c_bus_tmp->next_hop[i].channel);
 183                         if (ret != 0)
 184                                 return ret;
 185                 }
 186         }
 187         return 0;
 188 }
 189
 190 static int i2c_mux_disconnet_all(void)
 191 {
 192         struct  i2c_bus_hose *i2c_bus_tmp = &i2c_bus[I2C_BUS];
 193         int     i;
 194         uint8_t buf;
 195
 196         if (I2C_ADAP->init_done == 0)
 197                 return 0;
 198
 199         /* Disconnect current bus (turn off muxes if any) */
 200         if ((i2c_bus_tmp->next_hop[0].chip != 0) &&
 201             (I2C_ADAP->init_done != 0)) {
 202                 i = CONFIG_SYS_I2C_MAX_HOPS;
 203                 do {
 204                         uint8_t chip;
 205                         int ret;
 206
 207                         chip = i2c_bus_tmp->next_hop[--i].chip;
 208                         if (chip == 0)
 209                                 continue;
 210
 211                         ret = I2C_ADAP->write(I2C_ADAP, chip, 0, 0, &buf, 1);
 212                         if (ret != 0) {
 213                                 printf("i2c: mux diconnect error\n");
 214                                 return ret;
 215                         }
 216                 } while (i > 0);
 217         }
 218
 219         return 0;
 220 }
 221 #endif
 222
 223 /*
 224  * i2c_init_bus():
 225  * ---------------
 226  *
 227  * Initializes one bus. Will initialize the parent adapter. No current bus
 228  * changes, no mux (if any) setup.
 229  */
 230 static void i2c_init_bus(unsigned int bus_no, int speed, int slaveaddr)
 231 {
 232         if (bus_no >= CONFIG_SYS_NUM_I2C_BUSES)
 233                 return;
 234
 235         I2C_ADAP->init(I2C_ADAP, speed, slaveaddr);
 236
 237         if (gd->flags & GD_FLG_RELOC) {
 238                 I2C_ADAP->init_done = 1;
 239                 I2C_ADAP->speed = speed;
 240                 I2C_ADAP->slaveaddr = slaveaddr;
 241         }
 242 }
 243
 244 /* implement possible board specific board init */
 245 static void __def_i2c_init_board(void)
 246 {
 247 }
 248 void i2c_init_board(void)
 249         __attribute__((weak, alias("__def_i2c_init_board")));
 250
 251 /*
 252  * i2c_init_all():
 253  *
 254  * not longer needed, will deleted. Actual init the SPD_BUS
 255  * for compatibility.
 256  * i2c_adap[] must be initialized beforehead with function pointers and
 257  * data, including speed and slaveaddr.
 258  */
 259 void i2c_init_all(void)
 260 {
 261         i2c_init_board();
 262         i2c_set_bus_num(CONFIG_SYS_SPD_BUS_NUM);
 263         return;
 264 }
 265
 266 /*
 267  * i2c_get_bus_num():
 268  * ------------------
 269  *
 270  *  Returns index of currently active I2C bus.  Zero-based.
 271  */
 272 unsigned int i2c_get_bus_num(void)
 273 {
 274         return gd->cur_i2c_bus;
 275 }
 276
 277 /*
 278  * i2c_set_bus_num():
 279  * ------------------
 280  *
 281  *  Change the active I2C bus. Subsequent read/write calls will
 282  *  go to this one. Sets all of the muxes in a proper condition
 283  *  if that bus is behind muxes.
 284  *  If previously selected bus is behind the muxes turns off all the
 285  *  muxes along the path to that bus.
 286  *
 287  *      bus - bus index, zero based
 288  *
 289  *      Returns: 0 on success, not 0 on failure
 290  */
 291 int i2c_set_bus_num(unsigned int bus)
 292 {
 293         int max = ll_entry_count(struct i2c_adapter, i2c);
 294
 295         if (I2C_ADAPTER(bus) >= max) {
 296                 printf("Error, wrong i2c adapter %d max %d possible\n",
 297                        I2C_ADAPTER(bus), max);
 298                 return -2;
 299         }
 300 #ifndef CONFIG_SYS_I2C_DIRECT_BUS
 301         if (bus >= CONFIG_SYS_NUM_I2C_BUSES)
 302                 return -1;
 303 #endif
 304
 305         if ((bus == I2C_BUS) && (I2C_ADAP->init_done > 0))
 306                 return 0;
 307
 308 #ifndef CONFIG_SYS_I2C_DIRECT_BUS
 309         i2c_mux_disconnet_all();
 310 #endif
 311
 312         gd->cur_i2c_bus = bus;
 313         if (I2C_ADAP->init_done == 0)
 314                 i2c_init_bus(bus, I2C_ADAP->speed, I2C_ADAP->slaveaddr);
 315
 316 #ifndef CONFIG_SYS_I2C_DIRECT_BUS
 317         i2c_mux_set_all();
 318 #endif
 319         return 0;
 320 }
 321
 322 /*
 323  * Probe the given I2C chip address.  Returns 0 if a chip responded,
 324  * not 0 on failure.
 325  */
 326 int i2c_probe(uint8_t chip)
 327 {
 328         return I2C_ADAP->probe(I2C_ADAP, chip);
 329 }
 330
 331 /*
 332  * Read/Write interface:
 333  *   chip:    I2C chip address, range 0..127
 334  *   addr:    Memory (register) address within the chip
 335  *   alen:    Number of bytes to use for addr (typically 1, 2 for larger
 336  *              memories, 0 for register type devices with only one
 337  *              register)
 338  *   buffer:  Where to read/write the data
 339  *   len:     How many bytes to read/write
 340  *
 341  *   Returns: 0 on success, not 0 on failure
 342  */
 343 int i2c_read(uint8_t chip, unsigned int addr, int alen,
 344                                 uint8_t *buffer, int len)
 345 {
 346         return I2C_ADAP->read(I2C_ADAP, chip, addr, alen, buffer, len);
 347 }
 348
 349 int i2c_write(uint8_t chip, unsigned int addr, int alen,
 350                                 uint8_t *buffer, int len)
 351 {
 352         return I2C_ADAP->write(I2C_ADAP, chip, addr, alen, buffer, len);
 353 }
 354
 355 unsigned int i2c_set_bus_speed(unsigned int speed)
 356 {
 357         unsigned int ret;
 358
 359         if (I2C_ADAP->set_bus_speed == NULL)
 360                 return 0;
 361         ret = I2C_ADAP->set_bus_speed(I2C_ADAP, speed);
 362         if (gd->flags & GD_FLG_RELOC)
 363                 I2C_ADAP->speed = ret;
 364
 365         return ret;
 366 }
 367
 368 unsigned int i2c_get_bus_speed(void)
 369 {
 370         struct i2c_adapter *cur = I2C_ADAP;
 371         return cur->speed;
 372 }
 373
 374 uint8_t i2c_reg_read(uint8_t addr, uint8_t reg)
 375 {
 376         uint8_t buf;
 377
 378 #ifdef CONFIG_8xx
 379         /* MPC8xx needs this.  Maybe one day we can get rid of it. */
 380         /* maybe it is now the time for it ... */
 381         i2c_set_bus_num(i2c_get_bus_num());
 382 #endif
 383         i2c_read(addr, reg, 1, &buf, 1);
 384
 385 #ifdef DEBUG
 386         printf("%s: bus=%d addr=0x%02x, reg=0x%02x, val=0x%02x\n",
 387                __func__, i2c_get_bus_num(), addr, reg, buf);
 388 #endif
 389
 390         return buf;
 391 }
 392
 393 void i2c_reg_write(uint8_t addr, uint8_t reg, uint8_t val)
 394 {
 395 #ifdef CONFIG_8xx
 396         /* MPC8xx needs this.  Maybe one day we can get rid of it. */
 397         /* maybe it is now the time for it ... */
 398         i2c_set_bus_num(i2c_get_bus_num());
 399 #endif
 400
 401 #ifdef DEBUG
 402         printf("%s: bus=%d addr=0x%02x, reg=0x%02x, val=0x%02x\n",
 403                __func__, i2c_get_bus_num(), addr, reg, val);
 404 #endif
 405
 406         i2c_write(addr, reg, 1, &val, 1);
 407 }
 408
 409 void __i2c_init(int speed, int slaveaddr)
 410 {
 411         i2c_init_bus(i2c_get_bus_num(), speed, slaveaddr);
 412 }
 413 void i2c_init(int speed, int slaveaddr)
 414         __attribute__((weak, alias("__i2c_init")));