Skip to content

L
linux
Commit 8bc395a6 authored by Kent Gibson's avatar Kent Gibson Committed by Bartosz Golaszewski
Browse files
Options

selftests: gpio: rework and simplify test implementation 

The GPIO mockup selftests are overly complicated with separate
implementations of the tests for sysfs and cdev uAPI, and with the cdev
implementation being dependent on tools/gpio and libmount.

Rework the test implementation to provide a common test suite with a
simplified pluggable uAPI interface.  The cdev implementation utilises
the GPIO uAPI directly to remove the dependence on tools/gpio.
The simplified uAPI interface removes the need for any file system mount
checks in C, and so removes the dependence on libmount.

The rework also fixes the sysfs test implementation which has been broken
since the device created in the multiple gpiochip case was split into
separate devices.

Fixes: 8a39f597 ("gpio: mockup: rework device probing")
Signed-off-by: default avatarKent Gibson <warthog618@gmail.com>
Acked-by: default avatarLinus Walleij <linus.walleij@linaro.org>
Signed-off-by: default avatarBartosz Golaszewski <bgolaszewski@baylibre.com>
parent 27f8feea
Hide whitespace changes
Inline Side-by-side
Showing with 535 additions and 288 deletions
tools/testing/selftests/gpio/Makefile
View file @ 8bc395a6
# SPDX-License-Identifier: GPL-2.0 # SPDX-License-Identifier: GPL-2.0
VAR_CFLAGS := $(shell pkg-config --cflags mount 2>/dev/null)
VAR_LDLIBS := $(shell pkg-config --libs mount 2>/dev/null)
ifeq ($(VAR_LDLIBS),)
VAR_LDLIBS := -lmount -I/usr/include/libmount
endif
CFLAGS += -O2 -g -std=gnu99 -Wall -I../../../../usr/include/ $(VAR_CFLAGS)
LDLIBS += $(VAR_LDLIBS)
TEST_PROGS := gpio-mockup.sh TEST_PROGS := gpio-mockup.sh
TEST_FILES := gpio-mockup-sysfs.sh TEST_FILES := gpio-mockup-sysfs.sh
TEST_GEN_PROGS_EXTENDED := gpio-mockup-chardev TEST_GEN_PROGS_EXTENDED := gpio-mockup-cdev
KSFT_KHDR_INSTALL := 1
include ../lib.mk include ../lib.mk
GPIODIR := $(realpath ../../../gpio)
GPIOOUT := $(OUTPUT)/tools-gpio/
GPIOOBJ := $(GPIOOUT)/gpio-utils.o
CLEAN += ; $(RM) -rf $(GPIOOUT)
$(TEST_GEN_PROGS_EXTENDED): $(GPIOOBJ)
$(GPIOOUT):
mkdir -p $@
$(GPIOOBJ): $(GPIOOUT)
$(MAKE) OUTPUT=$(GPIOOUT) -C $(GPIODIR)
tools/testing/selftests/gpio/gpio-mockup-cdev.c 0 → 100644
View file @ 8bc395a6
// SPDX-License-Identifier: GPL-2.0
/*
* GPIO mockup cdev test helper
*
* Copyright (C) 2020 Kent Gibson
*/
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/gpio.h>
#define CONSUMER "gpio-mockup-cdev"
static int request_line_v1(int cfd, unsigned int offset,
uint32_t flags, unsigned int val)
{
struct gpiohandle_request req;
int ret;
memset(&req, 0, sizeof(req));
req.lines = 1;
req.lineoffsets[0] = offset;
req.flags = flags;
strcpy(req.consumer_label, CONSUMER);
if (flags & GPIOHANDLE_REQUEST_OUTPUT)
req.default_values[0] = val;
ret = ioctl(cfd, GPIO_GET_LINEHANDLE_IOCTL, &req);
if (ret == -1)
return -errno;
return req.fd;
}
static int get_value_v1(int lfd)
{
struct gpiohandle_data vals;
int ret;
memset(&vals, 0, sizeof(vals));
ret = ioctl(lfd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &vals);
if (ret == -1)
return -errno;
return vals.values[0];
}
static void usage(char *prog)
{
printf("Usage: %s [-l] [-b <bias>] [-s <value>] [-u <uAPI>] <gpiochip> <offset>\n", prog);
printf(" -b: set line bias to one of pull-down, pull-up, disabled\n");
printf(" (default is to leave bias unchanged):\n");
printf(" -l: set line active low (default is active high)\n");
printf(" -s: set line value (default is to get line value)\n");
exit(-1);
}
static int wait_signal(void)
{
int sig;
sigset_t wset;
sigemptyset(&wset);
sigaddset(&wset, SIGHUP);
sigaddset(&wset, SIGINT);
sigaddset(&wset, SIGTERM);
sigwait(&wset, &sig);
return sig;
}
int main(int argc, char *argv[])
{
char *chip;
int opt, ret, cfd, lfd;
unsigned int offset, val;
uint32_t flags_v1;
ret = 0;
flags_v1 = GPIOHANDLE_REQUEST_INPUT;
while ((opt = getopt(argc, argv, "lb:s:u:")) != -1) {
switch (opt) {
case 'l':
flags_v1 |= GPIOHANDLE_REQUEST_ACTIVE_LOW;
break;
case 'b':
if (strcmp("pull-up", optarg) == 0)
flags_v1 |= GPIOHANDLE_REQUEST_BIAS_PULL_UP;
else if (strcmp("pull-down", optarg) == 0)
flags_v1 |= GPIOHANDLE_REQUEST_BIAS_PULL_DOWN;
else if (strcmp("disabled", optarg) == 0)
flags_v1 |= GPIOHANDLE_REQUEST_BIAS_DISABLE;
break;
case 's':
val = atoi(optarg);
flags_v1 &= ~GPIOHANDLE_REQUEST_INPUT;
flags_v1 |= GPIOHANDLE_REQUEST_OUTPUT;
break;
default:
usage(argv[0]);
}
}
if (argc < optind + 2)
usage(argv[0]);
chip = argv[optind];
offset = atoi(argv[optind + 1]);
cfd = open(chip, 0);
if (cfd == -1) {
fprintf(stderr, "Failed to open %s: %s\n", chip, strerror(errno));
return -errno;
}
lfd = request_line_v1(cfd, offset, flags_v1, val);
close(cfd);
if (lfd < 0) {
fprintf(stderr, "Failed to request %s:%d: %s\n", chip, offset, strerror(-lfd));
return lfd;
}
if (flags_v1 & GPIOHANDLE_REQUEST_OUTPUT)
wait_signal();
else
ret = get_value_v1(lfd);
close(lfd);
return ret;
}
tools/testing/selftests/gpio/gpio-mockup-sysfs.sh
View file @ 8bc395a6
# SPDX-License-Identifier: GPL-2.0 # SPDX-License-Identifier: GPL-2.0
is_consistent()
{
val=
active_low_sysfs=`cat $GPIO_SYSFS/gpio$nr/active_low`
val_sysfs=`cat $GPIO_SYSFS/gpio$nr/value`
dir_sysfs=`cat $GPIO_SYSFS/gpio$nr/direction`
gpio_this_debugfs=`cat $GPIO_DEBUGFS |grep "gpio-$nr" | sed "s/(.*)//g"` # Overrides functions in gpio-mockup.sh to test using the GPIO SYSFS uAPI
dir_debugfs=`echo $gpio_this_debugfs | awk '{print $2}'`
val_debugfs=`echo $gpio_this_debugfs | awk '{print $3}'`
if [ $val_debugfs = "lo" ]; then
val=0
elif [ $val_debugfs = "hi" ]; then
val=1
fi
if [ $active_low_sysfs = "1" ]; then SYSFS=`grep -w sysfs /proc/mounts | cut -f2 -d' '`
if [ $val = "0" ]; then [ -d "$SYSFS" ] || skip "sysfs is not mounted"
val="1"
else
val="0"
fi
fi
if [ $val_sysfs = $val ] && [ $dir_sysfs = $dir_debugfs ]; then GPIO_SYSFS="${SYSFS}/class/gpio"
echo -n "." [ -d "$GPIO_SYSFS" ] || skip "CONFIG_GPIO_SYSFS is not selected"
else
echo "test fail, exit"
die
fi
}
test_pin_logic() PLATFORM_SYSFS=$SYSFS/devices/platform
{
nr=$1
direction=$2
active_low=$3
value=$4
echo $direction > $GPIO_SYSFS/gpio$nr/direction sysfs_nr=
echo $active_low > $GPIO_SYSFS/gpio$nr/active_low sysfs_ldir=
if [ $direction = "out" ]; then
echo $value > $GPIO_SYSFS/gpio$nr/value
fi
is_consistent $nr
}
test_one_pin() # determine the sysfs GPIO number given the $chip and $offset
# e.g. gpiochip1:32
find_sysfs_nr()
{ {
nr=$1 # e.g. /sys/devices/platform/gpio-mockup.1/gpiochip1
local platform=$(find $PLATFORM_SYSFS -mindepth 2 -maxdepth 2 -type d -name $chip)
echo -n "test pin<$nr>" [ "$platform" ] || fail "can't find platform of $chip"
# e.g. /sys/devices/platform/gpio-mockup.1/gpio/gpiochip508/base
echo $nr > $GPIO_SYSFS/export 2>/dev/null local base=$(find ${platform%/*}/gpio/ -mindepth 2 -maxdepth 2 -type f -name base)
[ "$base" ] || fail "can't find base of $chip"
if [ X$? != X0 ]; then sysfs_nr=$(($(< "$base") + $offset))
echo "test GPIO pin $nr failed" sysfs_ldir="$GPIO_SYSFS/gpio$sysfs_nr"
die
fi
#"Checking if the sysfs is consistent with debugfs: "
is_consistent $nr
#"Checking the logic of active_low: "
test_pin_logic $nr out 1 1
test_pin_logic $nr out 1 0
test_pin_logic $nr out 0 1
test_pin_logic $nr out 0 0
#"Checking the logic of direction: "
test_pin_logic $nr in 1 1
test_pin_logic $nr out 1 0
test_pin_logic $nr low 0 1
test_pin_logic $nr high 0 0
echo $nr > $GPIO_SYSFS/unexport
echo "successful"
} }
test_one_pin_fail() acquire_line()
{ {
nr=$1 [ "$sysfs_nr" ] && return
find_sysfs_nr
echo $nr > $GPIO_SYSFS/export 2>/dev/null echo "$sysfs_nr" > "$GPIO_SYSFS/export"
if [ X$? != X0 ]; then
echo "test invalid pin $nr successful"
else
echo "test invalid pin $nr failed"
echo $nr > $GPIO_SYSFS/unexport 2>/dev/null
die
fi
} }
list_chip() # The helpers being overridden...
get_line()
{ {
echo `ls -d $GPIO_DRV_SYSFS/gpiochip* 2>/dev/null` [ -e "$sysfs_ldir/value" ] && echo $(< "$sysfs_ldir/value")
} }
test_chip() set_line()
{ {
chip=$1 acquire_line
name=`basename $chip`
base=`cat $chip/base` for option in $*; do
ngpio=`cat $chip/ngpio` case $option in
printf "%-10s %-5s %-5s\n" $name $base $ngpio active-high)
if [ $ngpio = "0" ]; then echo 0 > "$sysfs_ldir/active_low"
echo "number of gpio is zero is not allowed". ;;
fi active-low)
test_one_pin $base echo 1 > "$sysfs_ldir/active_low"
test_one_pin $(($base + $ngpio - 1)) ;;
test_one_pin $((( RANDOM % $ngpio ) + $base )) input)
echo "in" > "$sysfs_ldir/direction"
;;
0)
echo "out" > "$sysfs_ldir/direction"
echo 0 > "$sysfs_ldir/value"
;;
1)
echo "out" > "$sysfs_ldir/direction"
echo 1 > "$sysfs_ldir/value"
;;
esac
done
} }
test_chips_sysfs() release_line()
{ {
gpiochip=`list_chip $module` [ "$sysfs_nr" ] || return 0
if [ X"$gpiochip" = X ]; then echo "$sysfs_nr" > "$GPIO_SYSFS/unexport"
if [ X"$valid" = Xfalse ]; then sysfs_nr=
echo "successful" sysfs_ldir=
else
echo "fail"
die
fi
else
for chip in $gpiochip; do
test_chip $chip
done
fi
} }
tools/testing/selftests/gpio/gpio-mockup.sh
View file @ 8bc395a6
#!/bin/bash #!/bin/bash -efu
# SPDX-License-Identifier: GPL-2.0 # SPDX-License-Identifier: GPL-2.0
#exit status #exit status
#1: Internal error #0: success
#2: sysfs/debugfs not mount #1: fail
#3: insert module fail when gpio-mockup is a module. #4: skip test - including run as non-root user
#4: Skip test including run as non-root user.
#5: other reason. BASE=${0%/*}
SYSFS=
GPIO_SYSFS=
GPIO_DRV_SYSFS=
DEBUGFS= DEBUGFS=
GPIO_DEBUGFS= GPIO_DEBUGFS=
dev_type= dev_type="cdev"
module= module="gpio-mockup"
verbose=
full_test=
random=
active_opt=
bias_opt=
line_set_pid=
# Kselftest framework requirement - SKIP code is 4. # Kselftest return codes
ksft_fail=1
ksft_skip=4 ksft_skip=4
usage() usage()
{ {
echo "Usage:" echo "Usage:"
echo "$0 [-f] [-m name] [-t type]" echo "$0 [-frv] [-t type]"
echo "-f: full test. It maybe conflict with existence gpio device." echo "-f: full test (minimal set run by default)"
echo "-m: module name, default name is gpio-mockup. It could also test" echo "-r: test random lines as well as fence posts"
echo " other gpio device." echo "-t: interface type:"
echo "-t: interface type: chardev(char device) and sysfs(being" echo " cdev (character device ABI) - default"
echo " deprecated). The first one is default" echo " sysfs (deprecated SYSFS ABI)"
echo "" echo "-v: verbose progress reporting"
echo "$0 -h" exit $ksft_fail
echo "This usage"
} }
prerequisite() skip()
{ {
msg="skip all tests:" echo "$*" >&2
if [ $UID != 0 ]; then echo "GPIO $module test SKIP"
echo $msg must be run as root >&2 exit $ksft_skip
exit $ksft_skip
fi
SYSFS=`mount -t sysfs | head -1 | awk '{ print $3 }'`
if [ ! -d "$SYSFS" ]; then
echo $msg sysfs is not mounted >&2
exit 2
fi
GPIO_SYSFS=`echo $SYSFS/class/gpio`
GPIO_DRV_SYSFS=`echo $SYSFS/devices/platform/$module/gpio`
DEBUGFS=`mount -t debugfs | head -1 | awk '{ print $3 }'`
if [ ! -d "$DEBUGFS" ]; then
echo $msg debugfs is not mounted >&2
exit 2
fi
GPIO_DEBUGFS=`echo $DEBUGFS/gpio`
source gpio-mockup-sysfs.sh
} }
try_insert_module() prerequisite()
{ {
if [ -d "$GPIO_DRV_SYSFS" ]; then [ $(id -u) -eq 0 ] || skip "must be run as root"
echo "$GPIO_DRV_SYSFS exist. Skip insert module"
else DEBUGFS=$(grep -w debugfs /proc/mounts | cut -f2 -d' ')
modprobe -q $module $1 [ -d "$DEBUGFS" ] || skip "debugfs is not mounted"
if [ X$? != X0 ]; then
echo $msg insmod $module failed >&2 GPIO_DEBUGFS=$DEBUGFS/$module
exit 3
fi
fi
} }
remove_module() remove_module()
...@@ -74,133 +57,340 @@ remove_module() ...@@ -74,133 +57,340 @@ remove_module()
modprobe -r -q $module modprobe -r -q $module
} }
die() cleanup()
{ {
set +e
release_line
remove_module remove_module
exit 5 jobs -p | xargs -r kill > /dev/null 2>&1
} }
test_chips() fail()
{ {
if [ X$dev_type = Xsysfs ]; then echo "test failed: $*" >&2
echo "WARNING: sysfs ABI of gpio is going to deprecated." echo "GPIO $module test FAIL"
test_chips_sysfs $* exit $ksft_fail
else }
$BASE/gpio-mockup-chardev $*
fi try_insert_module()
{
modprobe -q $module "$1" || fail "insert $module failed with error $?"
}
log()
{
[ -z "$verbose" ] || echo "$*"
} }
gpio_test() # The following line helpers, release_Line, get_line and set_line, all
# make use of the global $chip and $offset variables.
#
# This implementation drives the GPIO character device (cdev) uAPI.
# Other implementations may override these to test different uAPIs.
# Release any resources related to the line
release_line()
{ {
param=$1 [ "$line_set_pid" ] && kill $line_set_pid && wait $line_set_pid || true
valid=$2 line_set_pid=
}
if [ X"$param" = X ]; then # Read the current value of the line
die get_line()
{
release_line
$BASE/gpio-mockup-cdev $active_opt /dev/$chip $offset
echo $?
}
# Set the state of the line
#
# Changes to line configuration are provided as parameters.
# The line is assumed to be an output if the line value 0 or 1 is
# specified, else an input.
set_line()
{
local val=
release_line
# parse config options...
for option in $*; do
case $option in
active-low)
active_opt="-l "
;;
active-high)
active_opt=
;;
bias-none)
bias_opt=
;;
pull-down)
bias_opt="-bpull-down "
;;
pull-up)
bias_opt="-bpull-up "
;;
0)
val=0
;;
1)
val=1
;;
esac
done
local cdev_opts=${active_opt}
if [ "$val" ]; then
$BASE/gpio-mockup-cdev $cdev_opts -s$val /dev/$chip $offset &
# failure to set is detected by reading mockup and toggling values
line_set_pid=$!
# allow for gpio-mockup-cdev to launch and request line
# (there is limited value in checking if line has been requested)
sleep 0.01
elif [ "$bias_opt" ]; then
cdev_opts=${cdev_opts}${bias_opt}
$BASE/gpio-mockup-cdev $cdev_opts /dev/$chip $offset || true
fi fi
try_insert_module "gpio_mockup_ranges=$param"
echo -n "GPIO $module test with ranges: <"
echo "$param>: "
printf "%-10s %s\n" $param
test_chips $module $valid
remove_module
} }
BASE=`dirname $0` assert_line()
{
local val
# don't need any retry here as set_mock allows for propagation
val=$(get_line)
[ "$val" = "$1" ] || fail "line value is ${val:-empty} when $1 was expected"
}
# The following mockup helpers all make use of the $mock_line
assert_mock()
{
local backoff_wait=10
local retry=0
local val
# retry allows for set propagation from uAPI to mockup
while true; do
val=$(< $mock_line)
[ "$val" = "$1" ] && break
retry=$((retry + 1))
[ $retry -lt 5 ] || fail "mockup $mock_line value ${val:-empty} when $1 expected"
sleep $(printf "%0.2f" $((backoff_wait))e-3)
backoff_wait=$((backoff_wait * 2))
done
}
set_mock()
{
echo "$1" > $mock_line
# allow for set propagation - so we won't be in a race with set_line
assert_mock "$1"
}
dev_type= # test the functionality of a line
TEMP=`getopt -o fhm:t: -n '$0' -- "$@"` #
# The line is set from the mockup side and is read from the userspace side
# (input), and is set from the userspace side and is read from the mockup side
# (output).
#
# Setting the mockup pull using the userspace interface bias settings is
# tested where supported by the userspace interface (cdev).
test_line()
{
chip=$1
offset=$2
log "test_line $chip $offset"
mock_line=$GPIO_DEBUGFS/$chip/$offset
[ -e "$mock_line" ] || fail "missing line $chip:$offset"
if [ "$?" != "0" ]; then # test input active-high
echo "Parameter process failed, Terminating..." >&2 set_mock 1
exit 1 set_line input active-high
fi assert_line 1
set_mock 0
assert_line 0
set_mock 1
assert_line 1
if [ "$full_test" ]; then
if [ "$dev_type" != "sysfs" ]; then
# test pulls
set_mock 0
set_line input pull-up
assert_line 1
set_mock 0
assert_line 0
set_mock 1
set_line input pull-down
assert_line 0
set_mock 1
assert_line 1
set_line bias-none
fi
# test input active-low
set_mock 0
set_line active-low
assert_line 1
set_mock 1
assert_line 0
set_mock 0
assert_line 1
# test output active-high
set_mock 1
set_line active-high 0
assert_mock 0
set_line 1
assert_mock 1
set_line 0
assert_mock 0
fi
# test output active-low
set_mock 0
set_line active-low 0
assert_mock 1
set_line 1
assert_mock 0
set_line 0
assert_mock 1
release_line
}
test_no_line()
{
log test_no_line "$*"
[ ! -e "$GPIO_DEBUGFS/$1/$2" ] || fail "unexpected line $1:$2"
}
# Note the quotes around `$TEMP': they are essential! # Load the module and check that the expected number of gpiochips, with the
eval set -- "$TEMP" # expected number of lines, are created and are functional.
#
# $1 is the gpio_mockup_ranges parameter for the module
# The remaining parameters are the number of lines, n, expected for each of
# the gpiochips expected to be created.
#
# For each gpiochip the fence post lines, 0 and n-1, are tested, and the
# line on the far side of the fence post, n, is tested to not exist.
#
# If the $random flag is set then a random line in the middle of the
# gpiochip is tested as well.
insmod_test()
{
local ranges=
local gc=
local width=
while true; do [ "${1:-}" ] || fail "missing ranges"
case $1 in ranges=$1 ; shift
-f) try_insert_module "gpio_mockup_ranges=$ranges"
log "GPIO $module test with ranges: <$ranges>:"
# e.g. /sys/kernel/debug/gpio-mockup/gpiochip1
gpiochip=$(find "$DEBUGFS/$module/" -name gpiochip* -type d | sort)
for chip in $gpiochip; do
gc=${chip##*/}
[ "${1:-}" ] || fail "unexpected chip - $gc"
width=$1 ; shift
test_line $gc 0
if [ "$random" -a $width -gt 2 ]; then
test_line $gc $((RANDOM % ($width - 2) + 1))
fi
test_line $gc $(($width - 1))
test_no_line $gc $width
done
[ "${1:-}" ] && fail "missing expected chip of width $1"
remove_module || fail "failed to remove module with error $?"
}
while getopts ":frvt:" opt; do
case $opt in
f)
full_test=true full_test=true
shift
;;
-h)
usage
exit
;; ;;
-m) r)
module=$2 random=true
shift 2
;; ;;
-t) t)
dev_type=$2 dev_type=$OPTARG
shift 2
;; ;;
--) v)
shift verbose=true
break
;; ;;
*) *)
echo "Internal error!" usage
exit 1
;; ;;
esac esac
done done
shift $((OPTIND - 1))
if [ X"$module" = X ]; then [ "${1:-}" ] && fail "unknown argument '$1'"
module="gpio-mockup"
fi
if [ X$dev_type != Xsysfs ]; then
dev_type="chardev"
fi
prerequisite prerequisite
echo "1. Test dynamic allocation of gpio successful means insert gpiochip and" trap 'exit $ksft_fail' SIGTERM SIGINT
echo " manipulate gpio pin successful" trap cleanup EXIT
gpio_test "-1,32" true
gpio_test "-1,32,-1,32" true case "$dev_type" in
gpio_test "-1,32,-1,32,-1,32" true sysfs)
if [ X$full_test = Xtrue ]; then source $BASE/gpio-mockup-sysfs.sh
gpio_test "-1,32,32,64" true echo "WARNING: gpio sysfs ABI is deprecated."
gpio_test "-1,32,40,64,-1,5" true ;;
gpio_test "-1,32,32,64,-1,32" true cdev)
gpio_test "0,32,32,64,-1,32,-1,32" true ;;
gpio_test "-1,32,-1,32,0,32,32,64" true *)
echo "2. Do basic test: successful means insert gpiochip and" fail "unknown interface type: $dev_type"
echo " manipulate gpio pin successful" ;;
gpio_test "0,32" true esac
gpio_test "0,32,32,64" true
gpio_test "0,32,40,64,64,96" true remove_module || fail "can't remove existing $module module"
# manual gpio allocation tests fail if a physical chip already exists
[ "$full_test" -a -e "/dev/gpiochip0" ] && skip "full tests conflict with gpiochip0"
echo "1. Module load tests"
echo "1.1. dynamic allocation of gpio"
insmod_test "-1,32" 32
insmod_test "-1,23,-1,32" 23 32
insmod_test "-1,23,-1,26,-1,32" 23 26 32
if [ "$full_test" ]; then
echo "1.2. manual allocation of gpio"
insmod_test "0,32" 32
insmod_test "0,32,32,60" 32 28
insmod_test "0,32,40,64,64,96" 32 24 32
echo "1.3. dynamic and manual allocation of gpio"
insmod_test "-1,32,32,62" 32 30
insmod_test "-1,22,-1,23,0,24,32,64" 22 23 24 32
insmod_test "-1,32,32,60,-1,29" 32 28 29
insmod_test "-1,32,40,64,-1,5" 32 24 5
insmod_test "0,32,32,44,-1,22,-1,31" 32 12 22 31
fi fi
echo "3. Error test: successful means insert gpiochip failed" echo "2. Module load error tests"
echo "3.1 Test number of gpio overflow" echo "2.1 gpio overflow"
#Currently: The max number of gpio(1024) is defined in arm architecture. # Currently: The max number of gpio(1024) is defined in arm architecture.
gpio_test "-1,32,-1,1024" false insmod_test "-1,1024"
if [ X$full_test = Xtrue ]; then if [ "$full_test" ]; then
echo "3.2 Test zero line of gpio" echo "2.2 no lines defined"
gpio_test "0,0" false insmod_test "0,0"
echo "3.3 Test range overlap" echo "2.3 ignore range overlap"
echo "3.3.1 Test corner case" insmod_test "0,32,0,1" 32
gpio_test "0,32,0,1" false insmod_test "0,32,1,5" 32
gpio_test "0,32,32,64,32,40" false insmod_test "0,32,30,35" 32
gpio_test "0,32,35,64,35,45" false insmod_test "0,32,31,32" 32
gpio_test "0,32,31,32" false insmod_test "10,32,30,35" 22
gpio_test "0,32,32,64,36,37" false insmod_test "10,32,9,14" 22
gpio_test "0,32,35,64,34,36" false insmod_test "0,32,20,21,40,56" 32 16
echo "3.3.2 Test inserting invalid second gpiochip" insmod_test "0,32,32,64,32,40" 32 32
gpio_test "0,32,30,35" false insmod_test "0,32,32,64,36,37" 32 32
gpio_test "0,32,1,5" false insmod_test "0,32,35,64,34,36" 32 29
gpio_test "10,32,9,14" false insmod_test "0,30,35,64,35,45" 30 29
gpio_test "10,32,30,35" false insmod_test "0,32,40,56,30,33" 32 16
echo "3.3.3 Test others" insmod_test "0,32,40,56,30,41" 32 16
gpio_test "0,32,40,56,39,45" false insmod_test "0,32,40,56,39,45" 32 16
gpio_test "0,32,40,56,30,33" false
gpio_test "0,32,40,56,30,41" false
gpio_test "0,32,40,56,20,21" false
fi fi
echo GPIO test PASS echo "GPIO $module test PASS"
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7