kreyren/OSHW-DEIMOS
1
0
Fork 0
Code Issues Pull Requests Releases Activity
guix
OSHW-DEIMOS/SOFTWARE/A64-TERES/linux-a64/drivers/pinctrl/axp/pinctrl-axp-test.c
Dimitar Gamishev f9b0e7a283 linux
2017-10-13 14:07:04 +03:00

1302 lines
43 KiB
C
Executable File
Raw Permalink Blame History

/*
* driver/pinctrl/pinctrl-axp-test.c
*
* Copyright(c) 2013-2015 Allwinnertech Co., Ltd.
* http://www.allwinnertech.com
*
* Author: Ming Li <liming@allwinnertech.com>
*
* allwinner axp pinctrl test driver.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/io.h>
#include <linux/clk.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_device.h>
#include <linux/pinctrl/consumer.h>
#include <linux/pinctrl/pinconf-sunxi.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/ctype.h>
#include <linux/device.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/sys_config.h>
#ifndef TEST_DRIVER_IN_DRIVER_PATH
#define TEST_DRIVER_IN_DRIVER_PATH (1)
#endif
#if TEST_DRIVER_IN_DRIVER_PATH
#include "../core.h"
#endif
#define MODULE_NAME "pinctrl.1"
#define PINCTRL_AXP_TEST_NUMBER 30
#define PINCTRL_AXP_DEV_NAME_MAX_LEN 20
#define CASE_TEST_SUCCESSED 0
#define CASE_TEST_FAILED 1
#define CASE_HAVE_NOT_TEST 2
struct result_class{
char *name;
int result;
};
struct pinctrl_axp_test_data{
unsigned int exec;
unsigned int gpio_index;
unsigned int funcs;
unsigned int dat;
unsigned int test_result;
char dev_name[PINCTRL_AXP_DEV_NAME_MAX_LEN];
struct device *dev;
};
static struct result_class pinctrl_axp_result[PINCTRL_AXP_TEST_NUMBER];
static struct class *pinctrl_axp_test_class;
static unsigned int test_case_number;
static inline int axp_gpio_to_name(int gpio, char *name)
{
int index;
if (!name) {
return -EINVAL;
}
if (IS_AXP_PIN(gpio)) {
/* axp gpio name like this : GPIO0/GPIO1/.. */
index = gpio - AXP_PIN_BASE;
sprintf(name, "GPIO%d", index);
} else {
sprintf(name, "NOT AXP PIN");
}
return 0;
}
static int test_request_all_resource_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
struct pinctrl *pinctrl;
struct gpio_config pin_cfg;
script_item_u *pin_list;
u16 pin_count;
u16 pin_index;
long unsigned int config;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
char device_name[PINCTRL_AXP_DEV_NAME_MAX_LEN];
int ret = 0;
pinctrl_axp_result[0].name = "test_request_all_resource_api";
test_case_number = 0;
dev_set_name(dev, pinctrl_axp_test->dev_name);
strcpy(device_name,pinctrl_axp_test->dev_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("device[%s] all pin resource we want to request: \n",device_name);
script_dump_mainkey(device_name);
pr_warn("start testing...\n");
pr_warn("------------------------------------\n");
pr_warn("step1: request pin all resource.\n");
pinctrl = devm_pinctrl_get_select_default(dev);
if (IS_ERR_OR_NULL(pinctrl)) {
pr_warn("request pinctrl handle for device [%s] failed...\n",device_name);
return -EINVAL;
}
pr_warn("step2: get device[%s] pin count.\n",device_name);
pin_count = script_get_pio_list(pinctrl_axp_test->dev_name,&pin_list);
if (pin_count == 0) {
pr_warn(" devices own 0 pin resource or look for main key failed!\n");
return -EINVAL;
}
pr_warn("step3: get device[%s] pin configure and check.\n",device_name);
for(pin_index = 0; pin_index < pin_count; pin_index++)
{
pin_cfg = pin_list[pin_index].gpio;
sunxi_gpio_to_name(pin_cfg.gpio, pin_name);
/*check function config */
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC,0xFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if (pin_cfg.mul_sel != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("failed! mul value isn't equal as sys_config's.");
return -EINVAL;
}
/*check pull config */
if (pin_cfg.pull != GPIO_PULL_DEFAULT){
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_PUD, 0xFFFF);
pin_config_get(MODULE_NAME, pin_name, &config);
if (pin_cfg.pull != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("failed! pull value isn't equal as sys_config's.");
return -EINVAL;
}
}
/*check dlevel config */
if (pin_cfg.drv_level != GPIO_DRVLVL_DEFAULT){
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DRV,0XFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if(pin_cfg.drv_level != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("failed! dlevel value isn't equal as sys_config's.");
return -EINVAL;
}
}
/*check data config */
if (pin_cfg.data != GPIO_DATA_DEFAULT){
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT,0XFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if(pin_cfg.data != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("failed! pin data value isn't equal as sys_config's.");
return -EINVAL;
}
}
}
pr_warn("test pinctrl request all resource api success !\n");
pr_warn("++++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
return ret=0;
}
static int test_re_request_all_resource_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
struct pinctrl *pinctrl_1;
struct pinctrl *pinctrl_2;
int ret=0;
char device_name[PINCTRL_AXP_DEV_NAME_MAX_LEN];
pinctrl_axp_result[1].name="test_re_request_all_resource_api";
test_case_number = 1;
dev_set_name(dev, pinctrl_axp_test->dev_name);
strcpy(device_name,pinctrl_axp_test->dev_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("device[%s] all pin resource we want to request: \n",device_name);
script_dump_mainkey(device_name);
pr_warn("start testing...\n");
pr_warn("------------------------------------\n");
pr_warn("step1: first time request pin all resource.\n");
/*request all resource */
pinctrl_1 = devm_pinctrl_get_select_default(dev);
if (IS_ERR_OR_NULL(pinctrl_1)) {
pr_warn("request pinctrl handle for device [%s] failed!\n",device_name);
return -EINVAL;
}
/*repeat request */
pr_warn("step2: secondary request pin all resource.\n");
pinctrl_2 = devm_pinctrl_get_select_default(dev);
if (IS_ERR_OR_NULL(pinctrl_2)) {
pr_warn("repeat request device[%s] all pin resource failed\n", device_name);
pr_warn("test success! repeat request is unpermitted.\n");
ret = 0;
goto done;
} else {
pr_warn("repeat request device[%s] all pin resource success.\n", dev_name(dev));
pr_warn("test failed! repeat request is unpermitted\n");
ret = 1;
goto done;
}
done:
pr_warn("++++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
return ret;
}
static int test_pin_function_set_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret=0;
long unsigned int config_set;
long unsigned int config_get;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
int func=pinctrl_axp_test->funcs;
pinctrl_axp_result[2].name = "test_pin_function_set_api";
test_case_number = 2;
sunxi_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("\npin function we want to set:\n");
pr_warn(" gpio name: %s gpio index: %d gpio function: %d\n"
,pin_name,pinctrl_axp_test->gpio_index,func);
pr_warn("--------------------------------------------\n\n");
pr_warn("start testing...\n");
/*check if pin mul setting right */
pr_warn("step1:get [%s] function value.\n",pin_name);
config_get = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC,0XFFFF);
pin_config_get(MODULE_NAME,pin_name,&config_get);
pr_warn(" [%s] function value: %ld\n",pin_name,SUNXI_PINCFG_UNPACK_VALUE(config_get));
pr_warn("step2:set [%s] function value to %d\n",pin_name,func);
config_set = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC,func);
pin_config_set(MODULE_NAME,pin_name,config_set);
pr_warn("step3:get [%s] function value and check.\n",pin_name);
config_get = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC,0XFFFF);
pin_config_get(MODULE_NAME,pin_name,&config_get);
if (func != SUNXI_PINCFG_UNPACK_VALUE(config_get)){
pr_warn("test pin config for mul setting failed !\n");
return -EINVAL;
}
pr_warn("\n\ntest pin function set success ! \n");
pr_warn("++++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
return ret;
}
static int test_pin_data_set_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret=0;
long unsigned int config_set;
long unsigned int config_get;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
int dat=pinctrl_axp_test->dat;
pinctrl_axp_result[3].name = "test_pin_data_set_api";
test_case_number = 3;
sunxi_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("\npin data we want to set:\n");
pr_warn(" gpio name: %s gpio index: %d gpio data: %d\n"
,pin_name,pinctrl_axp_test->gpio_index,dat);
pr_warn("--------------------------------------------\n\n");
pr_warn("start testing...\n");
/*check if pin data setting right */
pr_warn("step1:get [%s] data value.\n",pin_name);
config_get = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT,0XFFFF);
pin_config_get(MODULE_NAME,pin_name,&config_get);
pr_warn(" [%s] data value: %ld\n",pin_name,SUNXI_PINCFG_UNPACK_VALUE(config_get));
pr_warn("step2:set [%s] data value to %d\n",pin_name,dat);
config_set = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT,dat);
pin_config_set(MODULE_NAME,pin_name,config_set);
pr_warn("step3:get [%s] data value and check.\n",pin_name);
config_get = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT,0XFFFF);
pin_config_get(MODULE_NAME,pin_name,&config_get);
if (dat != SUNXI_PINCFG_UNPACK_VALUE(config_get)){
pr_warn("test pin config for dlevel setting failed !\n");
return -EINVAL;
}
pr_warn("\n\ntest pin configure set success ! \n");
pr_warn("++++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
return ret;
}
static int test_gpio_request_free_api(struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret=0;
int req_status;
int gpio_index = pinctrl_axp_test->gpio_index;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
pinctrl_axp_result[4].name = "test_gpio_request_free_api";
test_case_number = 4;
sunxi_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("gpio name is : %s gpio index is : %d\n",pin_name
,pinctrl_axp_test->gpio_index);
pr_warn("start testing...\n");
/* request gpio*/
pr_warn("step1: request gpio[%s]\n",pin_name);
gpio_free(gpio_index);
req_status = gpio_request(gpio_index,NULL);
if(0 != req_status){
pr_warn("gpio request failed !return value %d\n",req_status);
return -EINVAL;
}
pr_warn(" request gpio[%s] success\n",pin_name);
gpio_free(gpio_index);
pr_warn("step2: free gpio[%s]\n",pin_name);
pr_warn("test gpio request free api success!\n");
pr_warn("++++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
return ret;
}
static int test_gpio_repeat_request_free_api(struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret=0;
int req_status;
int gpio_index = pinctrl_axp_test->gpio_index;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
pinctrl_axp_result[5].name = "test_gpio_re_request_free_api";
test_case_number = 5;
sunxi_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("gpio name is : %s gpio index is : %d\n",pin_name
,pinctrl_axp_test->gpio_index);
pr_warn("start testing...\n");
/* request gpio*/
pr_warn("step1:first time request gpio[%s]\n",pin_name);
req_status = gpio_request(gpio_index,NULL);
if(0 != req_status){
pr_warn(" first time request gpio [%s]failed !\n",pin_name);
return -EINVAL;
}
pr_warn(" first time request gpio[%s] success!\n",pin_name);
/* repeat request gpio */
pr_warn("step2: repeat request gpio[%s]\n",pin_name);
req_status = gpio_request(gpio_index,NULL);
if(0 != req_status){
pr_warn("repeat request gpio [%s] failed.\n",pin_name);
pr_warn("test success: for repeat request is unpermitted.\n");
ret = 0;
goto done;
}else{
pr_warn("repeat request gpio[%s]success.\n",pin_name);
pr_warn("test failed: for repeat request is unpermitted.\n");
ret = 1;
goto done;
}
done:
pr_warn("++++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
gpio_free(gpio_index);
return ret;
}
static int test_gpiolib_api(struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret = 0;
int val;
u16 pin_index;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
int req_status;
int set_direct_status;
long unsigned int config;
pinctrl_axp_result[6].name = "test_gpiolib_api";
test_case_number = 6;
pin_index = pinctrl_axp_test->gpio_index;
sunxi_gpio_to_name(pin_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("gpio name is : %s gpio index is : %d\n",pin_name,pin_index);
pr_warn("start testing...\n");
/*
* test gpio set direction input api
*/
pr_warn("-----------------------------------------------\n");
pr_warn("1.test gpio direction input api:\n");
pr_warn("step1:request gpio.\n");
req_status = gpio_request(pin_index,NULL);
if(0 != req_status){
pr_warn("gpio request failed !\n");
return -EINVAL;
}
pr_warn("step2:set gpio direction input.\n");
set_direct_status = gpio_direction_input(pin_index);
if (IS_ERR_VALUE(set_direct_status)) {
pr_warn("set gpio direction input failed!\n");
goto test_gpiolib_api_failed;
}
pr_warn("step3:get gpio mux value and check.\n");
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC,0xFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if (0 != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("test gpio set direction input failed !\n");
goto test_gpiolib_api_failed;
}
gpio_free(pin_index);
pr_warn("step4:gpio free.\n");
pr_warn("finish API(gpio_direction_input)testing.\n");
pr_warn("-----------------------------------------------\n\n");
/*
* test gpio set direction output api
*/
pr_warn("2.test gpio direction output api:\n");
pr_warn("step1:request gpio.\n");
req_status = gpio_request(pin_index,NULL);
if(0 != req_status){
pr_warn("gpio request failed !\n");
return -EINVAL;
}
pr_warn("step2:set gpio direction output(data value 1).\n");
set_direct_status = gpio_direction_output(pin_index,1);
if (IS_ERR_VALUE(set_direct_status)) {
pr_warn("set gpio direction output failed! \n");
goto test_gpiolib_api_failed;
}
pr_warn("step3:get gpio mux value and check.\n");
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC,0xFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if (1 != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("faile!FUNC value not the same as expectation.\n");
goto test_gpiolib_api_failed;
}
pr_warn("step4:get gpio data value and check.\n");
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT,0xFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if (1 != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("failed!DATA value not the same as expectation(1).\n");
goto test_gpiolib_api_failed;
}
pr_warn("step5:set gpio direction output(data value 0).\n");
set_direct_status = gpio_direction_output(pin_index,0);
if (IS_ERR_VALUE(set_direct_status)) {
pr_warn("set gpio direction output failed!\n");
goto test_gpiolib_api_failed;
}
pr_warn("step6:get gpio data value and check.\n");
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT,0xFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if (0 != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("failed!DATA value not the same as expectation(0).\n");
goto test_gpiolib_api_failed;
}
gpio_free(pin_index);
pr_warn("step7:gpio free.\n");
pr_warn("finish API(gpio_direction_output)testing.\n");
pr_warn("-----------------------------------------------\n\n");
/*
* test gpio get value api
*/
pr_warn("3.test gpio get value api:\n");
pr_warn("step1:request gpio.\n");
req_status = gpio_request(pin_index,NULL);
if(0 != req_status){
pr_warn("gpio request failed !\n");
return -EINVAL;
}
pr_warn("step2:set gpio direction output(data value 0).\n");
set_direct_status = gpio_direction_output(pin_index,0);
if (IS_ERR_VALUE(set_direct_status)) {
pr_warn("set gpio direction output failed !\n");
goto test_gpiolib_api_failed;
}
pr_warn("step3:get gpio data value and check.\n");
val=__gpio_get_value(pin_index);
pr_warn(" gpio data value : %d \n",val);
if (0 != val){
pr_warn("failed!DATA value not the same as expectation.\n");
goto test_gpiolib_api_failed;
}
gpio_free(pin_index);
pr_warn("step4:gpio free.\n");
pr_warn("finish API(gpio_get_value)testing.\n");
pr_warn("-----------------------------------------------\n\n");
/*
* test gpio set value api
*/
pr_warn("4.test gpio set value api:\n");
pr_warn("step1:request gpio.\n");
req_status = gpio_request(pin_index,NULL);
if(0 != req_status){
pr_warn("gpio request failed!\n");
return -EINVAL;
}
pr_warn("step2:set gpio direction output(set data value 0).\n");
set_direct_status = gpio_direction_output(pin_index,0);
if (IS_ERR_VALUE(set_direct_status)) {
pr_warn("set gpio direction output failed \n");
goto test_gpiolib_api_failed;
}
pr_warn("step3:get gpio data value,then set 1 and check.\n");
val=__gpio_get_value(pin_index);
pr_warn(" get gpio data value : %d \n",val);
__gpio_set_value(pin_index,1);
pr_warn(" set gpio data value : 1 \n");
val=__gpio_get_value(pin_index);
pr_warn(" get gpio data value : %d \n",val);
if (1 != val){
pr_warn("test gpio set dat value 1 failed ! \n");
goto test_gpiolib_api_failed;
}
pr_warn("step4:get gpio data value,then set 0 and check.\n");
val=__gpio_get_value(pin_index);
pr_warn(" get gpio data value : %d \n",val);
__gpio_set_value(pin_index,0);
pr_warn(" set gpio data value : 0 \n");
val=__gpio_get_value(pin_index);
pr_warn(" get gpio data value : %d \n",val);
if (0 != val){
pr_warn("test gpio set dat value 0 failed ! \n");
goto test_gpiolib_api_failed;
}
gpio_free(pin_index);
pr_warn("step5:gpio free.\n");
pr_warn("finish API(gpio_set_value)testing.\n");
pr_warn("-----------------------------------------------\n\n");
pr_warn("test gpiolib api success!\n");
pr_warn("+++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
return ret;
test_gpiolib_api_failed:
pr_warn("test gpiolib api failed!\n");
pr_warn("+++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
gpio_free(pin_index);
return -EINVAL;
}
static int test_pinctrl_scripts_api(struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret = 0;
char main_key[256] = {0},sub_key[256] = {0}, str_cmp[256] = {0};
int gpio_cnt_cmp, gpio_cnt_get;
script_item_u item_cmp, item_get, *list_get = NULL;
script_item_value_type_e type_cmp, type_get;
pinctrl_axp_result[7].name = "test_pinctrl_eint_api";
test_case_number = 7;
printk("%s, line %d\n", __func__, __LINE__);
/* test script api */
strcpy(main_key, "card0_boot_para");
script_dump_mainkey(main_key);
/* test for type int */
strcpy(sub_key, "card_ctrl");
item_cmp.val = 0;
type_cmp = SCIRPT_ITEM_VALUE_TYPE_INT;
type_get = script_get_item(main_key, sub_key, &item_get);
if(type_get != type_cmp){
pr_warn("%s err, line %d, %s->%s type should be %d, but get %d\n",
__func__, __LINE__, main_key, sub_key, type_cmp, type_get);
return -EINVAL;
}
if(item_cmp.val != item_get.val){
pr_warn("%s err, line %d, %s->%s value should be %d, but get %d\n",
__func__, __LINE__, main_key, sub_key, item_cmp.val, item_get.val);
return -EINVAL;
}
/* test for type gpio */
strcpy(sub_key, "sdc_d3");
type_cmp = SCIRPT_ITEM_VALUE_TYPE_PIO;
type_get = script_get_item(main_key, sub_key, &item_get);
if(type_get != type_cmp){
pr_warn("%s err, line %d, %s->%s type should be %d, but get %d\n",
__func__, __LINE__, main_key, sub_key, type_cmp, type_get);
return -EINVAL;
}
/* test for gpio list */
gpio_cnt_cmp = 6;
gpio_cnt_get = script_get_pio_list(main_key, &list_get);
if(gpio_cnt_get != gpio_cnt_cmp){
pr_warn("%s err, line %d, %s gpio cnt should be %d, but get %d\n",
__func__, __LINE__, main_key, gpio_cnt_cmp, gpio_cnt_get);
return -EINVAL;
}
/* test for str */
strcpy(main_key, "product");
strcpy(sub_key, "machine");
#if defined CONFIG_ARCH_SUN8IW6P1
strcpy(str_cmp, "perf3_v1_0");
#elif defined CONFIG_ARCH_SUN8IW7
strcpy(str_cmp, "perf");
#else
strcpy(str_cmp, "evb");
#endif
script_dump_mainkey(main_key);
type_cmp = SCIRPT_ITEM_VALUE_TYPE_STR;
type_get = script_get_item(main_key, sub_key, &item_get);
if(type_get != type_cmp){
pr_warn("%s err, line %d, %s->%s type should be %d, but get %d\n",
__func__, __LINE__, main_key, sub_key, type_cmp, type_get);
return -EINVAL;
}
if(strcmp(str_cmp, item_get.str)){
pr_warn("%s err, line %d, %s->%s value should be %s, but get %s\n",
__func__, __LINE__, main_key, sub_key, str_cmp, item_get.str);
return -EINVAL;
}
pr_warn("test sunxi pinctrl scripts success!\n");
return ret;
}
static int test_pinctrl_request_gpio_api(struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret=0;
int req_status;
int gpio_index = pinctrl_axp_test->gpio_index;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
pinctrl_axp_result[8].name = "test_pinctrl_request_gpio_api";
test_case_number = 8;
sunxi_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("gpio name is : %s gpio index is : %d\n",pin_name
,pinctrl_axp_test->gpio_index);
pinctrl_free_gpio(gpio_index);
pr_warn("start testing...\n");
/* request signal pin as gpio*/
pr_warn("step1: pinctrl request gpio[%s]\n",pin_name);
req_status = pinctrl_request_gpio(gpio_index);
if(0 != req_status){
pr_warn("pinctrl request gpio failed !return value %d\n",req_status);
return -EINVAL;
}
pr_warn(" pinctrl request gpio[%s]success\n",pin_name);
pinctrl_free_gpio(gpio_index);
pr_warn("test pinctrl request gpio api success!\n");
pr_warn("++++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
return ret;
}
static int test_pinctrl_free_gpio_api(struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret = 0;
int req_status;
int gpio_index = pinctrl_axp_test->gpio_index;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
pinctrl_axp_result[9].name = "test_pinctrl_free_gpio_api";
test_case_number = 9;
sunxi_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("gpio name is : %s gpio index is : %d\n",pin_name
,pinctrl_axp_test->gpio_index);
pinctrl_free_gpio(gpio_index);
pr_warn("start testing...\n");
/*request signal pin as gpio*/
pr_warn("step1: pinctrl request gpio[%s]\n",pin_name);
req_status = pinctrl_request_gpio(gpio_index);
if(0 != req_status){
pr_warn("pinctrl request gpio failed !return value %d\n",req_status);
return -EINVAL;
}
pr_warn(" pinctrl request gpio[%s]success\n",pin_name);
pr_warn("step2: pinctrl free gpio[%s]\n",pin_name);
pinctrl_free_gpio(gpio_index);
pr_warn("step3: pinctrl request the same gpio[%s] again..\n",pin_name);
req_status = pinctrl_request_gpio(gpio_index);
if(0 != req_status){
pr_warn("pinctrl request gpio failed !return value %d\n",req_status);
return -EINVAL;
}
pr_warn(" pinctrl request gpio[%s] again success.\n",pin_name);
pr_warn("test pinctrl free gpio api success!\n");
pr_warn("++++++++++++++++++++++++++++end++++++++++++++++++++++++++++\n\n\n");
pinctrl_free_gpio(gpio_index);
return ret;
}
static int test_pinctrl_gpio_direction_input_api(struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret = 0;
int req_status;
int gpio_index = pinctrl_axp_test->gpio_index;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
int direct_status;
long unsigned int config;
pinctrl_axp_result[10].name = "test_pinctrl_gpio_direction_input_api";
test_case_number = 10;
sunxi_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("gpio name is : %s gpio index is : %d\n",pin_name
,pinctrl_axp_test->gpio_index);
pinctrl_free_gpio(gpio_index);
pr_warn("start testing...\n");
/* test gpio set direction input */
pr_warn("-----------------------------------------------\n");
pr_warn("step1:Pinctrl request gpio.\n");
req_status = pinctrl_request_gpio(gpio_index);
if(0 != req_status){
pr_warn("pinctrl request gpio failed !return value %d\n",req_status);
return -EINVAL;
}
pr_warn("step2:Set gpio direction input.\n");
direct_status = pinctrl_gpio_direction_input(gpio_index);
if (IS_ERR_VALUE(direct_status)) {
pr_warn("set pinctrl gpio direction input failed! return value: %d\n"
,direct_status);
return -EINVAL;
}
pr_warn("step3:Get pin mux value and check.\n");
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC,0xFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if (0 != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("check: set pin direction input failed !\n");
return -EINVAL;
}
pr_warn("step4:Pinctrl free gpio.\n");
pinctrl_free_gpio(gpio_index);
pr_warn("test pinctrl gpio direction input api success!\n");
pr_warn("-----------------------------------------------\n\n");
return ret;
}
static int test_pinctrl_gpio_direction_output_api(struct pinctrl_axp_test_data *pinctrl_axp_test)
{
int ret = 0;
int req_status;
int gpio_index = pinctrl_axp_test->gpio_index;
char pin_name[SUNXI_PIN_NAME_MAX_LEN];
int direct_status;
long unsigned int config;
pinctrl_axp_result[11].name = "test_pinctrl_gpio_direction_output_api";
test_case_number = 11;
sunxi_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
pr_warn("gpio name is : %s gpio index is : %d\n",pin_name
,pinctrl_axp_test->gpio_index);
pinctrl_free_gpio(gpio_index);
pr_warn("start testing...\n");
/* test gpio set direction output */
pr_warn("-----------------------------------------------\n");
pr_warn("step1:Pinctrl request gpio.\n");
req_status = pinctrl_request_gpio(gpio_index);
if(0 != req_status){
pr_warn("pinctrl request gpio failed !return value %d\n",req_status);
return -EINVAL;
}
pr_warn("step2:Set gpio direction output.\n");
direct_status = pinctrl_gpio_direction_output(gpio_index);
if (IS_ERR_VALUE(direct_status)) {
pr_warn("set pinctrl gpio direction output failed! return value: %d\n"
,direct_status);
return -EINVAL;
}
pr_warn("step3:Get pin mux value and check.\n");
config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC,0xFFFF);
pin_config_get(MODULE_NAME,pin_name,&config);
if (1 != SUNXI_PINCFG_UNPACK_VALUE(config)){
pr_warn("check: set pinctrl gpio direction output failed !\n");
return -EINVAL;
}
pr_warn("step4:Pinctrl free gpio.\n");
pinctrl_free_gpio(gpio_index);
pr_warn("test pinctrl gpio direction output api success!\n");
pr_warn("-----------------------------------------------\n\n");
return ret;
}
static int test_pinctrl_get_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
struct pinctrl *pinctrl;
struct pinctrl_state *state;
struct pinctrl_setting *setting;
char device_name[PINCTRL_AXP_DEV_NAME_MAX_LEN];
int ret = 0;
pinctrl_axp_result[12].name = "test_pinctrl_get_api";
test_case_number = 12;
dev_set_name(dev, pinctrl_axp_test->dev_name);
strcpy(device_name,pinctrl_axp_test->dev_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
script_dump_mainkey(device_name);
pr_warn("start testing...\n");
pr_warn("------------------------------------\n");
pr_warn("step1: get pinctrl handle.\n");
pinctrl = pinctrl_get(dev);
if (IS_ERR_OR_NULL(pinctrl)) {
pr_warn("get pinctrl handle [%s] failed...,return value %ld\n",device_name,PTR_ERR(pinctrl));
return -EINVAL;
}
pr_warn("step2: check pinctrl handle we have getted.\n");
if(dev_name(dev) != dev_name(pinctrl->dev)){
pinctrl_put(pinctrl);
pr_warn("check: pinctrl handle isn't that one we want\n ");
return -EINVAL;
}
#if defined(TEST_DRIVER_IN_DRIVER_PATH)
pr_warn("device: %s current state: %s\n",dev_name(pinctrl->dev),
pinctrl->state ? pinctrl->state->name : "none");
list_for_each_entry(state, &pinctrl->states, node) {
pr_warn("state: %s\n", state->name);
list_for_each_entry(setting, &state->settings, node) {
struct pinctrl_dev *pctldev = setting->pctldev;
pr_warn(" setting type: %d pin controller %s \n"
,setting->type,pinctrl_dev_get_name(pctldev));
}
}
#endif
pinctrl_put(pinctrl);
pr_warn("test pinctrl get api success!\n");
pr_warn("-----------------------------------------------\n\n");
return ret;
}
static int test_pinctrl_lookup_state_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
struct pinctrl *pinctrl;
struct pinctrl_state *state;
char device_name[PINCTRL_AXP_DEV_NAME_MAX_LEN];
int ret = 0;
pinctrl_axp_result[13].name = "test_pinctrl_lookup_state_api";
test_case_number = 13;
dev_set_name(dev, pinctrl_axp_test->dev_name);
strcpy(device_name,pinctrl_axp_test->dev_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
script_dump_mainkey(device_name);
pr_warn("start testing...\n");
pr_warn("------------------------------------\n");
pr_warn("step1: get pinctrl handle.\n");
pinctrl = pinctrl_get(dev);
if (IS_ERR_OR_NULL(pinctrl)) {
pr_warn("get pinctrl handle [%s] failed...,return value %ld\n",device_name,PTR_ERR(pinctrl));
return -EINVAL;
}
pr_warn("step2: printk pinctrl current state.\n");
pr_warn(" device: %s current state: %s\n",dev_name(pinctrl->dev),
pinctrl->state ? pinctrl->state->name : "none");
pr_warn("step3: pinctrl lookup state(default state name: default).\n");
state = pinctrl_lookup_state(pinctrl, "default");
if (IS_ERR(state)) {
pr_warn("can not find state: default.\n");
return -EINVAL;
}
pr_warn("step4: check the state we lookup if the one needed.\n");
if (strcmp(state->name, "default")){
pr_warn("find state,but isn't the one we need.\n");
return -EINVAL;
}
pinctrl_put(pinctrl);
pr_warn("test pinctrl look up state api success!\n");
pr_warn("-----------------------------------------------\n\n");
return ret;
}
static int test_pinctrl_select_state_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
struct pinctrl *pinctrl;
struct pinctrl_state *state;
char device_name[PINCTRL_AXP_DEV_NAME_MAX_LEN];
int ret = 0;
int reqstatus;
pinctrl_axp_result[14].name = "test_pinctrl_select_state_api";
test_case_number = 14;
dev_set_name(dev, pinctrl_axp_test->dev_name);
strcpy(device_name,pinctrl_axp_test->dev_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
script_dump_mainkey(device_name);
pr_warn("start testing...\n");
pr_warn("------------------------------------\n");
pr_warn("step1: get pinctrl handle.\n");
pinctrl = pinctrl_get(dev);
if (IS_ERR_OR_NULL(pinctrl)) {
pr_warn("get pinctrl handle [%s] failed...,return value %ld\n",device_name,PTR_ERR(pinctrl));
return -EINVAL;
}
pr_warn("step2: printk pinctrl current state.\n");
pr_warn(" device: %s current state: %s\n",dev_name(pinctrl->dev),
pinctrl->state ? pinctrl->state->name : "none");
pr_warn("step3: pinctrl lookup state(default state name: default).\n");
state = pinctrl_lookup_state(pinctrl, "default");
if (IS_ERR(state)) {
pinctrl_put(pinctrl);
pr_warn("can not find state: default.\n");
return -EINVAL;
}
pr_warn("step4: check the state we lookup if the one needed.\n");
if (strcmp(state->name, "default")){
pinctrl_put(pinctrl);
pr_warn("find state,but isn't the one we need.\n");
return -EINVAL;
}
pr_warn("step5: select state for pinctrl handle.\n");
reqstatus = pinctrl_select_state(pinctrl, state);
if(reqstatus < 0){
pinctrl_put(pinctrl);
pr_warn("pinctrl select state failed. return value %d.\n",reqstatus);
}
pinctrl_put(pinctrl);
pr_warn("test pinctrl select state api success!\n");
pr_warn("-----------------------------------------------\n\n");
return ret;
}
static int test_pinctrl_put_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
struct pinctrl *pinctrl;
struct pinctrl_state *state;
struct pinctrl_setting *setting;
char device_name[PINCTRL_AXP_DEV_NAME_MAX_LEN];
int ret = 0;
pinctrl_axp_result[15].name = "test_pinctrl_put_api";
test_case_number = 15;
dev_set_name(dev, pinctrl_axp_test->dev_name);
strcpy(device_name,pinctrl_axp_test->dev_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
script_dump_mainkey(device_name);
pr_warn("start testing...\n");
pr_warn("------------------------------------\n");
pr_warn("step1: get pinctrl handle.\n");
pinctrl = pinctrl_get(dev);
if (IS_ERR_OR_NULL(pinctrl)) {
pr_warn("get pinctrl handle [%s] failed...,return value %ld\n",device_name,PTR_ERR(pinctrl));
return -EINVAL;
}
pr_warn("step2: check pinctrl handle we have getted.\n");
if(dev_name(dev) != dev_name(pinctrl->dev)){
pinctrl_put(pinctrl);
pr_warn("check: pinctrl handle isn't that one we want\n ");
return -EINVAL;
}
#if defined(TEST_DRIVER_IN_DRIVER_PATH)
pr_warn("device: %s current state: %s\n",dev_name(pinctrl->dev),
pinctrl->state ? pinctrl->state->name : "none");
list_for_each_entry(state, &pinctrl->states, node) {
pr_warn("state: %s\n", state->name);
list_for_each_entry(setting, &state->settings, node) {
struct pinctrl_dev *pctldev = setting->pctldev;
pr_warn(" setting type: %d pin controller %s \n"
,setting->type,pinctrl_dev_get_name(pctldev));
}
}
#endif
pr_warn("step3: free pinctrl handle we have getted.\n");
pinctrl_put(pinctrl);
pr_warn("step4: then repeat get.if get success ,previous free operate success.\n");
pinctrl = pinctrl_get(dev);
if (IS_ERR_OR_NULL(pinctrl)) {
pr_warn(" after free,we repeat get pinctrl handle [%s] failed...,return value %ld\n",device_name,PTR_ERR(pinctrl));
return -EINVAL;
}
pinctrl_put(pinctrl);
pr_warn("test pinctrl put api success!\n");
pr_warn("-----------------------------------------------\n\n");
return ret;
}
static int test_pinctrl_devm_get_put_api(struct device *dev,
struct pinctrl_axp_test_data *pinctrl_axp_test)
{
struct pinctrl *pinctrl;
struct pinctrl_state *state;
struct pinctrl_setting *setting;
char device_name[PINCTRL_AXP_DEV_NAME_MAX_LEN];
int ret = 0;
pinctrl_axp_result[16].name = "test_pinctrl_devm_get_put_api";
test_case_number = 16;
dev_set_name(dev, pinctrl_axp_test->dev_name);
strcpy(device_name,pinctrl_axp_test->dev_name);
pr_warn("++++++++++++++++++++++++++++%s++++++++++++++++++++++++++++\n", __func__);
script_dump_mainkey(device_name);
pr_warn("start testing...\n");
pr_warn("------------------------------------\n");
pr_warn("step1: devm get pinctrl handle.\n");
pinctrl = devm_pinctrl_get(dev);
if (IS_ERR(pinctrl)) {
pr_warn("get pinctrl handle [%s] failed...,return value %ld\n",device_name,PTR_ERR(pinctrl));
return -EINVAL;
}
pr_warn("step2: check pinctrl handle we have getted.\n");
if(dev_name(dev) != dev_name(pinctrl->dev)){
devm_pinctrl_put(pinctrl);
pr_warn("check: pinctrl handle isn't that one we want\n ");
return -EINVAL;
}
#if defined(TEST_DRIVER_IN_DRIVER_PATH)
pr_warn("device: %s current state: %s\n",dev_name(pinctrl->dev),
pinctrl->state ? pinctrl->state->name : "none");
list_for_each_entry(state, &pinctrl->states, node) {
pr_warn("state: %s\n", state->name);
list_for_each_entry(setting, &state->settings, node) {
struct pinctrl_dev *pctldev = setting->pctldev;
pr_warn(" setting type: %d pin controller %s \n"
,setting->type,pinctrl_dev_get_name(pctldev));
}
}
#endif
pr_warn("step3: devm free pinctrl handle we have getted.\n");
devm_pinctrl_put(pinctrl);
pr_warn("step4: then repeat get.if get success ,previous free operate success.\n");
pinctrl = devm_pinctrl_get(dev);
if (IS_ERR(pinctrl)) {
pr_warn(" after free,we repeat get pinctrl handle [%s] failed...,return value %ld\n",device_name,PTR_ERR(pinctrl));
return -EINVAL;
}
pinctrl_put(pinctrl);
pr_warn("test pinctrl devm get and put api success!\n");
pr_warn("-----------------------------------------------\n\n");
return ret;
}
static ssize_t exec_show(struct device *dev,struct device_attribute *attr,
char *buf)
{
struct pinctrl_axp_test_data *pinctrl_axp_test = dev_get_drvdata(dev);
return sprintf(buf,"%u\n",pinctrl_axp_test->exec);
}
static ssize_t exec_store(struct device *dev,struct device_attribute *attr,
const char *buf,size_t size)
{
struct pinctrl_axp_test_data *pinctrl_axp_test = dev_get_drvdata(dev);
char *after;
int final =0;
int exec_number =simple_strtoul(buf,&after,10);
switch(exec_number){
case 0:
final = test_request_all_resource_api(dev,pinctrl_axp_test);
break;
case 1:
final = test_re_request_all_resource_api(dev,pinctrl_axp_test);
break;
case 2:
final = test_pin_function_set_api(dev,pinctrl_axp_test);
break;
case 3:
final = test_pin_data_set_api(dev,pinctrl_axp_test);
break;
case 4:
final = test_gpio_request_free_api(pinctrl_axp_test);
break;
case 5:
final = test_gpio_repeat_request_free_api(pinctrl_axp_test);
break;
case 6:
final = test_gpiolib_api(pinctrl_axp_test);
break;
case 7:
final = test_pinctrl_scripts_api(pinctrl_axp_test);
break;
case 8:
final = test_pinctrl_request_gpio_api(pinctrl_axp_test);
break;
case 9:
final = test_pinctrl_free_gpio_api(pinctrl_axp_test);
break;
case 10:
final = test_pinctrl_gpio_direction_input_api(pinctrl_axp_test);
break;
case 11:
final = test_pinctrl_gpio_direction_output_api(pinctrl_axp_test);
break;
case 12:
final = test_pinctrl_get_api(dev,pinctrl_axp_test);
break;
case 13:
final = test_pinctrl_lookup_state_api(dev,pinctrl_axp_test);
break;
case 14:
final = test_pinctrl_select_state_api(dev,pinctrl_axp_test);
break;
case 15:
final = test_pinctrl_put_api(dev,pinctrl_axp_test);
break;
case 16:
final = test_pinctrl_devm_get_put_api(dev,pinctrl_axp_test);
break;
default:
pr_warn(" your input number should less than case number.\n");
final=1;
break;
}
pinctrl_axp_test->exec = exec_number;
if (final)
pinctrl_axp_result[exec_number].result=CASE_TEST_FAILED;
else{
if (pinctrl_axp_result[exec_number].result==CASE_HAVE_NOT_TEST)
pinctrl_axp_result[exec_number].result = CASE_TEST_SUCCESSED;
}
return size;
}
static ssize_t gpio_index_show(struct device *dev,struct device_attribute *attr,
char *buf)
{
/*chang gpio index to pin name */
char pin_name[PINCTRL_AXP_TEST_NUMBER];
struct pinctrl_axp_test_data *pinctrl_axp_test=dev_get_drvdata(dev);
axp_gpio_to_name(pinctrl_axp_test->gpio_index, pin_name);
return sprintf(buf,"%s\n",pin_name);
}
static ssize_t gpio_index_store(struct device *dev,struct device_attribute *attr,
const char *buf,size_t size)
{
struct pinctrl_axp_test_data *pinctrl_axp_test = dev_get_drvdata(dev);
char *after;
int gpio_index= simple_strtoul(buf,&after,10);
size_t count=after-buf;
ssize_t ret= -EINVAL;
if (isspace(*after))
count++;
if(count==size){
ret = count;
pinctrl_axp_test->gpio_index = gpio_index;
}
if (!IS_AXP_PIN(pinctrl_axp_test->gpio_index)) {
pr_err("NOT AXP PIN\n");
}
return ret;
}
static ssize_t function_show(struct device *dev,struct device_attribute *attr,
char *buf)
{
struct pinctrl_axp_test_data *pinctrl_axp_test=dev_get_drvdata(dev);
return sprintf(buf,"%u\n",pinctrl_axp_test->funcs);
}
static ssize_t function_store(struct device *dev,struct device_attribute *attr,
const char *buf,size_t size)
{
struct pinctrl_axp_test_data *pinctrl_axp_test=dev_get_drvdata(dev);
char *after;
int funcs =simple_strtoul(buf,&after,10);
size_t count =after-buf;
ssize_t ret =-EINVAL;
if (isspace(*after))
count++;
if(count==size){
ret=count;
pinctrl_axp_test->funcs=funcs;
}
return ret;
}
static ssize_t data_show(struct device *dev,struct device_attribute *attr,
char *buf)
{
struct pinctrl_axp_test_data *pinctrl_axp_test=dev_get_drvdata(dev);
return sprintf(buf,"%u\n",pinctrl_axp_test->dat);
}
static ssize_t data_store(struct device *dev,struct device_attribute *attr,
const char *buf,size_t size)
{
struct pinctrl_axp_test_data *pinctrl_axp_test=dev_get_drvdata(dev);
char *after;
int dat =simple_strtoul(buf,&after,10);
size_t count =after-buf;
ssize_t ret =-EINVAL;
if (isspace(*after))
count++;
if(count==size){
ret=count;
pinctrl_axp_test->dat=dat;
}
return ret;
}
static ssize_t test_result_show(struct device *dev,struct device_attribute *attr,
char *buf)
{
return sprintf(buf,"%d\n",pinctrl_axp_result[test_case_number].result);
}
static ssize_t test_result_shore(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
return size;
}
static ssize_t dev_name_show(struct device *dev,struct device_attribute *attr,
char *buf)
{
struct pinctrl_axp_test_data *pinctrl_axp_test=dev_get_drvdata(dev);
return sprintf(buf,"%s\n",pinctrl_axp_test->dev_name);
}
static ssize_t dev_name_shore(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int ret;
struct pinctrl_axp_test_data *pinctrl_axp_test = dev_get_drvdata(dev);
if(size>PINCTRL_AXP_DEV_NAME_MAX_LEN){
pr_warn("sunxi dev name max len less than 20 char.\n");
return -EINVAL;
}
ret=strlcpy(pinctrl_axp_test->dev_name,buf, size);
return ret;
}
static struct device_attribute pinctrl_axp_test_class_attrs[] = {
__ATTR(exec, S_IRUGO|S_IWUSR, exec_show, exec_store),
__ATTR(gpio_index,S_IRUGO|S_IWUSR,gpio_index_show,gpio_index_store),
__ATTR(function,S_IRUGO|S_IWUSR,function_show,function_store),
__ATTR(dat,S_IRUGO|S_IWUSR,data_show,data_store),
__ATTR(test_result,S_IRUGO|S_IWUSR,test_result_show,test_result_shore),
__ATTR(dev_name,S_IRUGO|S_IWUSR,dev_name_show,dev_name_shore),
__ATTR_NULL
};
static int pinctrl_axp_test_probe(struct platform_device *pdev)
{
struct pinctrl_axp_test_data *pinctrl_axp_test;
pinctrl_axp_test=devm_kzalloc(&pdev->dev,sizeof(*pinctrl_axp_test),GFP_KERNEL);
if(!pinctrl_axp_test){
dev_err(&pdev->dev,"No enougt memory for device \n");
return -ENOMEM;
}
platform_set_drvdata(pdev,pinctrl_axp_test);
pinctrl_axp_test_class = class_create(THIS_MODULE,"pinctrl_axp_test_class");
if(IS_ERR(pinctrl_axp_test_class))
return PTR_ERR(pinctrl_axp_test_class);
pinctrl_axp_test_class->dev_attrs = pinctrl_axp_test_class_attrs;
pinctrl_axp_test->dev=device_create(pinctrl_axp_test_class,&pdev->dev,0,
pinctrl_axp_test,"pinctrl_axp_test");
if(IS_ERR(pinctrl_axp_test->dev))
return PTR_ERR(pinctrl_axp_test->dev);
return 0;
}
static struct platform_driver pinctrl_axp_test_driver={
.probe =pinctrl_axp_test_probe,
.driver ={
.name ="pinctrl_axp_test",
.owner =THIS_MODULE,
},
};
static struct platform_device pinctrl_axp_test_device={
.name ="pinctrl_axp_test",
.id =PLATFORM_DEVID_NONE,
};
static int __init pinctrl_axp_test_init(void)
{
int ret,i;
for(i=0;i<PINCTRL_AXP_TEST_NUMBER;i++){
pinctrl_axp_result[i].result=CASE_HAVE_NOT_TEST;
}
ret=platform_device_register(&pinctrl_axp_test_device);
if(IS_ERR_VALUE(ret)){
pr_warn("register sunxi pinctrl test device failed\n");
return -EINVAL;
}
ret=platform_driver_register(&pinctrl_axp_test_driver);
if(IS_ERR_VALUE(ret)){
pr_warn("register sunxi pinctrl test driver failed\n");
return -EINVAL;
}
return ret;
return 0;
}
static void __exit pinctrl_axp_test_exit(void)
{
platform_device_unregister(&pinctrl_axp_test_device);
platform_driver_unregister(&pinctrl_axp_test_driver);
class_destroy(pinctrl_axp_test_class);
}
module_init(pinctrl_axp_test_init);
module_exit(pinctrl_axp_test_exit);
MODULE_AUTHOR("Ming Li <liming@allwinnertech.com");
MODULE_DESCRIPTION("Allwinner pinctrl axp driver test");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink