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"))); 415