medfield 平台 lvds bridge 驱动与console的关系

xxha000721

这也是个I2C 驱动，挂接在 I2C_2 总线上。

初始化如下：

1. /* ************************************************************************* *\
   
2.  * FUNCTION: dsi_lvds_bridge_init
   
3.  *
   
4.  * DESCRIPTION: Driver Init function for lvds bridge
   
5.  *
   
6. \* ************************************************************************* */
   
7. static int __init dsi_lvds_bridge_init(void)
   
8. {
   
9.     int ret = 0;
   
10.     struct i2c_adapter *adapter = NULL;
    
11.     struct i2c_client *client = NULL;
    
12.     struct i2c_board_info info;
    
13. 
    
14.     printk(KERN_INFO "[DISPLAY] %s: Enter\n", __func__);
    
15. 
    
16.     ret = misc_register(&dsi_lvds_bridge_dev);
    
17.     if (ret) {
    
18.         printk(KERN_ERR "[DISPLAY] %s: Can not register misc device.\n", __func__);
    
19.         return ret;
    
20.     }
    
21. 
    
22.     adapter = i2c_get_adapter(2); /*DV0 is on I2C bus 2 */
    
23.     if (!adapter) {
    
24.         printk(KERN_ERR "[DISPLAY] %s: Can not get bridge i2c adapter.\n", __func__);
    
25.         return 0;
    
26.     }
    
27. 
    
28.     /* Setup the i2c board info with the device type and
    
29.      the device address. */
    
30.     memset(&info, 0, sizeof(info));
    
31.     strlcpy(info.type, "i2c_disp_brig", sizeof(info.type));
    
32. 
    
33.     info.addr = 0x0F; /*I2C2 address 0x0F */
    
34. 
    
35.     /* Create the i2c client */
    
36.     client = i2c_new_device(adapter, &info);
    
37.     if (!client) {
    
38.         printk(KERN_ERR "[DISPLAY] %s: ERROR, i2c client=NULL\n", __func__);
    
39.         return -1;
    
40.     }
    
41. 
    
42.     ret = i2c_add_driver(&dsi_lvds_bridge_i2c_driver);
    
43. 
    
44.     printk(KERN_INFO "[DISPLAY] %s: Exit, ret = %d\n", __func__, ret);
    
45. 
    
46.     return 0;
    
47. }

1. /* ************************************************************************* *\
   
2.  * FUNCTION: dsi_lvds_bridge_exit
   
3.  *
   
4.  * DESCRIPTION: Driver exit function for lvds bridge
   
5.  *
   
6. \* ************************************************************************* */
   
7. static void __exit dsi_lvds_bridge_exit(void)
   
8. {
   
9.     printk(KERN_INFO "[DISPLAY] %s\n", __func__);
   
10. 
    
11.     misc_deregister(&dsi_lvds_bridge_dev);
    
12. 
    
13.     i2c_del_driver(&dsi_lvds_bridge_i2c_driver);
    
14. }
    
15. 
    
16. 
    
17. module_init(dsi_lvds_bridge_init);
    
18. module_exit(dsi_lvds_bridge_exit);

初始化用到的几个结构体：

1. static const struct i2c_device_id dsi_lvds_bridge_id[] = {
   
2.     { "i2c_disp_brig", 0 },
   
3.     { }
   
4. };
   
5. MODULE_DEVICE_TABLE(i2c, dsi_lvds_bridge_id);
   
6. 
   
7. static struct i2c_driver dsi_lvds_bridge_i2c_driver = {
   
8.     .driver = {
   
9.         .name = "i2c_disp_brig",
   
10.     },
    
11.     .id_table = dsi_lvds_bridge_id,
    
12.     .probe = dsi_lvds_bridge_probe,
    
13.     .remove = dsi_lvds_bridge_remove,
    
14. };

1. static const struct file_operations mipi_dsi_dev_fops = {
   
2.     .owner = THIS_MODULE,
   
3.     .unlocked_ioctl = dsi_lvds_dev_ioctl,
   
4. };
   
5. 
   
6. static struct miscdevice dsi_lvds_bridge_dev = {
   
7.     .minor = MISC_DYNAMIC_MINOR,
   
8.     .name = "mipi_dsi",
   
9.     .fops = &mipi_dsi_dev_fops,
   
10. };

dsi_lvds_bridge_probe()

1. /* ************************************************************************* *\
   
2.  * FUNCTION: dsi_lvds_bridge_probe
   
3.  *
   
4.  * DESCRIPTION: Probe function for LVDS bridge.
   
5.  *
   
6. \* ************************************************************************* */
   
7. static int dsi_lvds_bridge_probe(struct i2c_client *client, const struct i2c_device_id *id)
   
8. {
   
9.     printk(KERN_INFO "[DISPLAY] %s: Enter\n", __func__);
   
10. 
    
11.     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
    
12.         printk(KERN_ERR "[DISPLAY] %s: Check I2C functionality failed.\n", __func__);
    
13.         return -ENODEV;
    
14.     }
    
15. 
    
16.     dsi_lvds_inst = kzalloc(sizeof(struct dsi_lvds_bridge_instance), GFP_KERNEL);
    
17. 
    
18.     if (dsi_lvds_inst == NULL) {
    
19.         printk(KERN_ERR "[DISPLAY] %s: Can not allocate memory.\n", __func__);
    
20.         return -ENOMEM;
    
21.     }
    
22. 
    
23.     dsi_lvds_inst->client = client;
    
24. 
    
25.     i2c_set_clientdata(client, dsi_lvds_inst);
    
26. 
    
27.     dsi_lvds_inst->client->addr = 0x0F;
    
28. 
    
29.     printk(KERN_INFO "[DISPLAY] %s: Exit\n", __func__);
    
30. 
    
31.     return 0;
    
32. }

1. use GPIO to reset lvds state

1. /* ************************************************************************* *\
   
2.  * FUNCTION: dsi_lvds_set_bridge_reset_state
   
3.  *
   
4.  * DESCRIPTION: This function uses GPIO to force in and out of reset state.
   
5. \* ************************************************************************* */
   
6. void dsi_lvds_set_bridge_reset_state(int state)
   
7. {
   
8.     printk(KERN_INFO "[DISPLAY ] %s: state = %d, gpio = %d\n", __func__, state, gpio_get_value(GPIO_MIPI_BRIDGE_RESET));
   
9. 
   
10.     if (state) {
    
11.         gpio_direction_output(GPIO_MIPI_BRIDGE_RESET, 0);
    
12.         gpio_set_value_cansleep(GPIO_MIPI_BRIDGE_RESET, 0);
    
13.         mdelay(10);
    
14.     } else {
    
15. 
    
16.         gpio_direction_output(GPIO_MIPI_BRIDGE_RESET, 0);
    
17.         gpio_set_value_cansleep(GPIO_MIPI_BRIDGE_RESET, 0); /*Pull MIPI Bridge reset pin to Low */
    
18.         mdelay(20);
    
19.         gpio_direction_output(GPIO_MIPI_BRIDGE_RESET, 1);
    
20.         gpio_set_value_cansleep(GPIO_MIPI_BRIDGE_RESET, 1); /*Pull MIPI Bridge reset pin to High */
    
21.         mdelay(40);
    
22.     }
    
23. }

2. dsi_lvds_configure_lvds_bridge (） ， 用I2C总线，配置lvds bridge设备。

1. /* ************************************************************************* *\
   
2.  * FUNCTION: dsi_lvds_configure_lvds_bridge
   
3.  *
   
4.  * DESCRIPTION: This function uses I2C interface to set bridge registers.
   
5.  * to configure timings and MIPI lanes.
   
6. \* ************************************************************************* */
   
7. void dsi_lvds_configure_lvds_bridge(struct drm_device *dev)
   
8. {
   
9.     if (lvds_disp_init) {
   
10.         printk(KERN_ALERT "[DISPLAY ] %s is already initialized\n", __func__);
    
11.         return;
    
12.     }
    
13. 
    
14.     printk(KERN_INFO "[DISPLAY ]%s: Enter\n", __func__);
    
15. 
    
16.     DSI_I2C_ByteWrite(0x013C, 0x00050006, 6); /*PPI_TX_RX_TA, BTA parameters */
    
17.     DSI_I2C_ByteRead(0x013C, 4);
    
18.     DSI_I2C_ByteWrite(0x0114, 0x00000004, 6); /*PPI_LPTXTIMCNT */
    
19. 
    
20. #ifdef FIXME_MLD // DV0.9 changes
    
21.     DSI_I2C_ByteWrite(0x0164, 0x00000007, 6); /*PPI_D0S_CLRSIPOCOUNT */
    
22.     DSI_I2C_ByteWrite(0x0168, 0x00000007, 6); /*PPI_D1S_CLRSIPOCOUNT */
    
23.     DSI_I2C_ByteWrite(0x016c, 0x00000007, 6); /*PPI_D2S_CLRSIPOCOUNT */
    
24.     DSI_I2C_ByteWrite(0x0170, 0x00000007, 6); /*PPI_D3S_CLRSIPOCOUNT */
    
25. #else
    
26.     DSI_I2C_ByteWrite(0x0164, 0x00000001, 6); /*PPI_D0S_CLRSIPOCOUNT */
    
27.     DSI_I2C_ByteWrite(0x0168, 0x00000001, 6); /*PPI_D1S_CLRSIPOCOUNT */
    
28.     DSI_I2C_ByteWrite(0x016c, 0x00000001, 6); /*PPI_D2S_CLRSIPOCOUNT */
    
29.     DSI_I2C_ByteWrite(0x0170, 0x00000001, 6); /*PPI_D3S_CLRSIPOCOUNT */
    
30. #endif
    
31.     /*Enabling MIPI & PPI lanes, Enable 4 lanes */
    
32.     DSI_I2C_ByteWrite(0x0134, 0x0000001F, 6); /*PPI_LANEENABLE */
    
33.     DSI_I2C_ByteWrite(0x0210, 0x0000001F, 6); /*DSI_LANEENABLE */
    
34.     DSI_I2C_ByteWrite(0x0104, 0x00000001, 6); /*PPI_SARTPPI */
    
35.     DSI_I2C_ByteWrite(0x0204, 0x00000001, 6); /*DSI_SARTPPI */
    
36. 
    
37. #ifdef FIXME_MLD
    
38.     /*Setting LVDS output frequency */
    
39.     DSI_I2C_ByteWrite(0x04A0, 0x00000006, 6); /*LVDS PHY Register 0 (LVPHY0) */
    
40. 
    
41.     /*Calculating video panel control settings */
    
42.     /*Setting video panel control register */
    
43.     DSI_I2C_ByteWrite(0x0450, 0x00000130, 6); /*VPCTRL, Video Path Control, VTGen=ON */
    
44. 
    
45.     /*Setting display timing registers */
    
46.     DSI_I2C_ByteWrite(0x0454, 0x0064000A, 6); /*HTIM1, HBPR=100, HPW=10 */
    
47. 
    
48.     DSI_I2C_ByteWrite(0x0458, 0x00BE0400, 6); /*HTIM2, HFPR=190, HDISPR=1024 */
    
49.     DSI_I2C_ByteWrite(0x045c, 0x000F0005, 6); /*VTIM1, VBPR=15, VPW=5 */
    
50.     DSI_I2C_ByteWrite(0x0460, 0x000F0258, 6); /*VTIM2, VFPR=15, VDISPR=600 */

1. #else
   
2.     /*Setting LVDS output frequency */
   
3.     DSI_I2C_ByteWrite(0x04A0, 0x00048006, 6); /*LVDS PHY Register 0 (LVPHY0) */
   
4. 
   
5.     /*Calculating video panel control settings */
   
6.     /*Setting video panel control register */
   
7.     DSI_I2C_ByteWrite(0x0450, 0x00000120, 6); /*VPCTRL, Video Path Control, VTGen=ON */
   
8. 
   
9.     /*Setting display timing registers */
   
10.     DSI_I2C_ByteWrite(0x0454, 0x00280028, 6); /*HTIM1, HBPR=100, HPW=10 */
    
11. 
    
12.     DSI_I2C_ByteWrite(0x0458, 0x00500500, 6); /*HTIM2, HFPR=190, HDISPR=1024 */
    
13.     DSI_I2C_ByteWrite(0x045c, 0x000e000a, 6); /*VTIM1, VBPR=15, VPW=5 */
    
14.     DSI_I2C_ByteWrite(0x0460, 0x000e0320, 6); /*VTIM2, VFPR=15, VDISPR=600 */
    
15. #endif
    
16. 
    
17.     DSI_I2C_ByteWrite(0x0464, 0x00000001, 6); /*VFUEN */
    
18. 
    
19.     /*Setting LVDS bit arrangement */
    
20.     DSI_I2C_ByteWrite(0x0480, 0x03020100, 6); /*LVMX0003 */
    
21.     DSI_I2C_ByteWrite(0x0484, 0x08050704, 6); /*LVMX0407 */
    
22.     DSI_I2C_ByteWrite(0x0488, 0x0F0E0A09, 6); /*LVMX0811 */
    
23.     DSI_I2C_ByteWrite(0x048C, 0x100D0C0B, 6); /*LVMX1215 */
    
24.     DSI_I2C_ByteWrite(0x0490, 0x12111716, 6); /*LVMX1619 */
    
25.     DSI_I2C_ByteWrite(0x0494, 0x1B151413, 6); /*LVMX2023 */
    
26.     DSI_I2C_ByteWrite(0x0498, 0x061A1918, 6); /*LVMX2427 */
    
27. 
    
28. #ifdef FIXME_MLD //DV0.9 changes
    
29.     DSI_I2C_ByteWrite(0x049c, 0x00000101, 6); /*LVCFG */
    
30. #else
    
31.     DSI_I2C_ByteWrite(0x049c, 0x00000001, 6); /*LVCFG */
    
32. #endif
    
33. 
    
34.     DSI_I2C_ByteWrite(0x0288, 0xFFFFFFFF, 6); /*DSI_INTCLR */
    
35. 
    
36.     lvds_disp_init = 1;
    
37. 
    
38.     printk(KERN_INFO "[DISPLAY]%s: Exit\n", __func__);
    
39. 
    
40. }

3. panel on/off

1. /* ************************************************************************* *\
   
2.  * FUNCTION: dsi_lvds_toshiba_bridge_panel_off
   
3.  *
   
4.  * DESCRIPTION: This function uses GPIO to turn OFF panel.
   
5. \* ************************************************************************* */
   
6. void dsi_lvds_toshiba_bridge_panel_off(void)
   
7. {
   
8.     printk(KERN_INFO "[DISPLAY ] %s\n", __func__);
   
9. 
   
10.     gpio_direction_output(GPIO_MIPI_LCD_STBYB, 0);
    
11.     gpio_set_value_cansleep(GPIO_MIPI_LCD_STBYB, 0); /*Pull LCD_STBYB pin to Low */
    
12.     mdelay(1);
    
13. 
    
14.     gpio_direction_output(GPIO_MIPI_PANEL_RESET, 0);
    
15.     gpio_set_value_cansleep(GPIO_MIPI_PANEL_RESET, 0);
    
16.     mdelay(1);
    
17. }
    
18. 
    
19. /* ************************************************************************* *\
    
20.  * FUNCTION: dsi_lvds_toshiba_bridge_panel_on
    
21.  *
    
22.  * DESCRIPTION: This function uses GPIO to turn ON panel.
    
23. \* ************************************************************************* */
    
24. void dsi_lvds_toshiba_bridge_panel_on(void)
    
25. {
    
26.     printk(KERN_INFO "[DISPLAY ] %s\n", __func__);
    
27. 
    
28.     /* set following pin to low */
    
29.     gpio_direction_output(GPIO_MIPI_LCD_STBYB, 0);
    
30.     gpio_set_value_cansleep(GPIO_MIPI_LCD_STBYB, 0); /*Pull LCD_STBYB pin to Low */
    
31. 
    
32.     gpio_direction_output(GPIO_MIPI_PANEL_RESET, 0);
    
33.     gpio_set_value_cansleep(GPIO_MIPI_PANEL_RESET, 0);
    
34. 
    
35.     gpio_direction_output(GPIO_MIPI_LCD_VADD, 0);
    
36.     gpio_set_value_cansleep(GPIO_MIPI_LCD_VADD, 0);
    
37. 
    
38.     gpio_direction_output(GPIO_MIPI_LCD_BIAS_EN, 0);
    
39.     gpio_set_value_cansleep(GPIO_MIPI_LCD_BIAS_EN, 0);
    
40.     mdelay(10);
    
41. 
    
42.     /* STBYB */
    
43.     gpio_direction_output(GPIO_MIPI_LCD_STBYB, 1);
    
44.     gpio_set_value_cansleep(GPIO_MIPI_LCD_STBYB, 1); /*Pull LCD_STBYB pin to High */
    
45.     mdelay(10);
    
46. 
    
47.     /* VADD */
    
48.     gpio_direction_output(GPIO_MIPI_LCD_VADD, 1);
49.     mdelay(50);
    
50. 
    
51.     /* RESET */
    
52.     gpio_direction_output(GPIO_MIPI_PANEL_RESET, 1);
    
53.     gpio_set_value_cansleep(GPIO_MIPI_PANEL_RESET, 1);
    
54.     mdelay(100);
    
55. 
    
56.     /* BIAS */
    
57.     gpio_direction_output(GPIO_MIPI_LCD_BIAS_EN, 1);
    
58.     gpio_set_value_cansleep(GPIO_MIPI_LCD_BIAS_EN, 1);
    
59. 
    
60. }

4. init  / deinit

1. /* ************************************************************************* *\
   
2.  * FUNCTION: dsi_lvds_init_lvds_bridge
   
3.  *
   
4.  * DESCRIPTION: This function does all one time init. Currently defining
   
5.  * GPIOs only.
   
6. \* ************************************************************************* */
   
7. void dsi_lvds_init_lvds_bridge(struct drm_device *dev)
   
8. {
   
9.     /* request GPIOs */
   
10.     gpio_request(GPIO_MIPI_BRIDGE_RESET, "display");
    
11.     gpio_request(GPIO_MIPI_PANEL_RESET , "display");
    
12.     gpio_request(GPIO_MIPI_LCD_STBYB, "display");
    
13.     gpio_request(GPIO_MIPI_LCD_BIAS_EN, "display");
    
14.     gpio_request(GPIO_MIPI_LCD_VADD, "display");
    
15. }
    
16. 
    
17. /* ************************************************************************* *\
    
18.  * FUNCTION: dsi_lvds_deinit_lvds_bridge
    
19.  *
    
20.  * DESCRIPTION: This function does is called during deinit time.
    
21.  *
    
22. \* ************************************************************************* */
    
23. void dsi_lvds_deinit_lvds_bridge(struct drm_device *dev)
    
24. {
    
25.     if (!lvds_disp_init) {
    
26.         printk(KERN_ALERT "[DISPLAY ] %s has not initialized\n", __func__);
    
27.         return;
    
28.     }
    
29. 
    
30.     printk(KERN_INFO "[DISPLAY ] Enter %s\n", __func__);
    
31. 
    
32. 
    
33.     lvds_disp_init = 0;
    
34. }

5. get params

1. /* ************************************************************************* *\
   
2.  * FUNCTION: dsi_lvds_bridge_get_display_params
   
3.  *
   
4.  * DESCRIPTION: This function is a callback to get the panel resolution and
   
5.  * timing settings.
   
6.  *
   
7. \* ************************************************************************* */
   
8. void dsi_lvds_bridge_get_display_params(struct drm_display_mode *mode)
   
9. {
   
10. #ifdef FIXME_MLD // Changes for DV0.9 display
    
11. /* This settings is for 1024*600 panel*/
    
12.     mode->hdisplay = 1024;
    
13.     mode->vdisplay = 600;
    
14.     mode->hsync_start = 1655;
    
15.     mode->hsync_end = 1665;
    
16.     mode->htotal = 1765;
    
17.     mode->vsync_start = 615;
    
18.     mode->vsync_end = 620;
    
19.     mode->vtotal = 635;
    
20.     mode->clock = 33324;
    
21. #else
    
22.     mode->hdisplay = 1200;
    
23.     mode->vdisplay = 800;
    
24.     mode->hsync_start = 1360;
    
25.     mode->hsync_end = 1400;
    
26.     mode->htotal = 1440;
    
27.     mode->vsync_start = 814;
    
28.     mode->vsync_end = 824;
    
29.     mode->vtotal = 838;
    
30.     mode->clock = 33324;
    
31. #endif //end FIXME_MLD
    
32. 
    
33.     printk(KERN_INFO "[DISPLAY]: hdisplay(w) is %d\n", mode->hdisplay);
    
34.     printk(KERN_INFO "[DISPLAY]: vdisplay(h) is %d\n", mode->vdisplay);
    
35.     printk(KERN_INFO "[DISPLAY]: HSS is %d\n", mode->hsync_start);
    
36.     printk(KERN_INFO "[DISPLAY]: HSE is %d\n", mode->hsync_end);
    
37.     printk(KERN_INFO "[DISPLAY]: htotal is %d\n", mode->htotal);
    
38.     printk(KERN_INFO "[DISPLAY]: VSS is %d\n", mode->vsync_start);
    
39.     printk(KERN_INFO "[DISPLAY]: VSE is %d\n", mode->vsync_end);
    
40.     printk(KERN_INFO "[DISPLAY]: vtotal is %d\n", mode->vtotal);
    
41.     printk(KERN_INFO "[DISPLAY]: clock is %d\n", mode->clock);
    
42. }

7. 具体动作： read / write

1. /* ************************************************************************* *\
   
2.  * FUNCTION: DSI_I2C_ByteRead
   
3.  *
   
4.  * DESCRIPTION: Local functions to read I2C registers
   
5.  *
   
6. \* ************************************************************************* */
   
7. static int DSI_I2C_ByteRead(u16 reg, int count)
   
8. {
   
9.     if (dsi_lvds_inst->client)
   
10.         return __DSI_I2C_ByteRead(reg, count);
    
11.     else
    
12.         return -EIO;
    
13. }

1. /* ************************************************************************* *\
   
2.  * FUNCTION: __DSI_I2C_ByteRead
   
3.  *
   
4.  * DESCRIPTION: Local functions to process read req for I2C registers
   
5.  *
   
6. \* ************************************************************************* */
   
7. static int __DSI_I2C_ByteRead(u16 reg, int count)
   
8. {
   
9.     char rxData[4] = {0};
   
10.     char regData[2] = {0};
    
11.     struct i2c_msg msgs[] = {
    
12.         {
    
13.          .addr = dsi_lvds_inst->client->addr,
    
14.          .flags = 0,
    
15.          .len = 2,
    
16.          },
    
17.         {
    
18.          .addr = dsi_lvds_inst->client->addr,
    
19.          .flags = I2C_M_RD,
    
20.          .len = count - 2,
    
21.          },
    
22.     };
    
23. 
    
24.     regData[0] = (reg & 0xFF00) >> 8;
    
25.     regData[1] = reg & 0xFF;
    
26. 
    
27.     msgs[0].buf = regData;
    
28.     msgs[1].buf = rxData;
    
29. 
    
30.     printk(KERN_INFO "Register: 0x%x\n", reg);
    
31.     if (i2c_transfer(dsi_lvds_inst->client->adapter, msgs, 2) < 0) {
    
32.         printk(KERN_ERR "[DISPLAY] %s: transfer error\n", __func__);
    
33.         return -EIO;
    
34.     } else if (count > 2) {
    
35.         int i = 0;
    
36.         for (i = count - 3; i > -1; --i)
    
37.             printk(KERN_INFO "%02x ", rxData[i]);
    
38.         printk(KERN_INFO "\n");
    
39.         return rxData[0];
    
40.     }
    
41.     return 0;
    
42. }

1. /* ************************************************************************* *\
   
2.  * FUNCTION: DSI_I2C_ByteWrite
   
3.  *
   
4.  * DESCRIPTION: Local functions to issue write req for I2C registers
   
5.  *
   
6. \* ************************************************************************* */
   
7. static int DSI_I2C_ByteWrite(u16 reg, u32 data, int count)
   
8. {
   
9.     if (dsi_lvds_inst->client)
   
10.         return __DSI_I2C_ByteWrite(reg, data, count);
    
11.     else
    
12.         return -EIO;
    
13. }

1. /* ************************************************************************* *\
   
2.  * FUNCTION: __DSI_I2C_ByteWrite
   
3.  *
   
4.  * DESCRIPTION: Local functions to process write req for I2C registers
   
5.  *
   
6. \* ************************************************************************* */
   
7. static int __DSI_I2C_ByteWrite(u16 reg, u32 data, int count)
   
8. {
   
9.     char txData[6] = {0};
   
10.     struct i2c_msg msg[] = {
    
11.         {
    
12.          .addr = dsi_lvds_inst->client->addr,
    
13.          .flags = 0,
    
14.          .len = count,
    
15.          },
    
16.     };
    
17. 
    
18.     /*Set the register */
    
19.     txData[0] = (reg & 0xFF00) >> 8;
    
20.     txData[1] = reg & 0xFF;
    
21. 
    
22.     if (count == 6) {
    
23.         /*Set the data */
    
24.         txData[2] = (data & 0xFF);
    
25.         txData[3] = (data & 0xFF00) >> 8;
    
26.         txData[4] = (data & 0xFF0000) >> 16;
    
27.         txData[5] = (data & 0xFF000000) >> 24;
    
28.     } else {
    
29.         /* Not valid for this bridge chipset */
    
30.     }
    
31. 
    
32.     printk(KERN_INFO "[DISPLAY] %s: addr = %x, reg = %x, data = %x\n",
    
33.         __func__, dsi_lvds_inst->client->addr, reg, data);
    
34. 
    
35.     msg[0].buf = txData;
    
36. 
    
37.     if (i2c_transfer(dsi_lvds_inst->client->adapter, msg, 1) < 0) {
    
38.         printk(KERN_ERR "[DISPLAY] %s: transfer error\n", __func__);
    
39.         return -EIO;
    
40.     } else {
    
41.         return 0;
    
42.     }
    
43. }