Hi Nvidia Team,
I am using a Jetson AGX Thor module on a custom carrier board with JetPack 7.2. In the pinmux I have configured GPIO64 as a GPIO output; that pad is GPIO3_PU.01. I am trying to drive it with gpioset (including --mode=wait), but the pin value does not change.
Also output of “sudo cat /sys/kernel/debug/gpio | grep PU.01” shows 579 and same for PU.00 is 578 but in Jetson Thor Adaptation and Bring-Up — NVIDIA Jetson Linux Developer Guide mentions 356.
I also tried controlling it by creating a driver.
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/gpio.h>
/* Meta Information */
MODULE_LICENSE("GPL");
MODULE_AUTHOR("DSC PU.01 GNU/Linux");
MODULE_DESCRIPTION("A simple gpio driver for enabling/disabling PU.01 UART S/W Select");
/* Variables for device and device class */
static dev_t my_device_nr;
static struct class *my_class;
static struct cdev my_device;
#define DRIVER_NAME "PU.01"
#define DRIVER_CLASS "GPIO579Class"
/**
* @brief Read data out of the buffer
*/
static ssize_t driver_read(struct file *File, char *user_buffer, size_t count, loff_t *offs) {
int to_copy, not_copied, delta;
char tmp[3] = " \n";
/* Get amount of data to copy */
to_copy = min(count, sizeof(tmp));
/* Read value of button */
printk("Value of button: %d\n", gpio_get_value(579));
tmp[0] = gpio_get_value(579) + '0';
/* Copy data to user */
not_copied = copy_to_user(user_buffer, &tmp, to_copy);
/* Calculate data */
delta = to_copy - not_copied;
return delta;
}
/**
* @brief Write data to buffer
*/
static ssize_t driver_write(struct file *File, const char *user_buffer, size_t count, loff_t *offs) {
int to_copy, not_copied, delta;
char value;
/* Get amount of data to copy */
to_copy = min(count, sizeof(value));
/* Copy data to user */
not_copied = copy_from_user(&value, user_buffer, to_copy);
/* Setting the LED */
switch(value) {
case '0':
gpio_set_value(579, 0);
break;
case '1':
gpio_set_value(579, 1);
break;
default:
printk("Invalid Input!\n");
break;
}
/* Calculate data */
delta = to_copy - not_copied;
return delta;
}
/**
* @brief This function is called, when the device file is opened
*/
static int driver_open(struct inode *device_file, struct file *instance) {
printk("dev_nr - open was called!\n");
return 0;
}
/**
* @brief This function is called, when the device file is opened
*/
static int driver_close(struct inode *device_file, struct file *instance) {
printk("dev_nr - close was called!\n");
return 0;
}
static struct file_operations fops = {
.owner = THIS_MODULE,
.open = driver_open,
.release = driver_close,
.read = driver_read,
.write = driver_write
};
/**
* @brief This function is called, when the module is loaded into the kernel
*/
static int __init ModuleInit(void) {
printk("Hello, Kernel!\n");
/* Allocate a device nr */
if( alloc_chrdev_region(&my_device_nr, 0, 1, DRIVER_NAME) < 0) {
printk("Device Nr. could not be allocated!\n");
return -1;
}
printk("read_write - Device Nr. Major: %d, Minor: %d was registered!\n", my_device_nr >> 20, my_device_nr && 0xfffff);
/* Create device class */
if((my_class = class_create(DRIVER_CLASS)) == NULL) {
printk("Device class can not be created!\n");
goto ClassError;
}
/* create device file */
if(device_create(my_class, NULL, my_device_nr, NULL, DRIVER_NAME) == NULL) {
printk("Can not create device file!\n");
goto FileError;
}
/* Initialize device file */
cdev_init(&my_device, &fops);
/* Regisering device to kernel */
if(cdev_add(&my_device, my_device_nr, 1) == -1) {
printk("Registering of device to kernel failed!\n");
goto AddError;
}
/* GPIO 579 init */
if(gpio_request(579, "UART5_SW_SEL")) {
printk("Can not allocate GPIO 579\n");
goto AddError;
}
/* Set GPIO 579 direction */
if(gpio_direction_output(579, 0)) {
printk("Can not set GPIO 579 to output!\n");
goto Gpio579Error;
}
return 0;
Gpio579Error:
gpio_free(579);
AddError:
device_destroy(my_class, my_device_nr);
FileError:
class_destroy(my_class);
ClassError:
unregister_chrdev_region(my_device_nr, 1);
return -1;
}
/**
* @brief This function is called, when the module is removed from the kernel
*/
static void __exit ModuleExit(void) {
gpio_set_value(579, 0);
gpio_free(579);
cdev_del(&my_device);
device_destroy(my_class, my_device_nr);
class_destroy(my_class);
unregister_chrdev_region(my_device_nr, 1);
printk("Goodbye, Kernel\n");
}
module_init(ModuleInit);
module_exit(ModuleExit);
and tried controlling it using:
sudo insmod /etc/dsc/gpio_driver_modules/PU01.ko
sudo chmod 666 /dev/PU.01
printf "1" | sudo tee /dev/PU.01 > /dev/null
But no change in state was observed.
Kindly guide me on how to control this gpio’s.
Regards,
Vrushti