• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  */
sw_i2c_wait(void)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  */
sw_i2c_scl(unsigned char value)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  */
sw_i2c_sda(unsigned char value)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  */
sw_i2c_read_sda(void)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  */
sw_i2c_ack(void)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  */
sw_i2c_start(void)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  */
sw_i2c_stop(void)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  */
sw_i2c_write_byte(unsigned char data)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  */
sw_i2c_read_byte(unsigned char ack)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  */
sm750le_i2c_init(unsigned char clk_gpio,unsigned char data_gpio)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  */
sm750_sw_i2c_init(unsigned char clk_gpio,unsigned char data_gpio)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  */
sm750_sw_i2c_read_reg(unsigned char addr,unsigned char reg)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  */
sm750_sw_i2c_write_reg(unsigned char addr,unsigned char reg,unsigned char data)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