drivers/mtk_wcn_combo/common/linux/hw_chrdev_test.c

   1 /******************************************************************************\r
   2 *                         C O M P I L E R   F L A G S\r
   3 *******************************************************************************\r
   4 */\r
   5 \r
   6 /******************************************************************************\r
   7 *                    E X T E R N A L   R E F E R E N C E S\r
   8 *******************************************************************************\r
   9 */\r
  10 #include <linux/init.h>\r
  11 #include <linux/ioctl.h>\r
  12 #include <linux/module.h>\r
  13 #include <linux/types.h>\r
  14 #include <linux/kernel.h>\r
  15 #include <linux/fs.h>\r
  16 #include <linux/cdev.h>\r
  17 #include <linux/sched.h>\r
  18 #include <linux/poll.h>\r
  19 #include <linux/delay.h>\r
  20 #include <asm/current.h>\r
  21 #include <asm/uaccess.h>\r
  22 //for mtk\r
  23 //#include <mach/mt_combo.h>\r
  24 //#include <mach/mt6575_gpio.h>\r
  25 //#include <mach/board.h>\r
  26 //end for mtk\r
  27 \r
  28 //for Ingenic\r
  29 #include <mach/chip-misc.h>\r
  30 #include <mach/chip-gpio.h>\r
  31 #include <mach/chip-pin.h>\r
  32 #include <mach/chip-rtc.h>\r
  33 //end for Ingenic\r
  34 \r
  35 #include "hw_test.h"\r
  36 \r
  37 /******************************************************************************\r
  38 *                              C O N S T A N T S\r
  39 *******************************************************************************\r
  40 */\r
  41 #define GPIO_PMU_PIN GPD27\r
  42 #define GPIO_RST_PIN GPD29\r
  43 #define GPIO_RTC_PIN GPD14\r
  44 #define GPIO_BGF_INT GPF20\r
  45 #define GPIO_WIF_INT GPF21\r
  46 \r
  47 #define HWTEST_DEV_MAJOR 194 // never used number\r
  48 #define HWTEST_DEV_NUM 1\r
  49 \r
  50 /* Linux char device */\r
  51 static int HWTEST_major = HWTEST_DEV_MAJOR;\r
  52 static struct cdev HWTEST_cdev;\r
  53 static atomic_t HWTEST_ref_cnt = ATOMIC_INIT(0);\r
  54 \r
  55 unsigned char** g_read_card_info_bysdio;\r
  56 unsigned char** g_test;\r
  57 \r
  58 UINT8 g_read_current_io_isready_from_sdio_card;\r
  59 UINT16 g_read_function_blksize_from_sdio_card;\r
  60 UINT32 g_read_int_from_sdio_card;\r
  61 \r
  62 /*******************************************************************************\r
  63 *                          F U N C T I O N S\r
  64 ********************************************************************************\r
  65 */\r
  66 #define HWTEST_SUPPORT_PHONE 0\r
  67 #define HWTEST_SUPPORT_SDIO  1\r
  68 \r
  69 \r
  70 int porting_6620_sdio_card_detect()\r
  71 {\r
  72         int ret = -1;\r
  73         //for MTK\r
  74         //ret = mt_combo_sdio_ctrl(2,1);\r
  75         //end for MTK\r
  76         //for Ingenic\r
  77         ret = sdio_card_detect();\r
  78         //end for Ingenic\r
  79         if(!ret){\r
  80                 return 0;\r
  81         }else{\r
  82                 HWTEST_INFO_FUNC("sdio card detect fail");\r
  83                 return -1;\r
  84         }\r
  85 }\r
  86 int porting_6620_sdio_card_remove()\r
  87 {\r
  88         int ret = -1;\r
  89         //for MTK\r
  90         //ret = mt_combo_sdio_ctrl(2,0);\r
  91         //end for MTK\r
  92         //for Ingenic\r
  93         ret = sdio_card_remove();\r
  94         //end for Ingenic\r
  95         if(!ret){\r
  96                 return 0;\r
  97         }else{\r
  98                 HWTEST_INFO_FUNC("sdio card remove fail");\r
  99                 return -1;\r
 100         }\r
 101 }\r
 102 //end for Ingenic\r
 103 \r
 104 int chip_power_on(void)\r
 105 {\r
 106         //int ret = -1;\r
 107 #define MT6620_OFF_TIME (10) /* in ms, workable value */\r
 108 #define MT6620_RST_TIME (30) /* in ms, workable value */\r
 109 #define MT6620_STABLE_TIME (30) /* in ms, workable value */\r
 110 #define MT6620_EXT_INT_TIME (5) /* in ms, workable value */\r
 111 #define MT6620_32K_STABLE_TIME (100) /* in ms, test value */\r
 112 \r
 113 #if 0\r
 114 #if (HWTEST_SUPPORT_PHONE)\r
 115         /* disable pull */    \r
 116     mt_set_gpio_pull_enable(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_PULL_DISABLE);    \r
 117     /* set output */    \r
 118         mt_set_gpio_dir(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_DIR_OUT);    \r
 119         /* set gpio mode */    \r
 120         mt_set_gpio_mode(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_MODE_GPIO);    \r
 121         /* external LDO_EN high */    \r
 122         mt_set_gpio_out(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_OUT_ONE);\r
 123 #endif\r
 124 \r
 125 #if (HWTEST_SUPPORT_SDIO) && (CONFIG_MTK_COMBO_SDIO_SLOT == 0)\r
 126         printk(KERN_INFO "[mt6620] pull up sd0 bus(gpio169~gpio175(exclude gpio174))\n");\r
 127     mt_set_gpio_pull_enable(GPIO172, GPIO_PULL_ENABLE); //->CLK\r
 128     mt_set_gpio_pull_select(GPIO172, GPIO_PULL_UP);             \r
 129     mt_set_gpio_pull_enable(GPIO171, GPIO_PULL_ENABLE); //->CMD\r
 130     mt_set_gpio_pull_select(GPIO171, GPIO_PULL_UP);\r
 131     mt_set_gpio_pull_enable(GPIO175, GPIO_PULL_ENABLE); //->DAT0\r
 132     mt_set_gpio_pull_select(GPIO175, GPIO_PULL_UP);\r
 133     mt_set_gpio_pull_enable(GPIO173, GPIO_PULL_ENABLE); //->DAT1\r
 134     mt_set_gpio_pull_select(GPIO173, GPIO_PULL_UP);\r
 135     mt_set_gpio_pull_enable(GPIO169, GPIO_PULL_ENABLE); //->DAT2\r
 136     mt_set_gpio_pull_select(GPIO169, GPIO_PULL_UP);\r
 137     mt_set_gpio_pull_enable(GPIO170, GPIO_PULL_ENABLE); //->DAT3\r
 138     mt_set_gpio_pull_select(GPIO170, GPIO_PULL_UP);\r
 139 #elif (CONFIG_MTK_COMBO_SDIO_SLOT == 1)\r
 140         #error "error:MSDC1 is not reserved for MT6620 on MT6575EVB"\r
 141 #elif (CONFIG_MTK_COMBO_SDIO_SLOT == 2)\r
 142     printk(KERN_INFO "[mt6620] pull up sd2 bus(gpio182~187)\n");\r
 143     mt_set_gpio_pull_enable(GPIO182, GPIO_PULL_ENABLE); //->CLK\r
 144     mt_set_gpio_pull_select(GPIO182, GPIO_PULL_UP);             \r
 145     mt_set_gpio_pull_enable(GPIO184, GPIO_PULL_ENABLE); //->CMD\r
 146     mt_set_gpio_pull_select(GPIO184, GPIO_PULL_UP);\r
 147     mt_set_gpio_pull_enable(GPIO186, GPIO_PULL_ENABLE); //->DAT0\r
 148     mt_set_gpio_pull_select(GPIO186, GPIO_PULL_UP);\r
 149     mt_set_gpio_pull_enable(GPIO187, GPIO_PULL_ENABLE); //->DAT1\r
 150     mt_set_gpio_pull_select(GPIO187, GPIO_PULL_UP);\r
 151     mt_set_gpio_pull_enable(GPIO185, GPIO_PULL_ENABLE); //->DAT2\r
 152     mt_set_gpio_pull_select(GPIO185, GPIO_PULL_UP);\r
 153     mt_set_gpio_pull_enable(GPIO183, GPIO_PULL_ENABLE); //->DAT3\r
 154     mt_set_gpio_pull_select(GPIO183, GPIO_PULL_UP);\r
 155 #elif (CONFIG_MTK_COMBO_SDIO_SLOT == 3)\r
 156         printk(KERN_INFO "[mt6620] pull up sd3 bus (GPIO89~GPIO94)\n");\r
 157     mt_set_gpio_pull_enable(GPIO92, GPIO_PULL_ENABLE);  //->CLK\r
 158     mt_set_gpio_pull_select(GPIO92, GPIO_PULL_UP);              \r
 159     mt_set_gpio_pull_enable(GPIO91, GPIO_PULL_ENABLE);  //->CMD\r
 160     mt_set_gpio_pull_select(GPIO91, GPIO_PULL_UP);\r
 161     mt_set_gpio_pull_enable(GPIO94, GPIO_PULL_ENABLE);  //->DAT0\r
 162     mt_set_gpio_pull_select(GPIO94, GPIO_PULL_UP);\r
 163     mt_set_gpio_pull_enable(GPIO90, GPIO_PULL_ENABLE);  //->DAT1\r
 164     mt_set_gpio_pull_select(GPIO90, GPIO_PULL_UP);\r
 165     mt_set_gpio_pull_enable(GPIO89, GPIO_PULL_ENABLE);  //->DAT2\r
 166     mt_set_gpio_pull_select(GPIO89, GPIO_PULL_UP);\r
 167     mt_set_gpio_pull_enable(GPIO93, GPIO_PULL_ENABLE);  //->DAT3\r
 168     mt_set_gpio_pull_select(GPIO93, GPIO_PULL_UP);\r
 169 #else\r
 170         #error "error:unsupported CONFIG_MTK_COMBO_SDIO_SLOT" CONFIG_MTK_COMBO_SDIO_SLOT\r
 171 #endif\r
 172 \r
 173     /* UART Mode */\r
 174     ret = mt_set_gpio_mode(GPIO_UART_URXD3_PIN, GPIO_UART_URXD3_PIN_M_URXD);//GPIO_MODE_01->GPIO_UART_URXD3_PIN_M_URXD\r
 175     ret += mt_set_gpio_mode(GPIO_UART_UTXD3_PIN, GPIO_UART_UTXD3_PIN_M_UTXD);//GPIO_MODE_01->GPIO_UART_UTXD3_PIN_M_UTXD\r
 176     //printk(KERN_INFO "[mt6620] set UART GPIO Mode [%d]\n", result);\r
 177 \r
 178     /* disable pull */  \r
 179 #if (HWTEST_SUPPORT_PHONE)\r
 180         mt_set_gpio_pull_enable(GPIO25, GPIO_PULL_DISABLE);\r
 181 #endif\r
 182     ret += mt_set_gpio_pull_enable(GPIO_COMBO_PMU_EN_PIN, GPIO_PULL_DISABLE);\r
 183     ret += mt_set_gpio_pull_enable(GPIO_COMBO_RST_PIN, GPIO_PULL_DISABLE);\r
 184 \r
 185         /* set output */\r
 186 #if (HWTEST_SUPPORT_PHONE)\r
 187         mt_set_gpio_dir(GPIO25, GPIO_DIR_OUT);\r
 188 #endif\r
 189         ret += mt_set_gpio_dir(GPIO_COMBO_PMU_EN_PIN, GPIO_DIR_OUT);\r
 190     ret += mt_set_gpio_dir(GPIO_COMBO_RST_PIN, GPIO_DIR_OUT);\r
 191 \r
 192         /* set gpio mode */\r
 193 #if defined(HWTEST_SUPPORT_PHONE)\r
 194         mt_set_gpio_mode(GPIO25, GPIO_MODE_GPIO);\r
 195 #endif\r
 196     ret += mt_set_gpio_mode(GPIO_COMBO_PMU_EN_PIN, GPIO_MODE_GPIO);\r
 197     ret += mt_set_gpio_mode(GPIO_COMBO_RST_PIN, GPIO_MODE_GPIO);\r
 198 \r
 199     /* SYSRST_B low */\r
 200     ret += mt_set_gpio_out(GPIO_COMBO_RST_PIN, GPIO_OUT_ZERO);\r
 201     /* PMU_EN low */\r
 202 #if (HWTEST_SUPPORT_PHONE)\r
 203         mt_set_gpio_out(GPIO25, GPIO_OUT_ZERO);\r
 204 #endif\r
 205     ret += mt_set_gpio_out(GPIO_COMBO_PMU_EN_PIN, GPIO_OUT_ZERO);\r
 206 \r
 207     msleep(MT6620_OFF_TIME);\r
 208 \r
 209     /* PMU_EN high, SYSRST_B low */\r
 210 #if (HWTEST_SUPPORT_PHONE)\r
 211         mt_set_gpio_out(GPIO25, GPIO_OUT_ONE);\r
 212 #endif\r
 213     ret += mt_set_gpio_out(GPIO_COMBO_PMU_EN_PIN, GPIO_OUT_ONE);\r
 214     msleep(MT6620_RST_TIME);\r
 215 \r
 216     /* SYSRST_B high */\r
 217     ret += mt_set_gpio_out(GPIO_COMBO_RST_PIN, GPIO_OUT_ONE);\r
 218     msleep(MT6620_STABLE_TIME);\r
 219 #endif\r
 220 \r
 221         //for Ingenic\r
 222         rtc_enable_clk32k();\r
 223         msleep(MT6620_32K_STABLE_TIME);\r
 224         __gpio_as_uart2();\r
 225         msleep(30);\r
 226 \r
 227         //PMU_EN-->0\r
 228     __gpio_enable_pull(GPIO_PMU_PIN); \r
 229         __gpio_as_output(GPIO_PMU_PIN);\r
 230         __gpio_clear_pin(GPIO_PMU_PIN);\r
 231     //RST-->0\r
 232     __gpio_enable_pull(GPIO_RST_PIN);        \r
 233         __gpio_as_output(GPIO_RST_PIN);\r
 234         __gpio_clear_pin(GPIO_RST_PIN);\r
 235 \r
 236     msleep(MT6620_OFF_TIME);\r
 237     //PMU_EN-->1\r
 238     __gpio_set_pin(GPIO_PMU);\r
 239     msleep(MT6620_RST_TIME);\r
 240 \r
 241     __gpio_enable_pull(GPIO_RST_PIN);        \r
 242         __gpio_as_output(GPIO_RST_PIN);\r
 243         __gpio_set_pin(GPIO_RST_PIN);\r
 244 \r
 245     msleep(MT6620_STABLE_TIME);\r
 246     printk(KERN_INFO "[mt6620] power on \n");\r
 247 \r
 248     return 0;\r
 249 }\r
 250 \r
 251 \r
 252 int chip_power_off(void)\r
 253 {\r
 254     //int ret = -1;\r
 255     printk(KERN_INFO "[mt6620] power off\n");\r
 256 #if 0\r
 257     /* SYSRST_B low */\r
 258     mt_set_gpio_out(GPIO_COMBO_RST_PIN, GPIO_OUT_ZERO);\r
 259     /* PMU_EN low */\r
 260 #if (HWTEST_SUPPORT_PHONE)\r
 261         mt_set_gpio_out(GPIO25, GPIO_OUT_ZERO);\r
 262 #endif\r
 263     mt_set_gpio_out(GPIO_COMBO_PMU_EN_PIN, GPIO_OUT_ZERO);\r
 264 \r
 265 #if (HWTEST_SUPPORT_SDIO) && (CONFIG_MTK_COMBO_SDIO_SLOT == 0)\r
 266         printk(KERN_INFO "[mt6620] pull down sd0 bus(gpio169~gpio175(exclude gpio174))\n");\r
 267     mt_set_gpio_pull_enable(GPIO172, GPIO_PULL_DOWN);   //->CLK\r
 268     mt_set_gpio_pull_select(GPIO172, GPIO_PULL_ENABLE);         \r
 269     mt_set_gpio_pull_enable(GPIO171, GPIO_PULL_DOWN);   //->CMD\r
 270     mt_set_gpio_pull_select(GPIO171, GPIO_PULL_ENABLE);\r
 271     mt_set_gpio_pull_enable(GPIO175, GPIO_PULL_DOWN);   //->DAT0\r
 272     mt_set_gpio_pull_select(GPIO175, GPIO_PULL_ENABLE);\r
 273     mt_set_gpio_pull_enable(GPIO173, GPIO_PULL_DOWN);   //->DAT1\r
 274     mt_set_gpio_pull_select(GPIO173, GPIO_PULL_ENABLE);\r
 275     mt_set_gpio_pull_enable(GPIO169, GPIO_PULL_DOWN);   //->DAT2\r
 276     mt_set_gpio_pull_select(GPIO169, GPIO_PULL_ENABLE);\r
 277     mt_set_gpio_pull_enable(GPIO170, GPIO_PULL_DOWN);   //->DAT3\r
 278     mt_set_gpio_pull_select(GPIO170, GPIO_PULL_ENABLE);\r
 279 #elif (CONFIG_MTK_COMBO_SDIO_SLOT == 1)\r
 280         #error "error:MSDC1 is not reserved for MT6620 on MT6575EVB"\r
 281 #elif (CONFIG_MTK_COMBO_SDIO_SLOT == 2)\r
 282     printk(KERN_INFO "[mt6620] pull down sd2 bus(gpio182~187)\n");\r
 283     mt_set_gpio_pull_enable(GPIO182, GPIO_PULL_DOWN);   //->CLK\r
 284     mt_set_gpio_pull_select(GPIO182, GPIO_PULL_ENABLE);         \r
 285     mt_set_gpio_pull_enable(GPIO184, GPIO_PULL_DOWN);   //->CMD\r
 286     mt_set_gpio_pull_select(GPIO184, GPIO_PULL_ENABLE);\r
 287     mt_set_gpio_pull_enable(GPIO186, GPIO_PULL_DOWN);   //->DAT0\r
 288     mt_set_gpio_pull_select(GPIO186, GPIO_PULL_ENABLE);\r
 289     mt_set_gpio_pull_enable(GPIO187, GPIO_PULL_DOWN);   //->DAT1\r
 290     mt_set_gpio_pull_select(GPIO187, GPIO_PULL_ENABLE);\r
 291     mt_set_gpio_pull_enable(GPIO185, GPIO_PULL_DOWN);   //->DAT2\r
 292     mt_set_gpio_pull_select(GPIO185, GPIO_PULL_ENABLE);\r
 293     mt_set_gpio_pull_enable(GPIO183, GPIO_PULL_DOWN);   //->DAT3\r
 294     mt_set_gpio_pull_select(GPIO183, GPIO_PULL_ENABLE);\r
 295 #elif (CONFIG_MTK_COMBO_SDIO_SLOT == 3)\r
 296         printk(KERN_INFO "[mt6620] pull down sd3 bus (GPIO89~GPIO94)\n");\r
 297     mt_set_gpio_pull_enable(GPIO92, GPIO_PULL_DOWN);    //->CLK\r
 298     mt_set_gpio_pull_select(GPIO92, GPIO_PULL_ENABLE);          \r
 299     mt_set_gpio_pull_enable(GPIO91, GPIO_PULL_DOWN);    //->CMD\r
 300     mt_set_gpio_pull_select(GPIO91, GPIO_PULL_ENABLE);\r
 301     mt_set_gpio_pull_enable(GPIO94, GPIO_PULL_DOWN);    //->DAT0\r
 302     mt_set_gpio_pull_select(GPIO94, GPIO_PULL_ENABLE);\r
 303     mt_set_gpio_pull_enable(GPIO90, GPIO_PULL_DOWN);    //->DAT1\r
 304     mt_set_gpio_pull_select(GPIO90, GPIO_PULL_ENABLE);\r
 305     mt_set_gpio_pull_enable(GPIO89, GPIO_PULL_DOWN);    //->DAT2\r
 306     mt_set_gpio_pull_select(GPIO89, GPIO_PULL_ENABLE);\r
 307     mt_set_gpio_pull_enable(GPIO93, GPIO_PULL_DOWN);    //->DAT3\r
 308     mt_set_gpio_pull_select(GPIO93, GPIO_PULL_ENABLE);\r
 309 #else\r
 310         #error "error:unsupported CONFIG_MTK_COMBO_SDIO_SLOT" CONFIG_MTK_COMBO_SDIO_SLOT\r
 311 #endif\r
 312 \r
 313 \r
 314     //printk(KERN_INFO "[mt6620] set UART GPIO Mode output 0\n");\r
 315     ret = mt_set_gpio_mode(GPIO_UART_URXD3_PIN, GPIO_UART_URXD3_PIN_M_GPIO);\r
 316     ret += mt_set_gpio_dir(GPIO_UART_URXD3_PIN, GPIO_DIR_OUT);\r
 317     ret += mt_set_gpio_out(GPIO_UART_URXD3_PIN, GPIO_OUT_ZERO);\r
 318 \r
 319     ret += mt_set_gpio_mode(GPIO_UART_UTXD3_PIN, GPIO_UART_UTXD3_PIN_M_GPIO);\r
 320     ret += mt_set_gpio_dir(GPIO_UART_UTXD3_PIN, GPIO_DIR_OUT);\r
 321     ret += mt_set_gpio_out(GPIO_UART_UTXD3_PIN, GPIO_OUT_ZERO);\r
 322 \r
 323 #if (HWTEST_SUPPORT_PHONE)\r
 324          mt_set_gpio_out(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_OUT_ZERO);\r
 325 #endif\r
 326 #endif\r
 327         //for Ingenic\r
 328         printk(KERN_INFO "[mt6620] power off\n");\r
 329     __gpio_clear_pin(GPIO_RST_PIN);\r
 330     __gpio_clear_pin(GPIO_PMU_PIN);\r
 331     rtc_disable_clk32k();\r
 332     return 0;\r
 333 }\r
 334 \r
 335 ssize_t HWTEST_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)\r
 336 {\r
 337         return 0;\r
 338 }\r
 339 \r
 340 ssize_t HWTEST_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)\r
 341 {\r
 342         int i = 0;\r
 343         char local_buf[256] = {'\0'};\r
 344         \r
 345         HWTEST_INFO_FUNC("read card by sdio!\n");\r
 346         \r
 347         if(!g_sdio_init_count){\r
 348                 HWTEST_INFO_FUNC("sdio card still not initiliaztion yet!\n");\r
 349                 return -1;\r
 350         }\r
 351         if(!g_read_card_info_bysdio[0][0]){\r
 352                 HWTEST_INFO_FUNC("read sdio card buffer is null\n");\r
 353                 return -2;\r
 354         }\r
 355         HWTEST_INFO_FUNC("%s,%s",g_read_card_info_bysdio[0],g_read_card_info_bysdio[1]);\r
 356         sprintf(local_buf,"%s\n%s",g_read_card_info_bysdio[0],g_read_card_info_bysdio[1]);\r
 357         //strncpy(local_buf,g_read_card_info_bysdio[0],strlen(g_read_card_info_bysdio[0]));\r
 358 \r
 359         if(copy_to_user(buf,local_buf,strlen(g_read_card_info_bysdio[0]) + 1 + strlen(g_read_card_info_bysdio[1]))){\r
 360 \r
 361                 HWTEST_INFO_FUNC("copy info to user error!\n");\r
 362                 return -3;\r
 363         }\r
 364         return strlen(g_read_card_info_bysdio[0]) + strlen(g_read_card_info_bysdio[1])+1;\r
 365 }\r
 366 \r
 367 unsigned int HWTEST_poll(struct file *filp, poll_table *wait)\r
 368 {\r
 369     return 0;\r
 370 }\r
 371 //retval:odd is exception,even is error!\r
 372 int HWTEST_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)\r
 373 {\r
 374         int retval = 0;\r
 375         int ret;\r
 376         \r
 377         HWTEST_INFO_FUNC("cmd (0x%04x), arg (%d)\n", cmd, (int)arg);\r
 378 \r
 379         switch(cmd) {\r
 380                 case HWTEST_IOCTL_POWER_ON:\r
 381                         HWTEST_INFO_FUNC("power on!\n");\r
 382                         if(g_state_flag){\r
 383                                 HWTEST_INFO_FUNC("already power on!\n");\r
 384                                 retval = 1;\r
 385                         }else{\r
 386                                 ret = chip_power_on();\r
 387                                 if(!ret){\r
 388                                         g_state_flag = 1;\r
 389                                         HWTEST_INFO_FUNC("power on OK!\n");\r
 390                                 }else{\r
 391                                         HWTEST_INFO_FUNC("power on fail!\n");\r
 392                                         retval =  2;\r
 393                                 }               \r
 394                         }\r
 395                         break;\r
 396         \r
 397                 case HWTEST_IOCTL_POWER_OFF: \r
 398                         HWTEST_INFO_FUNC("power off!\n");\r
 399                         if(!g_state_flag){\r
 400                                 HWTEST_INFO_FUNC("already power off!\n");\r
 401                                 retval = 3;\r
 402                         }else{\r
 403                                 ret = chip_power_off();\r
 404                                 if(!ret){\r
 405                                         g_state_flag = 0;\r
 406                                         HWTEST_INFO_FUNC("power off OK!\n");\r
 407                                 }else{\r
 408                                         HWTEST_INFO_FUNC("power off fail!\n");\r
 409                                         retval = 4;\r
 410                                 }\r
 411                         }\r
 412                         break;\r
 413 \r
 414                 case HWTEST_IOCTL_CHIP_RESET:\r
 415                         HWTEST_INFO_FUNC("chip reset!\n");\r
 416                         if(g_state_flag){\r
 417                                 ret = chip_power_off();\r
 418                                 ret += chip_power_on();\r
 419                                 if(!ret){\r
 420                                         HWTEST_INFO_FUNC("chip reset OK!\n");\r
 421                                 }else{\r
 422                                         HWTEST_INFO_FUNC("chip rest fail!\n");\r
 423                                         retval = 6;\r
 424                                 }\r
 425                         }else{\r
 426                                 HWTEST_INFO_FUNC("chip is power off now!\n");\r
 427                                 retval = 5;\r
 428                         }\r
 429                         break;\r
 430                 case HWTEST_IOCTL_SDIO_INIT:\r
 431                         HWTEST_INFO_FUNC("init sdio card!\n");\r
 432                         if(g_sdio_init_count){  \r
 433                                 HWTEST_INFO_FUNC("SDIO card already exist!\n");\r
 434                                 retval = 7;\r
 435                         }else{\r
 436                                 ret = porting_6620_sdio_card_detect();\r
 437                                 if(!ret){\r
 438                                         HWTEST_INFO_FUNC("hwtest sdio init finish!\n");\r
 439                                 }else{\r
 440                                         HWTEST_INFO_FUNC("hwtest sdio init fail!\n");\r
 441                                         retval = 8;\r
 442                                 }\r
 443                                 g_sdio_init_count = 1;\r
 444                         }\r
 445                         break;\r
 446                 case HWTEST_IOCTL_SDIO_REMOVE:\r
 447                         HWTEST_INFO_FUNC("remove sdio card!\n");\r
 448                         if(!g_sdio_init_count){\r
 449                                 HWTEST_INFO_FUNC("sdio card not exist!\n");\r
 450                                 retval = 9;\r
 451                         }else{\r
 452                                 ret = porting_6620_sdio_card_remove();\r
 453                                 if(!ret){\r
 454                                         HWTEST_INFO_FUNC("hwtest sdio card remove finish!\n");\r
 455                                 }else{\r
 456                                         HWTEST_INFO_FUNC("hwtest sdio card remove fail!\n");\r
 457                                         retval = 10;\r
 458                                 }\r
 459                                 g_sdio_init_count = 0;\r
 460                         }\r
 461                         break;\r
 462                 case HWTEST_IOCTL_SDIO_READ_IOISREADY:\r
 463                         if(!g_read_current_io_isready_from_sdio_card){\r
 464                                 HWTEST_INFO_FUNC("sdio card current io is not ready!\n");\r
 465                                 retval = 11;\r
 466                         }else{\r
 467                                 if (copy_to_user((void *)arg, &g_read_current_io_isready_from_sdio_card, sizeof(g_read_current_io_isready_from_sdio_card)) < 0) {\r
 468                                         HWTEST_INFO_FUNC("copy to user space fail!\n");\r
 469                                         retval = 12;\r
 470                 }\r
 471                         }\r
 472                         break;\r
 473                 case HWTEST_IOCTL_SDIO_READ_BLKSIZE:\r
 474                         if(!g_read_function_blksize_from_sdio_card){\r
 475                                 HWTEST_INFO_FUNC("sdio card current function blksize is not set!\n");\r
 476                                 retval = 13;\r
 477                         }else{\r
 478                                 if (copy_to_user((void *)arg, &g_read_function_blksize_from_sdio_card, sizeof(g_read_function_blksize_from_sdio_card)) < 0) {\r
 479                                         HWTEST_INFO_FUNC("copy to user space fail!\n");\r
 480                                         retval = 14;\r
 481                 }\r
 482                         }\r
 483                         break;\r
 484                 case HWTEST_IOCTL_SDIO_READ_INT:\r
 485                         if(!g_read_int_from_sdio_card){\r
 486                                 HWTEST_INFO_FUNC("sdio card current register has not valuse!\n");\r
 487                                 retval = 15;\r
 488                         }else{\r
 489                                 if (copy_to_user((void *)arg, &g_read_int_from_sdio_card, sizeof(g_read_int_from_sdio_card)) < 0) {\r
 490                                         HWTEST_INFO_FUNC("copy to user space fail!\n");\r
 491                                         retval = 16;\r
 492                 }\r
 493                         }\r
 494                         break;\r
 495                 default:\r
 496                         retval = -17;\r
 497                         HWTEST_INFO_FUNC("unknown cmd (%d)\n", cmd);\r
 498                         break;\r
 499         }\r
 500 \r
 501     HWTEST_INFO_FUNC("retval = (%d)\n",retval);\r
 502         return retval;\r
 503 }\r
 504 \r
 505 \r
 506 \r
 507 static int HWTEST_open(struct inode *inode, struct file *file)\r
 508 {\r
 509     HWTEST_INFO_FUNC("major %d minor %d (pid %d)\n",\r
 510         imajor(inode),\r
 511         iminor(inode),\r
 512         current->pid\r
 513         );\r
 514 \r
 515     if (atomic_inc_return(&HWTEST_ref_cnt) == 1) {\r
 516         HWTEST_INFO_FUNC("1st call \n");\r
 517     }\r
 518 \r
 519     return 0;\r
 520 }\r
 521 \r
 522 static int HWTEST_close(struct inode *inode, struct file *file)\r
 523 {\r
 524     HWTEST_INFO_FUNC("major %d minor %d (pid %d)\n",\r
 525         imajor(inode),\r
 526         iminor(inode),\r
 527         current->pid\r
 528         );\r
 529 \r
 530     if (atomic_dec_return(&HWTEST_ref_cnt) == 0) {\r
 531         HWTEST_INFO_FUNC("last call \n");\r
 532     }\r
 533 \r
 534     return 0;\r
 535 }\r
 536 \r
 537 \r
 538 struct file_operations HWTEST_fops = {\r
 539     .open = HWTEST_open,\r
 540     .release = HWTEST_close,\r
 541     .read = HWTEST_read,\r
 542     .write = HWTEST_write,\r
 543     .unlocked_ioctl = HWTEST_unlocked_ioctl,\r
 544     .poll = HWTEST_poll,\r
 545 };\r
 546 \r
 547 \r
 548 static int HWTEST_init(void)\r
 549 {\r
 550     dev_t dev = MKDEV(HWTEST_major, 0);\r
 551     int cdev_err = -1;\r
 552     INT32 ret = -1;\r
 553     /* Prepare a char device */\r
 554     /*static allocate chrdev*/\r
 555     ret = register_chrdev_region(dev, HWTEST_DEV_NUM, HWTEST_DRIVER_NAME);\r
 556     if (ret) {\r
 557         HWTEST_ERR_FUNC("fail to register chrdev\n");\r
 558         return ret;\r
 559     }\r
 560 \r
 561     cdev_init(&HWTEST_cdev, &HWTEST_fops);\r
 562     HWTEST_cdev.owner = THIS_MODULE;\r
 563 \r
 564     cdev_err = cdev_add(&HWTEST_cdev, dev, HWTEST_DEV_NUM);\r
 565     if (cdev_err) {\r
 566         HWTEST_ERR_FUNC("cdev_add() fails (%d) \n", cdev_err);\r
 567         goto error;\r
 568     }\r
 569 \r
 570     HWTEST_INFO_FUNC("driver(major %d) installed \n", HWTEST_major);\r
 571 \r
 572     HWTEST_INFO_FUNC("success \n");\r
 573     return 0;\r
 574 \r
 575 error:\r
 576 \r
 577     if (cdev_err == 0) {\r
 578         cdev_del(&HWTEST_cdev);\r
 579     }\r
 580 \r
 581     if (ret == 0) {\r
 582         unregister_chrdev_region(dev, HWTEST_DEV_NUM);\r
 583         HWTEST_major = -1;\r
 584     }\r
 585         g_state_flag = 0;\r
 586     HWTEST_ERR_FUNC("fail \n");\r
 587 \r
 588     return -1;\r
 589 }\r
 590 \r
 591 static void HWTEST_exit (void)\r
 592 {\r
 593     dev_t dev = MKDEV(HWTEST_major, 0);\r
 594     cdev_del(&HWTEST_cdev);\r
 595     unregister_chrdev_region(dev, HWTEST_DEV_NUM);\r
 596     HWTEST_major = -1;\r
 597         g_state_flag = 0;\r
 598         g_sdio_init_count = 0;\r
 599     HWTEST_INFO_FUNC("done\n");\r
 600 }\r
 601 \r
 602 MODULE_LICENSE("GPL");\r
 603 EXPORT_SYMBOL_GPL(g_read_card_info_bysdio);\r
 604 EXPORT_SYMBOL_GPL(g_read_current_io_isready_from_sdio_card);\r
 605 EXPORT_SYMBOL_GPL(g_read_function_blksize_from_sdio_card);\r
 606 EXPORT_SYMBOL_GPL(g_read_int_from_sdio_card);\r
 607 \r
 608 \r
 609 module_init(HWTEST_init);\r
 610 module_exit(HWTEST_exit);\r
 611 \r