1 // SPDX-License-Identifier: GPL-2.0
2 #define USE_DVICHIP
3 #ifdef USE_DVICHIP
4
5 #include "ddk750_sii164.h"
6 #include "ddk750_hwi2c.h"
7
8 /* I2C Address of each SII164 chip */
9 #define SII164_I2C_ADDRESS 0x70
10
11 /* Define this definition to use hardware i2c. */
12 #define USE_HW_I2C
13
14 #ifdef USE_HW_I2C
15 #define i2cWriteReg sm750_hw_i2c_write_reg
16 #define i2cReadReg sm750_hw_i2c_read_reg
17 #else
18 #define i2cWriteReg sm750_sw_i2c_write_reg
19 #define i2cReadReg sm750_sw_i2c_read_reg
20 #endif
21
22 /* SII164 Vendor and Device ID */
23 #define SII164_VENDOR_ID 0x0001
24 #define SII164_DEVICE_ID 0x0006
25
26 #ifdef SII164_FULL_FUNCTIONS
27 /* Name of the DVI Controller chip */
28 static char *gDviCtrlChipName = "Silicon Image SiI 164";
29 #endif
30
31 /*
32 * sii164GetVendorID
33 * This function gets the vendor ID of the DVI controller chip.
34 *
35 * Output:
36 * Vendor ID
37 */
38 unsigned short sii164GetVendorID(void)
39 {
40 unsigned short vendorID;
41
42 vendorID = ((unsigned short)i2cReadReg(SII164_I2C_ADDRESS, SII164_VENDOR_ID_HIGH) << 8) |
43 (unsigned short)i2cReadReg(SII164_I2C_ADDRESS, SII164_VENDOR_ID_LOW);
44
45 return vendorID;
46 }
47
48 /*
49 * sii164GetDeviceID
50 * This function gets the device ID of the DVI controller chip.
51 *
52 * Output:
53 * Device ID
54 */
55 unsigned short sii164GetDeviceID(void)
56 {
57 unsigned short deviceID;
58
59 deviceID = ((unsigned short)i2cReadReg(SII164_I2C_ADDRESS, SII164_DEVICE_ID_HIGH) << 8) |
60 (unsigned short)i2cReadReg(SII164_I2C_ADDRESS, SII164_DEVICE_ID_LOW);
61
62 return deviceID;
63 }
64
65 /* DVI.C will handle all SiI164 chip stuffs and try it best to make code minimal and useful */
66
67 /*
68 * sii164InitChip
69 * This function initialize and detect the DVI controller chip.
70 *
71 * Input:
72 * edge_select - Edge Select:
73 * 0 = Input data is falling edge latched (falling
74 * edge latched first in dual edge mode)
75 * 1 = Input data is rising edge latched (rising
76 * edge latched first in dual edge mode)
77 * bus_select - Input Bus Select:
78 * 0 = Input data bus is 12-bits wide
79 * 1 = Input data bus is 24-bits wide
80 * dual_edge_clk_select - Dual Edge Clock Select
81 * 0 = Input data is single edge latched
82 * 1 = Input data is dual edge latched
83 * hsync_enable - Horizontal Sync Enable:
84 * 0 = HSYNC input is transmitted as fixed LOW
85 * 1 = HSYNC input is transmitted as is
86 * vsync_enable - Vertical Sync Enable:
87 * 0 = VSYNC input is transmitted as fixed LOW
88 * 1 = VSYNC input is transmitted as is
89 * deskew_enable - De-skewing Enable:
90 * 0 = De-skew disabled
91 * 1 = De-skew enabled
92 * deskew_setting - De-skewing Setting (increment of 260psec)
93 * 0 = 1 step --> minimum setup / maximum hold
94 * 1 = 2 step
95 * 2 = 3 step
96 * 3 = 4 step
97 * 4 = 5 step
98 * 5 = 6 step
99 * 6 = 7 step
100 * 7 = 8 step --> maximum setup / minimum hold
101 * continuous_sync_enable- SYNC Continuous:
102 * 0 = Disable
103 * 1 = Enable
104 * pll_filter_enable - PLL Filter Enable
105 * 0 = Disable PLL Filter
106 * 1 = Enable PLL Filter
107 * pll_filter_value - PLL Filter characteristics:
108 * 0~7 (recommended value is 4)
109 *
110 * Output:
111 * 0 - Success
112 * -1 - Fail.
113 */
114 long sii164InitChip(unsigned char edge_select,
115 unsigned char bus_select,
116 unsigned char dual_edge_clk_select,
117 unsigned char hsync_enable,
118 unsigned char vsync_enable,
119 unsigned char deskew_enable,
120 unsigned char deskew_setting,
121 unsigned char continuous_sync_enable,
122 unsigned char pll_filter_enable,
123 unsigned char pll_filter_value)
124 {
125 unsigned char config;
126
127 /* Initialize the i2c bus */
128 #ifdef USE_HW_I2C
129 /* Use fast mode. */
130 sm750_hw_i2c_init(1);
131 #else
132 sm750_sw_i2c_init(DEFAULT_I2C_SCL, DEFAULT_I2C_SDA);
133 #endif
134
135 /* Check if SII164 Chip exists */
136 if ((sii164GetVendorID() == SII164_VENDOR_ID) && (sii164GetDeviceID() == SII164_DEVICE_ID)) {
137 /*
138 * Initialize SII164 controller chip.
139 */
140
141 /* Select the edge */
142 if (edge_select == 0)
143 config = SII164_CONFIGURATION_LATCH_FALLING;
144 else
145 config = SII164_CONFIGURATION_LATCH_RISING;
146
147 /* Select bus wide */
148 if (bus_select == 0)
149 config |= SII164_CONFIGURATION_BUS_12BITS;
150 else
151 config |= SII164_CONFIGURATION_BUS_24BITS;
152
153 /* Select Dual/Single Edge Clock */
154 if (dual_edge_clk_select == 0)
155 config |= SII164_CONFIGURATION_CLOCK_SINGLE;
156 else
157 config |= SII164_CONFIGURATION_CLOCK_DUAL;
158
159 /* Select HSync Enable */
160 if (hsync_enable == 0)
161 config |= SII164_CONFIGURATION_HSYNC_FORCE_LOW;
162 else
163 config |= SII164_CONFIGURATION_HSYNC_AS_IS;
164
165 /* Select VSync Enable */
166 if (vsync_enable == 0)
167 config |= SII164_CONFIGURATION_VSYNC_FORCE_LOW;
168 else
169 config |= SII164_CONFIGURATION_VSYNC_AS_IS;
170
171 i2cWriteReg(SII164_I2C_ADDRESS, SII164_CONFIGURATION, config);
172
173 /*
174 * De-skew enabled with default 111b value.
175 * This fixes some artifacts problem in some mode on board 2.2.
176 * Somehow this fix does not affect board 2.1.
177 */
178 if (deskew_enable == 0)
179 config = SII164_DESKEW_DISABLE;
180 else
181 config = SII164_DESKEW_ENABLE;
182
183 switch (deskew_setting) {
184 case 0:
185 config |= SII164_DESKEW_1_STEP;
186 break;
187 case 1:
188 config |= SII164_DESKEW_2_STEP;
189 break;
190 case 2:
191 config |= SII164_DESKEW_3_STEP;
192 break;
193 case 3:
194 config |= SII164_DESKEW_4_STEP;
195 break;
196 case 4:
197 config |= SII164_DESKEW_5_STEP;
198 break;
199 case 5:
200 config |= SII164_DESKEW_6_STEP;
201 break;
202 case 6:
203 config |= SII164_DESKEW_7_STEP;
204 break;
205 case 7:
206 config |= SII164_DESKEW_8_STEP;
207 break;
208 }
209 i2cWriteReg(SII164_I2C_ADDRESS, SII164_DESKEW, config);
210
211 /* Enable/Disable Continuous Sync. */
212 if (continuous_sync_enable == 0)
213 config = SII164_PLL_FILTER_SYNC_CONTINUOUS_DISABLE;
214 else
215 config = SII164_PLL_FILTER_SYNC_CONTINUOUS_ENABLE;
216
217 /* Enable/Disable PLL Filter */
218 if (pll_filter_enable == 0)
219 config |= SII164_PLL_FILTER_DISABLE;
220 else
221 config |= SII164_PLL_FILTER_ENABLE;
222
223 /* Set the PLL Filter value */
224 config |= ((pll_filter_value & 0x07) << 1);
225
226 i2cWriteReg(SII164_I2C_ADDRESS, SII164_PLL, config);
227
228 /* Recover from Power Down and enable output. */
229 config = i2cReadReg(SII164_I2C_ADDRESS, SII164_CONFIGURATION);
230 config |= SII164_CONFIGURATION_POWER_NORMAL;
231 i2cWriteReg(SII164_I2C_ADDRESS, SII164_CONFIGURATION, config);
232
233 return 0;
234 }
235
236 /* Return -1 if initialization fails. */
237 return -1;
238 }
239
240 /* below sii164 function is not necessary */
241
242 #ifdef SII164_FULL_FUNCTIONS
243
244 /*
245 * sii164ResetChip
246 * This function resets the DVI Controller Chip.
247 */
248 void sii164ResetChip(void)
249 {
250 /* Power down */
251 sii164SetPower(0);
252 sii164SetPower(1);
253 }
254
255 /*
256 * sii164GetChipString
257 * This function returns a char string name of the current DVI Controller chip.
258 * It's convenient for application need to display the chip name.
259 */
260 char *sii164GetChipString(void)
261 {
262 return gDviCtrlChipName;
263 }
264
265 /*
266 * sii164SetPower
267 * This function sets the power configuration of the DVI Controller Chip.
268 *
269 * Input:
270 * powerUp - Flag to set the power down or up
271 */
272 void sii164SetPower(unsigned char powerUp)
273 {
274 unsigned char config;
275
276 config = i2cReadReg(SII164_I2C_ADDRESS, SII164_CONFIGURATION);
277 if (powerUp == 1) {
278 /* Power up the chip */
279 config &= ~SII164_CONFIGURATION_POWER_MASK;
280 config |= SII164_CONFIGURATION_POWER_NORMAL;
281 i2cWriteReg(SII164_I2C_ADDRESS, SII164_CONFIGURATION, config);
282 } else {
283 /* Power down the chip */
284 config &= ~SII164_CONFIGURATION_POWER_MASK;
285 config |= SII164_CONFIGURATION_POWER_DOWN;
286 i2cWriteReg(SII164_I2C_ADDRESS, SII164_CONFIGURATION, config);
287 }
288 }
289
290 /*
291 * sii164SelectHotPlugDetectionMode
292 * This function selects the mode of the hot plug detection.
293 */
294 static
295 void sii164SelectHotPlugDetectionMode(enum sii164_hot_plug_mode hotPlugMode)
296 {
297 unsigned char detectReg;
298
299 detectReg = i2cReadReg(SII164_I2C_ADDRESS, SII164_DETECT) &
300 ~SII164_DETECT_MONITOR_SENSE_OUTPUT_FLAG;
301 switch (hotPlugMode) {
302 case SII164_HOTPLUG_DISABLE:
303 detectReg |= SII164_DETECT_MONITOR_SENSE_OUTPUT_HIGH;
304 break;
305 case SII164_HOTPLUG_USE_MDI:
306 detectReg &= ~SII164_DETECT_INTERRUPT_MASK;
307 detectReg |= SII164_DETECT_INTERRUPT_BY_HTPLG_PIN;
308 detectReg |= SII164_DETECT_MONITOR_SENSE_OUTPUT_MDI;
309 break;
310 case SII164_HOTPLUG_USE_RSEN:
311 detectReg |= SII164_DETECT_MONITOR_SENSE_OUTPUT_RSEN;
312 break;
313 case SII164_HOTPLUG_USE_HTPLG:
314 detectReg |= SII164_DETECT_MONITOR_SENSE_OUTPUT_HTPLG;
315 break;
316 }
317
318 i2cWriteReg(SII164_I2C_ADDRESS, SII164_DETECT, detectReg);
319 }
320
321 /*
322 * sii164EnableHotPlugDetection
323 * This function enables the Hot Plug detection.
324 *
325 * enableHotPlug - Enable (=1) / disable (=0) Hot Plug detection
326 */
327 void sii164EnableHotPlugDetection(unsigned char enableHotPlug)
328 {
329 unsigned char detectReg;
330
331 detectReg = i2cReadReg(SII164_I2C_ADDRESS, SII164_DETECT);
332
333 /* Depending on each DVI controller, need to enable the hot plug based on each
334 * individual chip design.
335 */
336 if (enableHotPlug != 0)
337 sii164SelectHotPlugDetectionMode(SII164_HOTPLUG_USE_MDI);
338 else
339 sii164SelectHotPlugDetectionMode(SII164_HOTPLUG_DISABLE);
340 }
341
342 /*
343 * sii164IsConnected
344 * Check if the DVI Monitor is connected.
345 *
346 * Output:
347 * 0 - Not Connected
348 * 1 - Connected
349 */
350 unsigned char sii164IsConnected(void)
351 {
352 unsigned char hotPlugValue;
353
354 hotPlugValue = i2cReadReg(SII164_I2C_ADDRESS, SII164_DETECT) &
355 SII164_DETECT_HOT_PLUG_STATUS_MASK;
356 if (hotPlugValue == SII164_DETECT_HOT_PLUG_STATUS_ON)
357 return 1;
358 else
359 return 0;
360 }
361
362 /*
363 * sii164CheckInterrupt
364 * Checks if interrupt has occurred.
365 *
366 * Output:
367 * 0 - No interrupt
368 * 1 - Interrupt occurs
369 */
370 unsigned char sii164CheckInterrupt(void)
371 {
372 unsigned char detectReg;
373
374 detectReg = i2cReadReg(SII164_I2C_ADDRESS, SII164_DETECT) &
375 SII164_DETECT_MONITOR_STATE_MASK;
376 if (detectReg == SII164_DETECT_MONITOR_STATE_CHANGE)
377 return 1;
378 else
379 return 0;
380 }
381
382 /*
383 * sii164ClearInterrupt
384 * Clear the hot plug interrupt.
385 */
386 void sii164ClearInterrupt(void)
387 {
388 unsigned char detectReg;
389
390 /* Clear the MDI interrupt */
391 detectReg = i2cReadReg(SII164_I2C_ADDRESS, SII164_DETECT);
392 i2cWriteReg(SII164_I2C_ADDRESS, SII164_DETECT,
393 detectReg | SII164_DETECT_MONITOR_STATE_CLEAR);
394 }
395
396 #endif
397
398 #endif