1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2007 by Silicon Motion, Inc. (SMI) 4 * 5 * swi2c.c --- SM750/SM718 DDK 6 * This file contains the source code for I2C using software 7 * implementation. 8 */ 9 10 #include "ddk750_chip.h" 11 #include "ddk750_reg.h" 12 #include "ddk750_swi2c.h" 13 #include "ddk750_power.h" 14 15 /* 16 * I2C Software Master Driver: 17 * =========================== 18 * Each i2c cycle is split into 4 sections. Each of these section marks 19 * a point in time where the SCL or SDA may be changed. 20 * 21 * 1 Cycle == | Section I. | Section 2. | Section 3. | Section 4. | 22 * +-------------+-------------+-------------+-------------+ 23 * | SCL set LOW |SCL no change| SCL set HIGH|SCL no change| 24 * 25 * ____________ _____________ 26 * SCL == XXXX _____________ ____________ / 27 * 28 * I.e. the SCL may only be changed in section 1. and section 3. while 29 * the SDA may only be changed in section 2. and section 4. The table 30 * below gives the changes for these 2 lines in the varios sections. 31 * 32 * Section changes Table: 33 * ====================== 34 * blank = no change, L = set bit LOW, H = set bit HIGH 35 * 36 * | 1.| 2.| 3.| 4.| 37 * ---------------+---+---+---+---+ 38 * Tx Start SDA | | H | | L | 39 * SCL | L | | H | | 40 * ---------------+---+---+---+---+ 41 * Tx Stop SDA | | L | | H | 42 * SCL | L | | H | | 43 * ---------------+---+---+---+---+ 44 * Tx bit H SDA | | H | | | 45 * SCL | L | | H | | 46 * ---------------+---+---+---+---+ 47 * Tx bit L SDA | | L | | | 48 * SCL | L | | H | | 49 * ---------------+---+---+---+---+ 50 * 51 */ 52 53 /* GPIO pins used for this I2C. It ranges from 0 to 63. */ 54 static unsigned char sw_i2c_clk_gpio = DEFAULT_I2C_SCL; 55 static unsigned char sw_i2c_data_gpio = DEFAULT_I2C_SDA; 56 57 /* 58 * Below is the variable declaration for the GPIO pin register usage 59 * for the i2c Clock and i2c Data. 60 * 61 * Note: 62 * Notice that the GPIO usage for the i2c clock and i2c Data are 63 * separated. This is to make this code flexible enough when 64 * two separate GPIO pins for the clock and data are located 65 * in two different GPIO register set (worst case). 66 */ 67 68 /* i2c Clock GPIO Register usage */ 69 static unsigned long sw_i2c_clk_gpio_mux_reg = GPIO_MUX; 70 static unsigned long sw_i2c_clk_gpio_data_reg = GPIO_DATA; 71 static unsigned long sw_i2c_clk_gpio_data_dir_reg = GPIO_DATA_DIRECTION; 72 73 /* i2c Data GPIO Register usage */ 74 static unsigned long sw_i2c_data_gpio_mux_reg = GPIO_MUX; 75 static unsigned long sw_i2c_data_gpio_data_reg = GPIO_DATA; 76 static unsigned long sw_i2c_data_gpio_data_dir_reg = GPIO_DATA_DIRECTION; 77 78 /* 79 * This function puts a delay between command 80 */ 81 static void sw_i2c_wait(void) 82 { 83 /* find a bug: 84 * peekIO method works well before suspend/resume 85 * but after suspend, peekIO(0x3ce,0x61) & 0x10 86 * always be non-zero,which makes the while loop 87 * never finish. 88 * use non-ultimate for loop below is safe 89 */ 90 91 /* Change wait algorithm to use PCI bus clock, 92 * it's more reliable than counter loop .. 93 * write 0x61 to 0x3ce and read from 0x3cf 94 */ 95 int i, tmp; 96 97 for (i = 0; i < 600; i++) { 98 tmp = i; 99 tmp += i; 100 } 101 } 102 103 /* 104 * This function set/reset the SCL GPIO pin 105 * 106 * Parameters: 107 * value - Bit value to set to the SCL or SDA (0 = low, 1 = high) 108 * 109 * Notes: 110 * When setting SCL to high, just set the GPIO as input where the pull up 111 * resistor will pull the signal up. Do not use software to pull up the 112 * signal because the i2c will fail when other device try to drive the 113 * signal due to SM50x will drive the signal to always high. 114 */ 115 static void sw_i2c_scl(unsigned char value) 116 { 117 unsigned long gpio_data; 118 unsigned long gpio_dir; 119 120 gpio_dir = peek32(sw_i2c_clk_gpio_data_dir_reg); 121 if (value) { /* High */ 122 /* 123 * Set direction as input. This will automatically 124 * pull the signal up. 125 */ 126 gpio_dir &= ~(1 << sw_i2c_clk_gpio); 127 poke32(sw_i2c_clk_gpio_data_dir_reg, gpio_dir); 128 } else { /* Low */ 129 /* Set the signal down */ 130 gpio_data = peek32(sw_i2c_clk_gpio_data_reg); 131 gpio_data &= ~(1 << sw_i2c_clk_gpio); 132 poke32(sw_i2c_clk_gpio_data_reg, gpio_data); 133 134 /* Set direction as output */ 135 gpio_dir |= (1 << sw_i2c_clk_gpio); 136 poke32(sw_i2c_clk_gpio_data_dir_reg, gpio_dir); 137 } 138 } 139 140 /* 141 * This function set/reset the SDA GPIO pin 142 * 143 * Parameters: 144 * value - Bit value to set to the SCL or SDA (0 = low, 1 = high) 145 * 146 * Notes: 147 * When setting SCL to high, just set the GPIO as input where the pull up 148 * resistor will pull the signal up. Do not use software to pull up the 149 * signal because the i2c will fail when other device try to drive the 150 * signal due to SM50x will drive the signal to always high. 151 */ 152 static void sw_i2c_sda(unsigned char value) 153 { 154 unsigned long gpio_data; 155 unsigned long gpio_dir; 156 157 gpio_dir = peek32(sw_i2c_data_gpio_data_dir_reg); 158 if (value) { /* High */ 159 /* 160 * Set direction as input. This will automatically 161 * pull the signal up. 162 */ 163 gpio_dir &= ~(1 << sw_i2c_data_gpio); 164 poke32(sw_i2c_data_gpio_data_dir_reg, gpio_dir); 165 } else { /* Low */ 166 /* Set the signal down */ 167 gpio_data = peek32(sw_i2c_data_gpio_data_reg); 168 gpio_data &= ~(1 << sw_i2c_data_gpio); 169 poke32(sw_i2c_data_gpio_data_reg, gpio_data); 170 171 /* Set direction as output */ 172 gpio_dir |= (1 << sw_i2c_data_gpio); 173 poke32(sw_i2c_data_gpio_data_dir_reg, gpio_dir); 174 } 175 } 176 177 /* 178 * This function read the data from the SDA GPIO pin 179 * 180 * Return Value: 181 * The SDA data bit sent by the Slave 182 */ 183 static unsigned char sw_i2c_read_sda(void) 184 { 185 unsigned long gpio_dir; 186 unsigned long gpio_data; 187 unsigned long dir_mask = 1 << sw_i2c_data_gpio; 188 189 /* Make sure that the direction is input (High) */ 190 gpio_dir = peek32(sw_i2c_data_gpio_data_dir_reg); 191 if ((gpio_dir & dir_mask) != ~dir_mask) { 192 gpio_dir &= ~(1 << sw_i2c_data_gpio); 193 poke32(sw_i2c_data_gpio_data_dir_reg, gpio_dir); 194 } 195 196 /* Now read the SDA line */ 197 gpio_data = peek32(sw_i2c_data_gpio_data_reg); 198 if (gpio_data & (1 << sw_i2c_data_gpio)) 199 return 1; 200 else 201 return 0; 202 } 203 204 /* 205 * This function sends ACK signal 206 */ 207 static void sw_i2c_ack(void) 208 { 209 return; /* Single byte read is ok without it. */ 210 } 211 212 /* 213 * This function sends the start command to the slave device 214 */ 215 static void sw_i2c_start(void) 216 { 217 /* Start I2C */ 218 sw_i2c_sda(1); 219 sw_i2c_scl(1); 220 sw_i2c_sda(0); 221 } 222 223 /* 224 * This function sends the stop command to the slave device 225 */ 226 static void sw_i2c_stop(void) 227 { 228 /* Stop the I2C */ 229 sw_i2c_scl(1); 230 sw_i2c_sda(0); 231 sw_i2c_sda(1); 232 } 233 234 /* 235 * This function writes one byte to the slave device 236 * 237 * Parameters: 238 * data - Data to be write to the slave device 239 * 240 * Return Value: 241 * 0 - Success 242 * -1 - Fail to write byte 243 */ 244 static long sw_i2c_write_byte(unsigned char data) 245 { 246 unsigned char value = data; 247 int i; 248 249 /* Sending the data bit by bit */ 250 for (i = 0; i < 8; i++) { 251 /* Set SCL to low */ 252 sw_i2c_scl(0); 253 254 /* Send data bit */ 255 if ((value & 0x80) != 0) 256 sw_i2c_sda(1); 257 else 258 sw_i2c_sda(0); 259 260 sw_i2c_wait(); 261 262 /* Toggle clk line to one */ 263 sw_i2c_scl(1); 264 sw_i2c_wait(); 265 266 /* Shift byte to be sent */ 267 value = value << 1; 268 } 269 270 /* Set the SCL Low and SDA High (prepare to get input) */ 271 sw_i2c_scl(0); 272 sw_i2c_sda(1); 273 274 /* Set the SCL High for ack */ 275 sw_i2c_wait(); 276 sw_i2c_scl(1); 277 sw_i2c_wait(); 278 279 /* Read SDA, until SDA==0 */ 280 for (i = 0; i < 0xff; i++) { 281 if (!sw_i2c_read_sda()) 282 break; 283 284 sw_i2c_scl(0); 285 sw_i2c_wait(); 286 sw_i2c_scl(1); 287 sw_i2c_wait(); 288 } 289 290 /* Set the SCL Low and SDA High */ 291 sw_i2c_scl(0); 292 sw_i2c_sda(1); 293 294 if (i < 0xff) 295 return 0; 296 else 297 return -1; 298 } 299 300 /* 301 * This function reads one byte from the slave device 302 * 303 * Parameters: 304 * ack - Flag to indicate either to send the acknowledge 305 * message to the slave device or not 306 * 307 * Return Value: 308 * One byte data read from the Slave device 309 */ 310 static unsigned char sw_i2c_read_byte(unsigned char ack) 311 { 312 int i; 313 unsigned char data = 0; 314 315 for (i = 7; i >= 0; i--) { 316 /* Set the SCL to Low and SDA to High (Input) */ 317 sw_i2c_scl(0); 318 sw_i2c_sda(1); 319 sw_i2c_wait(); 320 321 /* Set the SCL High */ 322 sw_i2c_scl(1); 323 sw_i2c_wait(); 324 325 /* Read data bits from SDA */ 326 data |= (sw_i2c_read_sda() << i); 327 } 328 329 if (ack) 330 sw_i2c_ack(); 331 332 /* Set the SCL Low and SDA High */ 333 sw_i2c_scl(0); 334 sw_i2c_sda(1); 335 336 return data; 337 } 338 339 /* 340 * This function initializes GPIO port for SW I2C communication. 341 * 342 * Parameters: 343 * clk_gpio - The GPIO pin to be used as i2c SCL 344 * data_gpio - The GPIO pin to be used as i2c SDA 345 * 346 * Return Value: 347 * -1 - Fail to initialize the i2c 348 * 0 - Success 349 */ 350 static long sm750le_i2c_init(unsigned char clk_gpio, unsigned char data_gpio) 351 { 352 int i; 353 354 /* Initialize the GPIO pin for the i2c Clock Register */ 355 sw_i2c_clk_gpio_data_reg = GPIO_DATA_SM750LE; 356 sw_i2c_clk_gpio_data_dir_reg = GPIO_DATA_DIRECTION_SM750LE; 357 358 /* Initialize the Clock GPIO Offset */ 359 sw_i2c_clk_gpio = clk_gpio; 360 361 /* Initialize the GPIO pin for the i2c Data Register */ 362 sw_i2c_data_gpio_data_reg = GPIO_DATA_SM750LE; 363 sw_i2c_data_gpio_data_dir_reg = GPIO_DATA_DIRECTION_SM750LE; 364 365 /* Initialize the Data GPIO Offset */ 366 sw_i2c_data_gpio = data_gpio; 367 368 /* Note that SM750LE don't have GPIO MUX and power is always on */ 369 370 /* Clear the i2c lines. */ 371 for (i = 0; i < 9; i++) 372 sw_i2c_stop(); 373 374 return 0; 375 } 376 377 /* 378 * This function initializes the i2c attributes and bus 379 * 380 * Parameters: 381 * clk_gpio - The GPIO pin to be used as i2c SCL 382 * data_gpio - The GPIO pin to be used as i2c SDA 383 * 384 * Return Value: 385 * -1 - Fail to initialize the i2c 386 * 0 - Success 387 */ 388 long sm750_sw_i2c_init(unsigned char clk_gpio, unsigned char data_gpio) 389 { 390 int i; 391 392 /* 393 * Return 0 if the GPIO pins to be used is out of range. The 394 * range is only from [0..63] 395 */ 396 if ((clk_gpio > 31) || (data_gpio > 31)) 397 return -1; 398 399 if (sm750_get_chip_type() == SM750LE) 400 return sm750le_i2c_init(clk_gpio, data_gpio); 401 402 /* Initialize the GPIO pin for the i2c Clock Register */ 403 sw_i2c_clk_gpio_mux_reg = GPIO_MUX; 404 sw_i2c_clk_gpio_data_reg = GPIO_DATA; 405 sw_i2c_clk_gpio_data_dir_reg = GPIO_DATA_DIRECTION; 406 407 /* Initialize the Clock GPIO Offset */ 408 sw_i2c_clk_gpio = clk_gpio; 409 410 /* Initialize the GPIO pin for the i2c Data Register */ 411 sw_i2c_data_gpio_mux_reg = GPIO_MUX; 412 sw_i2c_data_gpio_data_reg = GPIO_DATA; 413 sw_i2c_data_gpio_data_dir_reg = GPIO_DATA_DIRECTION; 414 415 /* Initialize the Data GPIO Offset */ 416 sw_i2c_data_gpio = data_gpio; 417 418 /* Enable the GPIO pins for the i2c Clock and Data (GPIO MUX) */ 419 poke32(sw_i2c_clk_gpio_mux_reg, 420 peek32(sw_i2c_clk_gpio_mux_reg) & ~(1 << sw_i2c_clk_gpio)); 421 poke32(sw_i2c_data_gpio_mux_reg, 422 peek32(sw_i2c_data_gpio_mux_reg) & ~(1 << sw_i2c_data_gpio)); 423 424 /* Enable GPIO power */ 425 sm750_enable_gpio(1); 426 427 /* Clear the i2c lines. */ 428 for (i = 0; i < 9; i++) 429 sw_i2c_stop(); 430 431 return 0; 432 } 433 434 /* 435 * This function reads the slave device's register 436 * 437 * Parameters: 438 * addr - i2c Slave device address which register 439 * to be read from 440 * reg - Slave device's register to be read 441 * 442 * Return Value: 443 * Register value 444 */ 445 unsigned char sm750_sw_i2c_read_reg(unsigned char addr, unsigned char reg) 446 { 447 unsigned char data; 448 449 /* Send the Start signal */ 450 sw_i2c_start(); 451 452 /* Send the device address */ 453 sw_i2c_write_byte(addr); 454 455 /* Send the register index */ 456 sw_i2c_write_byte(reg); 457 458 /* Get the bus again and get the data from the device read address */ 459 sw_i2c_start(); 460 sw_i2c_write_byte(addr + 1); 461 data = sw_i2c_read_byte(1); 462 463 /* Stop swI2C and release the bus */ 464 sw_i2c_stop(); 465 466 return data; 467 } 468 469 /* 470 * This function writes a value to the slave device's register 471 * 472 * Parameters: 473 * addr - i2c Slave device address which register 474 * to be written 475 * reg - Slave device's register to be written 476 * data - Data to be written to the register 477 * 478 * Result: 479 * 0 - Success 480 * -1 - Fail 481 */ 482 long sm750_sw_i2c_write_reg(unsigned char addr, 483 unsigned char reg, 484 unsigned char data) 485 { 486 long ret = 0; 487 488 /* Send the Start signal */ 489 sw_i2c_start(); 490 491 /* Send the device address and read the data. All should return success 492 * in order for the writing processed to be successful 493 */ 494 if ((sw_i2c_write_byte(addr) != 0) || 495 (sw_i2c_write_byte(reg) != 0) || 496 (sw_i2c_write_byte(data) != 0)) { 497 ret = -1; 498 } 499 500 /* Stop i2c and release the bus */ 501 sw_i2c_stop(); 502 503 return ret; 504 } 505