GPIO Driver and Driver Binding Computer Science & Engineering Department Arizona State University Tempe, AZ 85287 Dr. Yann-Hang Lee yhlee@asu.edu (480) 727-7507

Linux GPIO Driver A GPIO (General Purpose Input/Output) pin can be configured, set up its direction, and value if it is an output pin A SoC chip may have several GPIO components Multiple “gpio chips” A global number in the integrated GPIO namespace, i.e., 0, 1, 2,…,n sysfs interface to user space GPIO framework (gpiolib.c) IO expanders Quark GIP controller Quark legacy GPIO GPIO_SUS[5:0] GPIO[9:0] GPIO[….] chip drivers

Software Components for Galileo Gen2 GPIO /linux/driver/gpio/gpiolib.c the core program for gpio subsystem (framework) /linux/driver/mfd/intel_qrk_gip_core.c the dontroller for gip device on PCI bus /linux/driver/mfd/intel_qrk_gip_gpio.c gpio chip controller for gip_gpio /linux/driver/gpio/gpio-pca953x.c gpio chip controller for I2c expander pca9535 /linux/driver/i2c/busses/i2c-designware-core.c i2c bus controller for designware i2c controller /linux/driver/mfd/intel-qrk-gip_i2c.c a warpper to connect to i2c_designware_core.c /linux/driver/gpio/gpio-sch.c gpio chip controller for gpio port in Poulsbo SCH (system control hub) /linux/driver/platform/x86/quark/intel_qrk_board_data.c /linux/driver/platform/x86/quark/intel_qrk_plat_galileo_gen2.c

GPIO Chip Driver(1) A driver for each type of GPIO controller to provide methods to establish GPIO direction and to access GPIO values method to return the IRQ number associated to a given GPIO flag saying whether calls to its methods may sleep optional base number In intel_qrk_gip_gpio.c /* The base GPIO number under GPIOLIB framework */ #define INTEL_QRK_GIP_GPIO_BASE 8 /* The default number of South-Cluster GPIO on Quark. */ #define INTEL_QRK_GIP_NGPIO 8 In /include/asm-generic/gpio.h, “gpio_chip” is defined, including base: identifies the first GPIO number handled by this chip. ngpio: the number of GPIOs handled by this controller; the last GPIO handled is (base + ngpio - 1).

GPIO Chip Driver(2) gpio_chip includes function pointers to operate a gpio chip int (*get)(struct gpio_chip *chip, unsigned offset); void (*set)(struct gpio_chip *chip, unsigned offset, int value); int (*direction_input)(struct gpio_chip *chip, unsigned offset); ……. So, we can invoke operations at each pin of a gpio chip When a gpio chip driver is installed register itself to the bus it attached (e.g. PCI or i2c) The callback “probe” function is invoked to initialize struct gpio_chip, then to add gpio_chip /driver/mfd/intel_qrk_gip_gpio.c for gip_gpio /driver/gpio/gpio_pca953x.c for pca9535 chips

Binding of GPIOs to Pins Example: gpio 26 is bit 10 of the 1st PCAL9535 chip Each GPIO chip is represented by “struct gpio_chip” standard methods such as get, set, etc. “int base;” and “u16 ngpio;” When a gpio chip is added, use “base” and “ngpio” to determine “pin range” of the chip In intel_qrk_plt_galileo_gen2.c, define gpio_base When pca953x_setup_gpio() is invoked, ngpio is set, When pca953x_gpio_get_value() is called, an input argument: gpio=26 use container_of to find the chip (there are 3 PCAL9535) invoke pca953x_read_reg(chip, offset, &reg_val) to read input reg check the bit and return 1 or 0

IO Expenders in Galileo Gen 1 & 2 Gen 1 – CY8C9540A Gen 2 – 3 PCAL9535 Both connected to quark processor via I2C bus How does the Linux know board configuration Read BIOS DMI data to identify the board Then, register the board (platform_device_register() in linux/drivers/platform/x86/quark/intel_qrk_board_data.c) Once the board is registered, find the platform_driver for "GalileoGen2“, i.e., intel_qrk_plat_galileo_gen2.c In the platform (board) driver, 3 PCA9535 chips are defined and then probed. strlcpy(probed_i2c_pcal9555a_exp0.type, "pcal9555a", I2C_NAME_SIZE); client = i2c_new_probed_device(i2c_adap, &probed_i2c_pcal9555a_exp0, pcal9555a_exp0_i2c_addr, i2c_probe);

Binding of GPIO Adapter and Driver (1) Case 1: pca9535 instantiate the devices --- add 3 pca9535 devices as i2c clients in intel_qrk_plat_galileo_gen2.c (call to i2c_new_device()) initiate pca953x driver – static int __init pca953x_init(void) { return i2c_add_driver(&pca953x_driver); } then invoke i2c_register_driver and eventually pca953x_probe () if found matching devices In the probe function pca953x_setup_gpio device_pca953x_init gpiochip_add driver_register bus_add_driver driver_attach __driver_attach for each device on bus driver_probe_device if matches really_probe dev->bus->probe (i.e. i2c_device_probe) pca953x_probe

Binding of GPIO Adapter and Driver (2) Case 2: gip_gpio instantiate the devices --- pci device initialization initiate intel_qrk_gip_core driver – static int intel_qrk_gip_init(void) { return pci_register_driver(&intel_qrk_gip_driver); } then invoke pci_register_driver and eventually intel_qrk_gip_probe () and then pci_enable_device (for gip) and intel_qrk_gpio_probe In the probe function set up a gpio_chip struct gpiochip_add

GPIO Driver Operation in gpio core GPIO chip driver request to add “gpio_chip” to the platform gc->base = pdata->gpio_base; gc->ngpio = NGPIO; ret = gpiochip_add(&dev->gpio_chip); gpiolib.c exports methods to work on GPIO pins from GPIO # to find chip and to invoke the corresponding methods provided by the chip gpio_request_one(LED1, GPIOF_OUT_INIT_LOW, "led1"); gpio_desc desc1 = gpio_to_desc(LED1); gpio_set_value(desc1, data); sysfs gpio interfaces, such as gpiod_export, gpio_unexport, gpiod_set_value, gpio_direction_input

GPIO Interrupts (1) Interrupts from gip_gpio One interrupt source from gip controller GIP ISR is requested in intel_qrk_gip_probe() request_irq(pdev->irq, intel_qrk_gip_handler, IRQF_SHARED, "intel_qrk_gip", gip_drvdata); The handler calls i2c_dw_isr() and intel_qrk_gpio_isr() In intel_qrk_gpio_isr(), Check any pending interrupts (triggered) pin  gpio  irq  desc  desc->handle_irq(desc); irq_desc to keep track of interrupt request source and manage IRQ flow. A list of irq actions and an action may be called when the irq occurs gpio_chip: include irq_chip as the driver for interrupt controller (to manage hardware) To receive a gpio interrupt, an isr (action) must be registered for the irq with proper triggering flag.

GPIO Interrupts (2) In gpio sysfs interface, setting an edge type enables interrupt gpio_edge_store()  gpio_setup_irq()  request_any_context_irq(irq, gpio_sysfs_irq, irq_flags, "gpiolib", value_sd);  request_threaded_irq(irq, NULL, handler, flags, name, dev_id); (or request_irq(…))  an action is allocated  __setup_irq(irq, desc, action); The handler static irqreturn_t gpio_sysfs_irq(int irq, void *priv)  to wake up threads in polling list (of sysfs dir) A similar approach irq_no = gpio_to_irq(GPIO_X); // get the irq number from Linux gpio number request_irq(irq_no, isr_handler, TRIGGER_FLAG, “name", NULL); Use irq_set_irq_type() to reset flags

Linux Kernel Thread A way to implement background tasks inside the kernel static struct task_struct *tsk; static int thread_function(void *data) { int time_count = 0; do { printk(KERN_INFO "thread_function: %d times", ++time_count); msleep(1000); }while(!kthread_should_stop() && time_count<=30); return time_count; } static int hello_init(void) { tsk = kthread_run(thread_function, NULL, "mythread%d", 1); if (IS_ERR(tsk)) { …. } kthread_run()  kthread_create() + wake_up_process()  create a kthread_create_info wake_up kthreadd_task  kthreadd_task calls create_kthread()  kernel_thread()  do_fork ()

Platform Drivers platform_driver_register(&my_pdevice_of_driver ); The driver’s probe function invoked when a platform device is registered and it's device name matches the name specified on the device driver. Initializes and registers the device(s) static const struct platform_device_id my_pdevice_id_table[] = { { "basic-mmio-gpio", }, { "basic-mmio-gpio-be", }, {}, }; MODULE_DEVICE_TABLE(platform, my_pdevice_id_table); static struct platform_driver my_pdevice_driver = { .driver = { .name = "my_pdevice”, .owner = THIS_MODULE, .of_match_table = of_match_ptr(my_pdevice_of_match), }, ,id_table = my_pdevice_id_table, .probe = my_pdevice_probe, .remove = my_pdevice_remove, }; module_platform_driver(my_pdevice_of_driver);

Platform Devices platform_device Once a platform device is declared, name, used in driver binding, a list of resources Once a platform device is declared, init device structure after attached to platform_bus (a virtual bus) device_add(&pdev->dev)  bus_probe_device(dev)  device_attach(dev)  bus_for_each_drv(dev->bus, NULL, dev, __device_attach)  driver_match_device(drv, dev)  drv->bus->match(dev, drv)  given “platform_bus_type”,  platform_match(dev, drv)  driver_probe_device(drv, dev) struct platform_device { const char *name; u32 id; struct device dev; u32 num_resources; struct resource *resource; }; int platform_device_register(struct platform_device *pdev) { device_initialize(&pdev->dev); return platform_device_add(pdev); }

Platform_match if (pdev->driver_override) return !strcmp(pdev->driver_override, drv->name); if (of_driver_match_device(dev, drv)) /* an OF style match first */ return 1; if (acpi_driver_match_device(dev, drv)) /* ACPI style match */ if (pdrv->id_table) /* match against the id table */ return platform_match_id(pdrv->id_table, pdev) != NULL; /* fall-back to driver name match */ return (strcmp(pdev->name, drv->name) == 0); static const struct i2c_device_id pca953x_id[] = { { "pca9535", 16 | PCA953X_TYPE | PCA_INT, }, … { "pca9555", 16 | PCA953X_TYPE | PCA_INT, }, { "pcal9555a", 16 | PCAL953X_TYPE | PCA_INT, }, … }

I2C Devices and Drivers of Galileo Board

Platform Devices and Drivers of Galileo Board