drivers/video/sprdfb/sprdfb_i2c.c

   1 /*\r
   2  * Copyright (C) 2012 Spreadtrum Communications Inc.\r
   3  *\r
   4  */\r
   5 #include <common.h>\r
   6 \r
   7 #include <asm/arch/sprd_lcd.h>\r
   8 #include <asm/arch/sprd_i2c.h>\r
   9 #include "sprdfb.h"\r
  10 \r
  11 #define SPRDFB_I2C_TRY_NUM (4)\r
  12 #define msleep(ms) udelay(ms*1000)\r
  13 \r
  14 uint16_t sprdfb_i2c_init(struct sprdfb_device *dev)\r
  15 {\r
  16         I2C_Init(10);\r
  17         return 1;\r
  18 }\r
  19 \r
  20 uint16_t sprdfb_i2c_uninit(struct sprdfb_device *dev)\r
  21 {\r
  22 \r
  23         return 1;\r
  24 }\r
  25 \r
  26 \r
  27 /*write i2c, reg is 8 bit, val is 8 bit*/\r
  28 static int32_t sprdfb_i2c_write_8bits(uint8 addr, uint8_t reg, uint8_t val)\r
  29 {\r
  30         uint8_t buf_w[2];\r
  31         uint32_t i = 0;\r
  32         int32_t ret = -1;\r
  33 \r
  34         if (0xFF == reg) {\r
  35                 mdelay(val);\r
  36                 FB_PRINT("sprdfb: [%s], sleep %d\n", __FUNCTION__,  val);\r
  37                 return 0;\r
  38         }\r
  39 \r
  40         buf_w[0] = reg;\r
  41         buf_w[1] = val;\r
  42         for (i = 0; i < SPRDFB_I2C_TRY_NUM; i++) {\r
  43                 ret = I2C_WriteCmdArr(addr, buf_w, 2, TRUE);\r
  44                 if (ret != ERR_I2C_NONE) {\r
  45                         printf("sprdfb:[%s] write panel reg fai, ret : %d, I2C w addr: 0x%x, \n",\r
  46                              __FUNCTION__, ret, addr);\r
  47                         ret = -1;\r
  48                         msleep(20);\r
  49                 }else{\r
  50                         ret = 0;\r
  51                         break;\r
  52                 }\r
  53         }\r
  54         return ret;\r
  55 }\r
  56 \r
  57 \r
  58 /*read i2c, reg is 8 bit, val is 8 bit*/\r
  59 static int32_t sprdfb_i2c_read_8bits(uint8 addr, uint8_t reg, uint8_t *val)\r
  60 {\r
  61         uint32_t i;\r
  62         int32_t ret = -1;\r
  63 \r
  64         for (i = 0; i < SPRDFB_I2C_TRY_NUM; i++) {\r
  65                 ret = I2C_WriteCmd(addr, reg , TRUE);\r
  66                 if (ret != ERR_I2C_NONE) {\r
  67                         printf("sprdfb:[%s]: read i2c reg fail(1), ret: %d, I2C r addr: 0x%x \n",\r
  68                              __FUNCTION__, ret, addr);\r
  69                         *val = 0xff;\r
  70                         ret = -1;\r
  71                         msleep(20);\r
  72                 }else{\r
  73                         ret = 0;\r
  74                         break;\r
  75                 }\r
  76         }\r
  77 \r
  78         for (i = 0; i < SPRDFB_I2C_TRY_NUM; i++) {\r
  79                 ret = I2C_ReadCmd(addr, *val, TRUE);\r
  80                 if (ret != ERR_I2C_NONE) {\r
  81                         printf("sprdfb:[%s]: read i2c reg fail(2), ret: %d, I2C r addr: 0x%x \n",\r
  82                              __FUNCTION__, ret, addr);\r
  83                         *val = 0xff;\r
  84                         ret = -1;\r
  85                         msleep(20);\r
  86                 }else{\r
  87                         ret = 0;\r
  88                         break;\r
  89                 }\r
  90         }\r
  91         return ret;\r
  92 }\r
  93 \r
  94 \r
  95 /*write i2c, reg is 8 or 16 bit, val is 8 or 16bit*/\r
  96 static int32_t sprdfb_i2c_write_16bits(uint8 addr, uint16_t reg, BOOLEAN reg_is_8bit, uint16_t val, BOOLEAN val_is_8bit)\r
  97 {\r
  98         uint8_t cmd[4] = { 0 };\r
  99         uint32_t i = 0;\r
 100         uint32_t cmd_num = 0;\r
 101         int32_t ret = -1;\r
 102 \r
 103         if ((reg_is_8bit && (0xff == reg))||(!reg_is_8bit &&(0xffff == reg))) {\r
 104                 mdelay(val);\r
 105                 FB_PRINT("sprdfb: [%s], sleep %d\n", __FUNCTION__,  val);\r
 106                 return 0;\r
 107         }\r
 108 \r
 109         if (!reg_is_8bit) {\r
 110                 cmd[cmd_num++] = (uint8_t) ((reg >> 8) & 0xff);\r
 111                 cmd[cmd_num++] = (uint8_t) (reg & 0xff);\r
 112         } else {\r
 113                 cmd[cmd_num++] = (uint8_t) reg;\r
 114         }\r
 115 \r
 116         if (!val_is_8bit) {\r
 117                 cmd[cmd_num++] = (uint8_t) ((val >> 8) & 0xff);\r
 118                 cmd[cmd_num++] = (uint8_t) (val & 0xff);\r
 119         } else {\r
 120                 cmd[cmd_num++] = (uint8_t) val;\r
 121         }\r
 122 \r
 123         for (i = 0; i < SPRDFB_I2C_TRY_NUM; i++) {\r
 124                 ret = I2C_WriteCmdArr(addr, cmd, cmd_num, TRUE);\r
 125                 if (ret != ERR_I2C_NONE) {\r
 126                         printf("srpdfb [%s]: write sensor reg fai, ret : %d, I2C w addr: 0x%x, \n",\r
 127                                 __FUNCTION__, ret, addr);\r
 128                         ret = -1;\r
 129                         msleep(20);\r
 130                 } else {\r
 131                         ret = 0;\r
 132                         break;\r
 133                 }\r
 134         }\r
 135         return ret;\r
 136 }\r
 137 \r
 138 \r
 139 /*read i2c, reg is 8 or 16 bit, val is 8 or 16bit*/\r
 140 static int32_t sprdfb_i2c_read_16bits(uint8 addr, uint16_t reg, BOOLEAN reg_is_8bit, uint16_t *val, BOOLEAN val_is_8bit)\r
 141 {\r
 142         uint32_t i = 0;\r
 143         uint8_t cmd[2] = { 0 };\r
 144         uint16_t w_cmd_num = 0;\r
 145         uint16_t r_cmd_num = 0;\r
 146         uint8_t buf_r[2] = { 0 };\r
 147         int32_t ret = -1;\r
 148 \r
 149         if (!reg_is_8bit) {\r
 150                 cmd[w_cmd_num++] = (uint8_t) ((reg >> 8) & 0xff);\r
 151                 cmd[w_cmd_num++] = (uint8_t) (reg & 0xff);\r
 152         } else {\r
 153                 cmd[w_cmd_num++] = (uint8_t) reg;\r
 154         }\r
 155 \r
 156         if (!val_is_8bit) {\r
 157                 r_cmd_num = 2;\r
 158         } else {\r
 159                 r_cmd_num = 1;\r
 160         }\r
 161 \r
 162         for (i = 0; i < SPRDFB_I2C_TRY_NUM; i++) {\r
 163                 ret = I2C_WriteCmdArr(addr, cmd, w_cmd_num, TRUE);\r
 164                 if (ret != ERR_I2C_NONE) {\r
 165                         printf("srpdfb [%s]: read panel reg fail(1), ret : %d, I2C w addr: 0x%x, \n",\r
 166                              __FUNCTION__,ret, addr);\r
 167                         *val = 0xffff;\r
 168                         ret = -1;\r
 169                         msleep(20);\r
 170                 } else {\r
 171                         *val = (r_cmd_num == 1) ? (uint16_t) buf_r[0]\r
 172                             : (uint16_t) ((buf_r[0] << 8) + buf_r[1]);\r
 173                         ret = 0;\r
 174                         break;\r
 175                 }\r
 176         }\r
 177 \r
 178         for (i = 0; i < SPRDFB_I2C_TRY_NUM; i++) {\r
 179                 ret = I2C_ReadCmdArr(addr, buf_r, r_cmd_num, TRUE);\r
 180                 if (ret != ERR_I2C_NONE) {\r
 181                         printf("srpdfb [%s]: read panel reg fail(2), ret : %d, I2C w addr: 0x%x, \n",\r
 182                              __FUNCTION__,ret, addr);\r
 183                         *val = 0xffff;\r
 184                         ret = -1;\r
 185                         msleep(20);\r
 186                 } else {\r
 187                         *val = (r_cmd_num == 1) ? (uint16_t) buf_r[0]\r
 188                             : (uint16_t) ((buf_r[0] << 8) + buf_r[1]);\r
 189                         ret = 0;\r
 190                         break;\r
 191                 }\r
 192         }\r
 193         return ret;\r
 194 }\r
 195 \r
 196 \r
 197 /*write i2c with burst mode*/\r
 198 static int32_t sprdfb_i2c_write_burst(uint8 addr, uint8_t* buf, int num)\r
 199 {\r
 200         uint32_t i = 0;\r
 201         int32_t ret = -1;\r
 202 \r
 203         for (i = 0; i < SPRDFB_I2C_TRY_NUM; i++) {\r
 204                 ret = I2C_WriteCmdArr(addr, buf, num, TRUE);\r
 205                 if (ret != ERR_I2C_NONE) {\r
 206                         printf("srpdfb [%s]: write i2c reg fail, ret : %d, I2C w addr: 0x%x, \n",\r
 207                                 __FUNCTION__, ret, addr);\r
 208                         ret = -1;\r
 209                         msleep(20);\r
 210                 } else {\r
 211                         ret = 0;\r
 212                         break;\r
 213                 }\r
 214         }\r
 215 \r
 216         return ret;\r
 217 }\r
 218 \r
 219 struct ops_i2c sprdfb_i2c_ops = {\r
 220         .i2c_write_8bits = sprdfb_i2c_write_8bits,\r
 221         .i2c_read_8bits = sprdfb_i2c_read_8bits,\r
 222         .i2c_write_16bits = sprdfb_i2c_write_16bits,\r
 223         .i2c_read_16bits = sprdfb_i2c_read_16bits,\r
 224         .i2c_write_burst = sprdfb_i2c_write_burst,\r
 225 };\r
 226 \r