zephyr/drivers/gpio/gpio_cc13xx_cc26xx.c

/*
 * Copyright (c) 2019 Brett Witherspoon
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/types.h>
#include <sys/__assert.h>
#include <device.h>
#include <errno.h>
#include <drivers/gpio.h>

#include <driverlib/gpio.h>
#include <driverlib/interrupt.h>
#include <driverlib/ioc.h>
#include <driverlib/prcm.h>

#include "gpio_utils.h"

struct gpio_cc13xx_cc26xx_data {
	sys_slist_t callbacks;
	u32_t pin_callback_enables;
};

static struct gpio_cc13xx_cc26xx_data gpio_cc13xx_cc26xx_data_0;

static int gpio_cc13xx_cc26xx_config(struct device *port, int access_op,
				     u32_t pin, int flags)
{
	u32_t config;

	if (access_op != GPIO_ACCESS_BY_PIN) {
		return -ENOTSUP;
	}

	__ASSERT_NO_MSG(pin < NUM_IO_MAX);

	config = IOC_CURRENT_2MA | IOC_STRENGTH_AUTO | IOC_SLEW_DISABLE |
		 IOC_NO_WAKE_UP;

	if (flags & GPIO_INT) {
		__ASSERT_NO_MSG((flags & GPIO_DIR_MASK) == GPIO_DIR_IN);

		config |= IOC_INT_ENABLE | IOC_INPUT_ENABLE;

		if (flags & GPIO_INT_EDGE) {
			if (flags & GPIO_INT_DOUBLE_EDGE) {
				config |= IOC_BOTH_EDGES;
			} else if (flags & GPIO_INT_ACTIVE_HIGH) {
				config |= IOC_RISING_EDGE;
			} else { /* GPIO_INT_ACTIVE_LOW */
				config |= IOC_FALLING_EDGE;
			}
		} else {
			return -ENOTSUP;
		}

		config |= (flags & GPIO_INT_DEBOUNCE) ? IOC_HYST_ENABLE :
							IOC_HYST_DISABLE;
	} else {
		config |= IOC_INT_DISABLE | IOC_NO_EDGE | IOC_HYST_DISABLE;
		config |= (flags & GPIO_DIR_MASK) == GPIO_DIR_IN ?
				  IOC_INPUT_ENABLE :
				  IOC_INPUT_DISABLE;
	}

	config |= (flags & GPIO_POL_MASK) == GPIO_POL_INV ? IOC_IOMODE_INV :
							    IOC_IOMODE_NORMAL;

	switch (flags & GPIO_PUD_MASK) {
	case GPIO_PUD_NORMAL:
		config |= IOC_NO_IOPULL;
		break;
	case GPIO_PUD_PULL_UP:
		config |= IOC_IOPULL_UP;
		break;
	case GPIO_PUD_PULL_DOWN:
		config |= IOC_IOPULL_DOWN;
		break;
	default:
		return -EINVAL;
	}

	IOCPortConfigureSet(pin, IOC_PORT_GPIO, config);

	if ((flags & GPIO_DIR_MASK) == GPIO_DIR_IN) {
		GPIO_setOutputEnableDio(pin, GPIO_OUTPUT_DISABLE);
	} else {
		GPIO_setOutputEnableDio(pin, GPIO_OUTPUT_ENABLE);
	}

	return 0;
}

static int gpio_cc13xx_cc26xx_write(struct device *port, int access_op,
				    u32_t pin, u32_t value)
{
	switch (access_op) {
	case GPIO_ACCESS_BY_PIN:
		__ASSERT_NO_MSG(pin < NUM_IO_MAX);
		if (value) {
			GPIO_setDio(pin);
		} else {
			GPIO_clearDio(pin);
		}
		break;
	case GPIO_ACCESS_BY_PORT:
		if (value) {
			GPIO_setMultiDio(GPIO_DIO_ALL_MASK);
		} else {
			GPIO_clearMultiDio(GPIO_DIO_ALL_MASK);
		}
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int gpio_cc13xx_cc26xx_read(struct device *port, int access_op,
				   u32_t pin, u32_t *value)
{
	__ASSERT_NO_MSG(value != NULL);

	switch (access_op) {
	case GPIO_ACCESS_BY_PIN:
		__ASSERT_NO_MSG(pin < NUM_IO_MAX);
		*value = GPIO_readDio(pin);
		break;
	case GPIO_ACCESS_BY_PORT:
		*value = GPIO_readMultiDio(GPIO_DIO_ALL_MASK);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int gpio_cc13xx_cc26xx_manage_callback(struct device *port,
					      struct gpio_callback *callback,
					      bool set)
{
	struct gpio_cc13xx_cc26xx_data *data = port->driver_data;

	return gpio_manage_callback(&data->callbacks, callback, set);
}

static int gpio_cc13xx_cc26xx_enable_callback(struct device *port,
					      int access_op, u32_t pin)
{
	struct gpio_cc13xx_cc26xx_data *data = port->driver_data;

	switch (access_op) {
	case GPIO_ACCESS_BY_PIN:
		__ASSERT_NO_MSG(pin < NUM_IO_MAX);
		data->pin_callback_enables |= (1 << pin);
		break;
	case GPIO_ACCESS_BY_PORT:
		data->pin_callback_enables = 0xFFFFFFFF;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int gpio_cc13xx_cc26xx_disable_callback(struct device *port,
					       int access_op, u32_t pin)
{
	struct gpio_cc13xx_cc26xx_data *data = port->driver_data;

	switch (access_op) {
	case GPIO_ACCESS_BY_PIN:
		__ASSERT_NO_MSG(pin < NUM_IO_MAX);
		data->pin_callback_enables &= ~(1 << pin);
		break;
	case GPIO_ACCESS_BY_PORT:
		data->pin_callback_enables = 0U;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static u32_t gpio_cc13xx_cc26xx_get_pending_int(struct device *dev)
{
	return GPIO_getEventMultiDio(GPIO_DIO_ALL_MASK);
}

DEVICE_DECLARE(gpio_cc13xx_cc26xx);

static void gpio_cc13xx_cc26xx_isr(void *arg)
{
	struct device *dev = arg;
	struct gpio_cc13xx_cc26xx_data *data = dev->driver_data;

	u32_t status = GPIO_getEventMultiDio(GPIO_DIO_ALL_MASK);
	u32_t enabled = status & data->pin_callback_enables;

	GPIO_clearEventMultiDio(status);

	gpio_fire_callbacks(&data->callbacks, dev, enabled);
}

static int gpio_cc13xx_cc26xx_init(struct device *dev)
{
	struct gpio_cc13xx_cc26xx_data *data = dev->driver_data;

	/* Enable peripheral power domain */
	PRCMPowerDomainOn(PRCM_DOMAIN_PERIPH);

	/* Enable GPIO peripheral */
	PRCMPeripheralRunEnable(PRCM_PERIPH_GPIO);

	/* Load PRCM settings */
	PRCMLoadSet();
	while (!PRCMLoadGet()) {
		continue;
	}

	/* Enable IRQ */
	IRQ_CONNECT(DT_INST_0_TI_CC13XX_CC26XX_GPIO_IRQ_0,
		    DT_INST_0_TI_CC13XX_CC26XX_GPIO_IRQ_0_PRIORITY,
		    gpio_cc13xx_cc26xx_isr, DEVICE_GET(gpio_cc13xx_cc26xx), 0);
	irq_enable(DT_INST_0_TI_CC13XX_CC26XX_GPIO_IRQ_0);

	/* Disable callbacks */
	data->pin_callback_enables = 0;

	/* Peripheral should not be accessed until power domain is on. */
	while (PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) !=
	       PRCM_DOMAIN_POWER_ON) {
		continue;
	}

	return 0;
}

static const struct gpio_driver_api gpio_cc13xx_cc26xx_driver_api = {
	.config = gpio_cc13xx_cc26xx_config,
	.write = gpio_cc13xx_cc26xx_write,
	.read = gpio_cc13xx_cc26xx_read,
	.manage_callback = gpio_cc13xx_cc26xx_manage_callback,
	.enable_callback = gpio_cc13xx_cc26xx_enable_callback,
	.disable_callback = gpio_cc13xx_cc26xx_disable_callback,
	.get_pending_int = gpio_cc13xx_cc26xx_get_pending_int
};

DEVICE_AND_API_INIT(gpio_cc13xx_cc26xx, DT_INST_0_TI_CC13XX_CC26XX_GPIO_LABEL,
		    gpio_cc13xx_cc26xx_init, &gpio_cc13xx_cc26xx_data_0, NULL,
		    POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
		    &gpio_cc13xx_cc26xx_driver_api);