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 * SPDX-License-Identifier: GPL-2.0+ 10 */ 11 #include <common.h> 12 #include <i2c.h> 13 14 struct i2c_adapter *i2c_get_adapter(int index) 15 { 16 struct i2c_adapter *i2c_adap_p = ll_entry_start(struct i2c_adapter, 17 i2c); 18 int max = ll_entry_count(struct i2c_adapter, i2c); 19 int i; 20 21 if (index >= max) { 22 printf("Error, wrong i2c adapter %d max %d possible\n", 23 index, max); 24 return i2c_adap_p; 25 } 26 if (index == 0) 27 return i2c_adap_p; 28 29 for (i = 0; i < index; i++) 30 i2c_adap_p++; 31 32 return i2c_adap_p; 33 } 34 35 #if !defined(CONFIG_SYS_I2C_DIRECT_BUS) 36 struct i2c_bus_hose i2c_bus[CONFIG_SYS_NUM_I2C_BUSES] = 37 CONFIG_SYS_I2C_BUSES; 38 #endif 39 40 DECLARE_GLOBAL_DATA_PTR; 41 42 #ifndef CONFIG_SYS_I2C_DIRECT_BUS 43 /* 44 * i2c_mux_set() 45 * ------------- 46 * 47 * This turns on the given channel on I2C multiplexer chip connected to 48 * a given I2C adapter directly or via other multiplexers. In the latter 49 * case the entire multiplexer chain must be initialized first starting 50 * with the one connected directly to the adapter. When disabling a chain 51 * muxes must be programmed in reverse order, starting with the one 52 * farthest from the adapter. 53 * 54 * mux_id is the multiplexer chip type from defined in i2c.h. So far only 55 * NXP (Philips) PCA954x multiplexers are supported. Switches are NOT 56 * supported (anybody uses them?) 57 */ 58 59 static int i2c_mux_set(struct i2c_adapter *adap, int mux_id, int chip, 60 int channel) 61 { 62 uint8_t buf; 63 int ret; 64 65 /* channel < 0 - turn off the mux */ 66 if (channel < 0) { 67 buf = 0; 68 ret = adap->write(adap, chip, 0, 0, &buf, 1); 69 if (ret) 70 printf("%s: Could not turn off the mux.\n", __func__); 71 return ret; 72 } 73 74 switch (mux_id) { 75 case I2C_MUX_PCA9540_ID: 76 case I2C_MUX_PCA9542_ID: 77 if (channel > 1) 78 return -1; 79 buf = (uint8_t)((channel & 0x01) | (1 << 2)); 80 break; 81 case I2C_MUX_PCA9544_ID: 82 if (channel > 3) 83 return -1; 84 buf = (uint8_t)((channel & 0x03) | (1 << 2)); 85 break; 86 case I2C_MUX_PCA9547_ID: 87 if (channel > 7) 88 return -1; 89 buf = (uint8_t)((channel & 0x07) | (1 << 3)); 90 break; 91 case I2C_MUX_PCA9548_ID: 92 if (channel > 7) 93 return -1; 94 buf = (uint8_t)(0x01 << channel); 95 break; 96 default: 97 printf("%s: wrong mux id: %d\n", __func__, mux_id); 98 return -1; 99 } 100 101 ret = adap->write(adap, chip, 0, 0, &buf, 1); 102 if (ret) 103 printf("%s: could not set mux: id: %d chip: %x channel: %d\n", 104 __func__, mux_id, chip, channel); 105 return ret; 106 } 107 108 static int i2c_mux_set_all(void) 109 { 110 struct i2c_bus_hose *i2c_bus_tmp = &i2c_bus[I2C_BUS]; 111 int i; 112 113 /* Connect requested bus if behind muxes */ 114 if (i2c_bus_tmp->next_hop[0].chip != 0) { 115 /* Set all muxes along the path to that bus */ 116 for (i = 0; i < CONFIG_SYS_I2C_MAX_HOPS; i++) { 117 int ret; 118 119 if (i2c_bus_tmp->next_hop[i].chip == 0) 120 break; 121 122 ret = i2c_mux_set(I2C_ADAP, 123 i2c_bus_tmp->next_hop[i].mux.id, 124 i2c_bus_tmp->next_hop[i].chip, 125 i2c_bus_tmp->next_hop[i].channel); 126 if (ret != 0) 127 return ret; 128 } 129 } 130 return 0; 131 } 132 133 static int i2c_mux_disconnect_all(void) 134 { 135 struct i2c_bus_hose *i2c_bus_tmp = &i2c_bus[I2C_BUS]; 136 int i; 137 uint8_t buf = 0; 138 139 if (I2C_ADAP->init_done == 0) 140 return 0; 141 142 /* Disconnect current bus (turn off muxes if any) */ 143 if ((i2c_bus_tmp->next_hop[0].chip != 0) && 144 (I2C_ADAP->init_done != 0)) { 145 i = CONFIG_SYS_I2C_MAX_HOPS; 146 do { 147 uint8_t chip; 148 int ret; 149 150 chip = i2c_bus_tmp->next_hop[--i].chip; 151 if (chip == 0) 152 continue; 153 154 ret = I2C_ADAP->write(I2C_ADAP, chip, 0, 0, &buf, 1); 155 if (ret != 0) { 156 printf("i2c: mux disconnect error\n"); 157 return ret; 158 } 159 } while (i > 0); 160 } 161 162 return 0; 163 } 164 #endif 165 166 /* 167 * i2c_init_bus(): 168 * --------------- 169 * 170 * Initializes one bus. Will initialize the parent adapter. No current bus 171 * changes, no mux (if any) setup. 172 */ 173 static void i2c_init_bus(unsigned int bus_no, int speed, int slaveaddr) 174 { 175 if (bus_no >= CONFIG_SYS_NUM_I2C_BUSES) 176 return; 177 178 I2C_ADAP->init(I2C_ADAP, speed, slaveaddr); 179 180 if (gd->flags & GD_FLG_RELOC) { 181 I2C_ADAP->init_done = 1; 182 I2C_ADAP->speed = speed; 183 I2C_ADAP->slaveaddr = slaveaddr; 184 } 185 } 186 187 /* implement possible board specific board init */ 188 __weak void i2c_init_board(void) 189 { 190 } 191 192 /* implement possible for i2c specific early i2c init */ 193 __weak void i2c_early_init_f(void) 194 { 195 } 196 197 /* 198 * i2c_init_all(): 199 * 200 * not longer needed, will deleted. Actual init the SPD_BUS 201 * for compatibility. 202 * i2c_adap[] must be initialized beforehead with function pointers and 203 * data, including speed and slaveaddr. 204 */ 205 void i2c_init_all(void) 206 { 207 i2c_init_board(); 208 i2c_set_bus_num(CONFIG_SYS_SPD_BUS_NUM); 209 return; 210 } 211 212 /* 213 * i2c_get_bus_num(): 214 * ------------------ 215 * 216 * Returns index of currently active I2C bus. Zero-based. 217 */ 218 unsigned int i2c_get_bus_num(void) 219 { 220 return gd->cur_i2c_bus; 221 } 222 223 /* 224 * i2c_set_bus_num(): 225 * ------------------ 226 * 227 * Change the active I2C bus. Subsequent read/write calls will 228 * go to this one. Sets all of the muxes in a proper condition 229 * if that bus is behind muxes. 230 * If previously selected bus is behind the muxes turns off all the 231 * muxes along the path to that bus. 232 * 233 * bus - bus index, zero based 234 * 235 * Returns: 0 on success, not 0 on failure 236 */ 237 int i2c_set_bus_num(unsigned int bus) 238 { 239 int max; 240 241 if ((bus == I2C_BUS) && (I2C_ADAP->init_done > 0)) 242 return 0; 243 244 #ifndef CONFIG_SYS_I2C_DIRECT_BUS 245 if (bus >= CONFIG_SYS_NUM_I2C_BUSES) 246 return -1; 247 #endif 248 249 max = ll_entry_count(struct i2c_adapter, i2c); 250 if (I2C_ADAPTER(bus) >= max) { 251 printf("Error, wrong i2c adapter %d max %d possible\n", 252 I2C_ADAPTER(bus), max); 253 return -2; 254 } 255 256 #ifndef CONFIG_SYS_I2C_DIRECT_BUS 257 i2c_mux_disconnect_all(); 258 #endif 259 260 gd->cur_i2c_bus = bus; 261 if (I2C_ADAP->init_done == 0) 262 i2c_init_bus(bus, I2C_ADAP->speed, I2C_ADAP->slaveaddr); 263 264 #ifndef CONFIG_SYS_I2C_DIRECT_BUS 265 i2c_mux_set_all(); 266 #endif 267 return 0; 268 } 269 270 /* 271 * Probe the given I2C chip address. Returns 0 if a chip responded, 272 * not 0 on failure. 273 */ 274 int i2c_probe(uint8_t chip) 275 { 276 return I2C_ADAP->probe(I2C_ADAP, chip); 277 } 278 279 /* 280 * Read/Write interface: 281 * chip: I2C chip address, range 0..127 282 * addr: Memory (register) address within the chip 283 * alen: Number of bytes to use for addr (typically 1, 2 for larger 284 * memories, 0 for register type devices with only one 285 * register) 286 * buffer: Where to read/write the data 287 * len: How many bytes to read/write 288 * 289 * Returns: 0 on success, not 0 on failure 290 */ 291 int i2c_read(uint8_t chip, unsigned int addr, int alen, 292 uint8_t *buffer, int len) 293 { 294 return I2C_ADAP->read(I2C_ADAP, chip, addr, alen, buffer, len); 295 } 296 297 int i2c_write(uint8_t chip, unsigned int addr, int alen, 298 uint8_t *buffer, int len) 299 { 300 return I2C_ADAP->write(I2C_ADAP, chip, addr, alen, buffer, len); 301 } 302 303 unsigned int i2c_set_bus_speed(unsigned int speed) 304 { 305 unsigned int ret; 306 307 if (I2C_ADAP->set_bus_speed == NULL) 308 return 0; 309 ret = I2C_ADAP->set_bus_speed(I2C_ADAP, speed); 310 if (gd->flags & GD_FLG_RELOC) 311 I2C_ADAP->speed = (ret == 0) ? speed : 0; 312 313 return ret; 314 } 315 316 unsigned int i2c_get_bus_speed(void) 317 { 318 struct i2c_adapter *cur = I2C_ADAP; 319 return cur->speed; 320 } 321 322 uint8_t i2c_reg_read(uint8_t addr, uint8_t reg) 323 { 324 uint8_t buf; 325 326 i2c_read(addr, reg, 1, &buf, 1); 327 328 #ifdef DEBUG 329 printf("%s: bus=%d addr=0x%02x, reg=0x%02x, val=0x%02x\n", 330 __func__, i2c_get_bus_num(), addr, reg, buf); 331 #endif 332 333 return buf; 334 } 335 336 void i2c_reg_write(uint8_t addr, uint8_t reg, uint8_t val) 337 { 338 #ifdef DEBUG 339 printf("%s: bus=%d addr=0x%02x, reg=0x%02x, val=0x%02x\n", 340 __func__, i2c_get_bus_num(), addr, reg, val); 341 #endif 342 343 i2c_write(addr, reg, 1, &val, 1); 344 } 345 346 __weak void i2c_init(int speed, int slaveaddr) 347 { 348 i2c_init_bus(i2c_get_bus_num(), speed, slaveaddr); 349 } 350