diff --git a/apps/Makefile b/apps/Makefile index 2a0008e1b5..86e973441c 100644 --- a/apps/Makefile +++ b/apps/Makefile @@ -157,7 +157,7 @@ clean: @rm -f $(BIN) *~ .*.swp *.o $(call CLEAN) -distclean: clean +distclean: # clean @for dir in $(SUBDIRS) ; do \ $(MAKE) -C $$dir distclean TOPDIR="$(TOPDIR)" APPDIR="$(APPDIR)"; \ done diff --git a/nuttx/configs/stm3220g-eval/src/up_stmpe811.c b/nuttx/configs/stm3220g-eval/src/up_stmpe811.c index b07cc52bf2..a15e695067 100644 --- a/nuttx/configs/stm3220g-eval/src/up_stmpe811.c +++ b/nuttx/configs/stm3220g-eval/src/up_stmpe811.c @@ -136,7 +136,7 @@ struct stm32_stmpe811config_s /* Additional private definitions only known to this driver */ STMPE811_HANDLE handle; /* The STMPE811 driver handle */ - xcpt_t handler; /* The STMPE811 interrupt handler */ + xcpt_t handler; /* The STMPE811 interrupt handler */ }; /**************************************************************************** diff --git a/nuttx/configs/stm3240g-eval/src/up_stmpe811.c b/nuttx/configs/stm3240g-eval/src/up_stmpe811.c index a64d628259..257c886b90 100644 --- a/nuttx/configs/stm3240g-eval/src/up_stmpe811.c +++ b/nuttx/configs/stm3240g-eval/src/up_stmpe811.c @@ -136,7 +136,7 @@ struct stm32_stmpe811config_s /* Additional private definitions only known to this driver */ STMPE811_HANDLE handle; /* The STMPE811 driver handle */ - xcpt_t handler; /* The STMPE811 interrupt handler */ + xcpt_t handler; /* The STMPE811 interrupt handler */ }; /**************************************************************************** diff --git a/nuttx/drivers/input/stmpe811.h b/nuttx/drivers/input/stmpe811.h index 05917fc37a..f6d646527f 100644 --- a/nuttx/drivers/input/stmpe811.h +++ b/nuttx/drivers/input/stmpe811.h @@ -1,5 +1,5 @@ /******************************************************************************************** - * drivers/input/stmpe11.h + * drivers/input/stmpe811.h * * Copyright (C) 2012 Gregory Nutt. All rights reserved. * Author: Gregory Nutt @@ -37,8 +37,8 @@ * ********************************************************************************************/ -#ifndef __DRIVERS_INPUT_STMPE11_H -#define __DRIVERS_INPUT_STMPE11_H +#ifndef __DRIVERS_INPUT_STMPE811_H +#define __DRIVERS_INPUT_STMPE811_H /******************************************************************************************** * Included Files @@ -51,9 +51,9 @@ #include #include -#include +#include -#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE11) +#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE811) /******************************************************************************************** * Pre-Processor Definitions @@ -62,12 +62,12 @@ /* Reference counting is partially implemented, but not needed in the current design. */ -#undef CONFIG_STMPE11_REFCNT +#undef CONFIG_STMPE811_REFCNT /* No support for the SPI interface yet */ -#ifdef CONFIG_STMPE11_SPI -# error "Only the STMPE11 I2C interface is supported by this driver" +#ifdef CONFIG_STMPE811_SPI +# error "Only the STMPE811 I2C interface is supported by this driver" #endif /* Driver support ***************************************************************************/ @@ -78,32 +78,32 @@ #define DEV_FORMAT "/dev/input%d" #define DEV_NAMELEN 16 -/* STMPE11 Resources ************************************************************************/ -#ifndef CONFIG_STMPE11_TSC_DISABLE -# define SMTPE11_ADC_NPINS 4 /* Only pins 0-3 can be used for ADC */ -# define SMTPE11_GPIO_NPINS 4 /* Only pins 0-3 can be used as GPIOs */ +/* STMPE811 Resources ************************************************************************/ +#ifndef CONFIG_STMPE811_TSC_DISABLE +# define STMPE811_ADC_NPINS 4 /* Only pins 0-3 can be used for ADC */ +# define STMPE811_GPIO_NPINS 4 /* Only pins 0-3 can be used as GPIOs */ #else -# define SMTPE11_ADC_NPINS 8 /* All pins can be used for ADC */ -# define SMTPE11_GPIO_NPINS 8 /* All pins can be used as GPIOs */ +# define STMPE811_ADC_NPINS 8 /* All pins can be used for ADC */ +# define STMPE811_GPIO_NPINS 8 /* All pins can be used as GPIOs */ #endif /* Driver flags */ -#define STMPE11_FLAGS_TSC_INITIALIZED (1 << 0) /* 1: The TSC block has been initialized */ -#define STMPE11_FLAGS_GPIO_INITIALIZED (1 << 1) /* 1: The GIO block has been initialized */ -#define STMPE11_FLAGS_ADC_INITIALIZED (1 << 2) /* 1: The ADC block has been initialized */ -#define STMPE11_FLAGS_TS_INITIALIZED (1 << 3) /* 1: The TS block has been initialized */ +#define STMPE811_FLAGS_TSC_INITIALIZED (1 << 0) /* 1: The TSC block has been initialized */ +#define STMPE811_FLAGS_GPIO_INITIALIZED (1 << 1) /* 1: The GIO block has been initialized */ +#define STMPE811_FLAGS_ADC_INITIALIZED (1 << 2) /* 1: The ADC block has been initialized */ +#define STMPE811_FLAGS_TS_INITIALIZED (1 << 3) /* 1: The TS block has been initialized */ /* Timeout to detect missing pen up events */ -#define STMPE11_PENUP_TICKS ((100 + (MSEC_PER_TICK-1)) / MSEC_PER_TICK) +#define STMPE811_PENUP_TICKS ((100 + (MSEC_PER_TICK-1)) / MSEC_PER_TICK) /******************************************************************************************** * Public Types ********************************************************************************************/ /* This describes the state of one contact */ -enum stmpe11_contact_3 +enum stmpe811_contact_3 { CONTACT_NONE = 0, /* No contact */ CONTACT_DOWN, /* First contact */ @@ -111,47 +111,47 @@ enum stmpe11_contact_3 CONTACT_UP, /* Contact lost */ }; -/* This structure describes the results of one STMPE11 sample */ +/* This structure describes the results of one STMPE811 sample */ -struct stmpe11_sample_s +struct stmpe811_sample_s { uint8_t id; /* Sampled touch point ID */ - uint8_t contact; /* Contact state (see enum stmpe11_contact_e) */ + uint8_t contact; /* Contact state (see enum stmpe811_contact_e) */ bool valid; /* True: x,y,z contain valid, sampled data */ uint16_t x; /* Measured X position */ uint16_t y; /* Measured Y position */ uint8_t z; /* Measured Z index */ }; -/* This structure represents the state of the SMTPE11 driver */ +/* This structure represents the state of the STMPE811 driver */ -struct stmpe11_dev_s +struct stmpe811_dev_s { -#ifdef CONFIG_STMPE11_MULTIPLE - FAR struct stmpe11_dev_s *flink; /* Supports a singly linked list of drivers */ +#ifdef CONFIG_STMPE811_MULTIPLE + FAR struct stmpe811_dev_s *flink; /* Supports a singly linked list of drivers */ #endif /* Common fields */ - FAR struct stmpe11_config_s *config; /* Board configuration data */ + FAR struct stmpe811_config_s *config; /* Board configuration data */ sem_t exclsem; /* Manages exclusive access to this structure */ -#ifdef CONFIG_STMPE11_SPI +#ifdef CONFIG_STMPE811_SPI FAR struct spi_dev_s *spi; /* Saved SPI driver instance */ #else FAR struct i2c_dev_s *i2c; /* Saved I2C driver instance */ #endif - uint8_t inuse; /* SMTPE11 pins in use */ - uint8_t flags; /* See SMTPE11_FLAGS_* definitions */ + uint8_t inuse; /* STMPE811 pins in use */ + uint8_t flags; /* See STMPE811_FLAGS_* definitions */ struct work_s work; /* Supports the interrupt handling "bottom half" */ /* Fields that may be disabled to save size if touchscreen support is not used. */ -#ifndef CONFIG_STMPE11_TSC_DISABLE -#ifdef CONFIG_STMPE11_REFCNT +#ifndef CONFIG_STMPE811_TSC_DISABLE +#ifdef CONFIG_STMPE811_REFCNT uint8_t crefs; /* Number of times the device has been opened */ #endif - uint8_t nwaiters; /* Number of threads waiting for STMPE11 data */ + uint8_t nwaiters; /* Number of threads waiting for STMPE811 data */ uint8_t id; /* Current touch point ID */ uint8_t minor; /* Touchscreen minor device number */ volatile bool penchange; /* An unreported event is buffered */ @@ -162,7 +162,7 @@ struct stmpe11_dev_s struct work_s timeout; /* Supports tiemeout work */ WDOG_ID wdog; /* Timeout to detect missing pen down events */ - struct stmpe11_sample_s sample; /* Last sampled touch point data */ + struct stmpe811_sample_s sample; /* Last sampled touch point data */ /* The following is a list if poll structures of threads waiting for * driver events. The 'struct pollfd' reference for each open is also @@ -170,14 +170,14 @@ struct stmpe11_dev_s */ #ifndef CONFIG_DISABLE_POLL - struct pollfd *fds[CONFIG_STMPE11_NPOLLWAITERS]; + struct pollfd *fds[CONFIG_STMPE811_NPOLLWAITERS]; #endif #endif /* Fields that may be disabled to save size of GPIO support is not used */ -#if !defined(CONFIG_STMPE11_GPIO_DISABLE) && !defined(CONFIG_STMPE11_GPIOINT_DISABLE) - stmpe11_handler_t handlers[SMTPE11_GPIO_NPINS]; /* GPIO "interrupt handlers" */ +#if !defined(CONFIG_STMPE811_GPIO_DISABLE) && !defined(CONFIG_STMPE811_GPIOINT_DISABLE) + stmpe811_handler_t handlers[STMPE811_GPIO_NPINS]; /* GPIO "interrupt handlers" */ #endif }; @@ -186,37 +186,37 @@ struct stmpe11_dev_s ********************************************************************************************/ /******************************************************************************************** - * Name: stmpe11_getreg8 + * Name: stmpe811_getreg8 * * Description: - * Read from an 8-bit STMPE11 register + * Read from an 8-bit STMPE811 register * ********************************************************************************************/ -uint8_t stmpe11_getreg8(FAR struct stmpe11_dev_s *priv, uint8_t regaddr); +uint8_t stmpe811_getreg8(FAR struct stmpe811_dev_s *priv, uint8_t regaddr); /******************************************************************************************** - * Name: stmpe11_putreg8 + * Name: stmpe811_putreg8 * * Description: - * Write a value to an 8-bit STMPE11 register + * Write a value to an 8-bit STMPE811 register * ********************************************************************************************/ -void stmpe11_putreg8(FAR struct stmpe11_dev_s *priv, uint8_t regaddr, uint8_t regval); +void stmpe811_putreg8(FAR struct stmpe811_dev_s *priv, uint8_t regaddr, uint8_t regval); /******************************************************************************************** - * Name: stmpe11_getreg16 + * Name: stmpe811_getreg16 * * Description: * Read 16-bits of data from an STMPE-11 register * ********************************************************************************************/ -uint16_t stmpe11_getreg16(FAR struct stmpe11_dev_s *priv, uint8_t regaddr); +uint16_t stmpe811_getreg16(FAR struct stmpe811_dev_s *priv, uint8_t regaddr); /******************************************************************************************** - * Name: stmpe11_tscint + * Name: stmpe811_tscint * * Description: * Handle touchscreen interrupt events (this function actually executes in the context of @@ -224,12 +224,12 @@ uint16_t stmpe11_getreg16(FAR struct stmpe11_dev_s *priv, uint8_t regaddr); * ********************************************************************************************/ -#ifndef CONFIG_STMPE11_TSC_DISABLE -void stmpe11_tscworker(FAR struct stmpe11_dev_s *priv, uint8_t intsta) weak_function; +#ifndef CONFIG_STMPE811_TSC_DISABLE +void stmpe811_tscworker(FAR struct stmpe811_dev_s *priv, uint8_t intsta) weak_function; #endif /******************************************************************************************** - * Name: stmpe11_gpioworker + * Name: stmpe811_gpioworker * * Description: * Handle GPIO interrupt events (this function actually executes in the context of the @@ -237,9 +237,9 @@ void stmpe11_tscworker(FAR struct stmpe11_dev_s *priv, uint8_t intsta) weak_func * ********************************************************************************************/ -#if !defined(CONFIG_STMPE11_GPIO_DISABLE) && !defined(CONFIG_STMPE11_GPIOINT_DISABLE) -void stmpe11_gpioworker(FAR struct stmpe11_dev_s *priv) weak_function; +#if !defined(CONFIG_STMPE811_GPIO_DISABLE) && !defined(CONFIG_STMPE811_GPIOINT_DISABLE) +void stmpe811_gpioworker(FAR struct stmpe811_dev_s *priv) weak_function; #endif -#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE11 */ -#endif /* __DRIVERS_INPUT_STMPE11_H */ +#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE811 */ +#endif /* __DRIVERS_INPUT_STMPE811_H */ diff --git a/nuttx/drivers/input/stmpe811_adc.c b/nuttx/drivers/input/stmpe811_adc.c index 5b9d045c93..1ffe987e64 100644 --- a/nuttx/drivers/input/stmpe811_adc.c +++ b/nuttx/drivers/input/stmpe811_adc.c @@ -1,5 +1,5 @@ /**************************************************************************** - * drivers/input/stmpe11_adc.c + * drivers/input/stmpe811_adc.c * * Copyright (C) 2012 Gregory Nutt. All rights reserved. * Author: Gregory Nutt @@ -49,11 +49,11 @@ #include #include -#include +#include -#include "stmpe11.h" +#include "stmpe811.h" -#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE11) && !defined(CONFIG_STMPE11_ADC_DISABLE) +#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE811) && !defined(CONFIG_STMPE811_ADC_DISABLE) /**************************************************************************** * Private Types @@ -72,14 +72,14 @@ ****************************************************************************/ /**************************************************************************** - * Name: stmpe11_adcinitialize + * Name: stmpe811_adcinitialize * * Description: * Configure for ADC mode operation. Set overall ADC ADC timing that * applies to all pins. * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * * Returned Value: * Zero is returned on success. Otherwise, a negated errno value is @@ -87,9 +87,9 @@ * ****************************************************************************/ -int stmpe11_adcinitialize(STMPE11_HANDLE handle) +int stmpe811_adcinitialize(STMPE811_HANDLE handle) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; uint8_t regval; int ret; @@ -107,13 +107,13 @@ int stmpe11_adcinitialize(STMPE11_HANDLE handle) /* Enable Clocking for ADC */ - regval = stmpe11_getreg8(priv, STMPE11_SYS_CTRL2); + regval = stmpe811_getreg8(priv, STMPE811_SYS_CTRL2); regval &= ~SYS_CTRL2_ADC_OFF; - stmpe11_putreg8(priv, STMPE11_SYS_CTRL2, regval); + stmpe811_putreg8(priv, STMPE811_SYS_CTRL2, regval); /* Select Sample Time, bit number and ADC Reference */ - stmpe11_putreg8(priv, STMPE11_ADC_CTRL1, priv->config->ctrl1); + stmpe811_putreg8(priv, STMPE811_ADC_CTRL1, priv->config->ctrl1); /* Wait for 20 ms */ @@ -121,23 +121,23 @@ int stmpe11_adcinitialize(STMPE11_HANDLE handle) /* Select the ADC clock speed */ - stmpe11_putreg8(priv, STMPE11_ADC_CTRL2, priv->config->ctrl2); + stmpe811_putreg8(priv, STMPE811_ADC_CTRL2, priv->config->ctrl2); /* Mark ADC initialized */ - priv->flags |= STMPE11_FLAGS_ADC_INITIALIZED; + priv->flags |= STMPE811_FLAGS_ADC_INITIALIZED; sem_post(&priv->exclsem); return OK; } /**************************************************************************** - * Name: stmpe11_adcconfig + * Name: stmpe811_adcconfig * * Description: * Configure a pin for ADC input. * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * pin - The ADC pin number * * Returned Value: @@ -146,14 +146,14 @@ int stmpe11_adcinitialize(STMPE11_HANDLE handle) * ****************************************************************************/ -int stmpe11_adcconfig(STMPE11_HANDLE handle, int pin) +int stmpe811_adcconfig(STMPE811_HANDLE handle, int pin) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; uint8_t pinmask = GPIO_PIN(pin); uint8_t regval; int ret; - DEBUGASSERT(handle && (unsigned)pin < STMPE11_ADC_NPINS); + DEBUGASSERT(handle && (unsigned)pin < STMPE811_ADC_NPINS); /* Get exclusive access to the device structure */ @@ -179,9 +179,9 @@ int stmpe11_adcconfig(STMPE11_HANDLE handle, int pin) * ADC_CTRL1_REF_SEL bit). */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_AF); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_AF); regval &= ~pinmask; - stmpe11_putreg8(priv, STMPE11_GPIO_AF, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_AF, regval); /* Mark the pin as 'in use' */ @@ -191,13 +191,13 @@ int stmpe11_adcconfig(STMPE11_HANDLE handle, int pin) } /**************************************************************************** - * Name: stmpe11_adcread + * Name: stmpe811_adcread * * Description: * Read the converted analog input value from the select pin. * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * pin - The ADC pin number * * Returned Value: @@ -205,9 +205,9 @@ int stmpe11_adcconfig(STMPE11_HANDLE handle, int pin) * ****************************************************************************/ -uint16_t stmpe11_adcread(STMPE11_HANDLE handle, int pin) +uint16_t stmpe811_adcread(STMPE811_HANDLE handle, int pin) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; uint8_t pinmask = GPIO_PIN(pin); uint8_t regval; int i; @@ -229,7 +229,7 @@ uint16_t stmpe11_adcread(STMPE11_HANDLE handle, int pin) * ADC CAPT register. */ - stmpe11_putreg8(priv, STMPE11_ADC_CAPT, pinmask); + stmpe811_putreg8(priv, STMPE811_ADC_CAPT, pinmask); /* Wait for the conversion to complete. The ADC CAPT register reads '1' * if conversion is completed. Reads '0' if conversion is in progress. @@ -248,7 +248,7 @@ uint16_t stmpe11_adcread(STMPE11_HANDLE handle, int pin) /* Check if the conversion is complete */ - regval = stmpe11_getreg8(priv, STMPE11_ADC_CAPT); + regval = stmpe811_getreg8(priv, STMPE811_ADC_CAPT); if ((regval & pinmask) != 0) { break; @@ -259,8 +259,8 @@ uint16_t stmpe11_adcread(STMPE11_HANDLE handle, int pin) * from the channel register associated with the pin. */ - return stmpe11_getreg16(priv, STMPE11_ADC_DATACH(pin)); + return stmpe811_getreg16(priv, STMPE811_ADC_DATACH(pin)); } -#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE11 && !CONFIG_STMPE11_ADC_DISABLE */ +#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE811 && !CONFIG_STMPE811_ADC_DISABLE */ diff --git a/nuttx/drivers/input/stmpe811_base.c b/nuttx/drivers/input/stmpe811_base.c index 8e29006103..72af1575a9 100644 --- a/nuttx/drivers/input/stmpe811_base.c +++ b/nuttx/drivers/input/stmpe811_base.c @@ -1,5 +1,5 @@ /**************************************************************************** - * drivers/input/stmpe11_base.c + * drivers/input/stmpe811_base.c * * Copyright (C) 2012 Gregory Nutt. All rights reserved. * Author: Gregory Nutt @@ -48,11 +48,11 @@ #include #include -#include +#include -#include "stmpe11.h" +#include "stmpe811.h" -#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE11) +#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE811) /**************************************************************************** * Private Types @@ -62,17 +62,17 @@ * Private Data ****************************************************************************/ -/* If only a single STMPE11 device is supported, then the driver state +/* If only a single STMPE811 device is supported, then the driver state * structure may as well be pre-allocated. */ -#ifndef CONFIG_STMPE11_MULTIPLE -static struct stmpe11_dev_s g_stmpe11; +#ifndef CONFIG_STMPE811_MULTIPLE +static struct stmpe811_dev_s g_stmpe811; /* Otherwise, we will need to maintain allocated driver instances in a list */ #else -static struct stmpe11_dev_s *g_stmpe11list; +static struct stmpe811_dev_s *g_stmpe811list; #endif /**************************************************************************** @@ -80,56 +80,56 @@ static struct stmpe11_dev_s *g_stmpe11list; ****************************************************************************/ /**************************************************************************** - * Name: stmpe11_worker + * Name: stmpe811_worker * * Description: - * This is the "bottom half" of the STMPE11 interrupt handler + * This is the "bottom half" of the STMPE811 interrupt handler * ****************************************************************************/ -static void stmpe11_worker(FAR void *arg) +static void stmpe811_worker(FAR void *arg) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)arg; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)arg; uint8_t regval; DEBUGASSERT(priv && priv->config); /* Get the global interrupt status */ - regval = stmpe11_getreg8(priv, STMPE11_INT_STA); + regval = stmpe811_getreg8(priv, STMPE811_INT_STA); /* Check for a touchscreen interrupt */ -#ifndef CONFIG_STMPE11_TSC_DISABLE +#ifndef CONFIG_STMPE811_TSC_DISABLE if ((regval & (INT_TOUCH_DET|INT_FIFO_TH|INT_FIFO_OFLOW)) != 0) { /* Dispatch the touchscreen interrupt if it was brought into the link */ #ifdef CONFIG_HAVE_WEAKFUNCTIONS - if (stmpe11_tscworker) + if (stmpe811_tscworker) #endif { - stmpe11_tscworker(priv, regval); + stmpe811_tscworker(priv, regval); } - stmpe11_putreg8(priv, STMPE11_INT_STA, (INT_TOUCH_DET|INT_FIFO_TH|INT_FIFO_OFLOW)); + stmpe811_putreg8(priv, STMPE811_INT_STA, (INT_TOUCH_DET|INT_FIFO_TH|INT_FIFO_OFLOW)); regval &= ~(INT_TOUCH_DET|INT_FIFO_TH|INT_FIFO_OFLOW); } #endif -#if !defined(CONFIG_STMPE11_GPIO_DISABLE) && !defined(CONFIG_STMPE11_GPIOINT_DISABLE) +#if !defined(CONFIG_STMPE811_GPIO_DISABLE) && !defined(CONFIG_STMPE811_GPIOINT_DISABLE) if ((regval & INT_GPIO) != 0) { /* Dispatch the GPIO interrupt if it was brought into the link */ #ifdef CONFIG_HAVE_WEAKFUNCTIONS - if (stmpe11_gpioworker) + if (stmpe811_gpioworker) #endif { - stmpe11_gpioworker(priv); + stmpe811_gpioworker(priv); } - stmpe11_putreg8(priv, STMPE11_INT_STA, INT_GPIO); + stmpe811_putreg8(priv, STMPE811_INT_STA, INT_GPIO); regval &= ~INT_GPIO; } #endif @@ -138,34 +138,34 @@ static void stmpe11_worker(FAR void *arg) if (regval != 0) { - stmpe11_putreg8(priv, STMPE11_INT_STA, regval); + stmpe811_putreg8(priv, STMPE811_INT_STA, regval); } - /* Re-enable the STMPE11 GPIO interrupt */ + /* Re-enable the STMPE811 GPIO interrupt */ priv->config->enable(priv->config, true); } /**************************************************************************** - * Name: stmpe11_interrupt + * Name: stmpe811_interrupt * * Description: - * The STMPE11 interrupt handler + * The STMPE811 interrupt handler * ****************************************************************************/ -static int stmpe11_interrupt(int irq, FAR void *context) +static int stmpe811_interrupt(int irq, FAR void *context) { - FAR struct stmpe11_dev_s *priv; - FAR struct stmpe11_config_s *config; + FAR struct stmpe811_dev_s *priv; + FAR struct stmpe811_config_s *config; int ret; - /* Which STMPE11 device caused the interrupt? */ + /* Which STMPE811 device caused the interrupt? */ -#ifndef CONFIG_STMPE11_MULTIPLE - priv = &g_stmpe11; +#ifndef CONFIG_STMPE811_MULTIPLE + priv = &g_stmpe811; #else - for (priv = g_stmpe11list; + for (priv = g_stmpe811list; priv && priv->config->irq != irq; priv = priv->flink); @@ -190,12 +190,12 @@ static int stmpe11_interrupt(int irq, FAR void *context) if (work_available(&priv->work)) { - /* Yes.. Transfer processing to the worker thread. Since STMPE11 + /* Yes.. Transfer processing to the worker thread. Since STMPE811 * interrupts are disabled while the work is pending, no special * action should be required to protect the work queue. */ - ret = work_queue(&priv->work, stmpe11_worker, priv, 0); + ret = work_queue(&priv->work, stmpe811_worker, priv, 0); if (ret != 0) { illdbg("Failed to queue work: %d\n", ret); @@ -209,22 +209,22 @@ static int stmpe11_interrupt(int irq, FAR void *context) } /**************************************************************************** - * Name: stmpe11_checkid + * Name: stmpe811_checkid * * Description: - * Read and verify the STMPE11 chip ID + * Read and verify the STMPE811 chip ID * ****************************************************************************/ -static int stmpe11_checkid(FAR struct stmpe11_dev_s *priv) +static int stmpe811_checkid(FAR struct stmpe811_dev_s *priv) { uint16_t devid = 0; /* Read device ID */ - devid = stmpe11_getreg8(priv, STMPE11_CHIP_ID); + devid = stmpe811_getreg8(priv, STMPE811_CHIP_ID); devid = (uint32_t)(devid << 8); - devid |= (uint32_t)stmpe11_getreg8(priv, STMPE11_CHIP_ID+1); + devid |= (uint32_t)stmpe811_getreg8(priv, STMPE811_CHIP_ID+1); ivdbg("devid: %04x\n", devid); if (devid != (uint16_t)CHIP_ID) @@ -238,18 +238,18 @@ static int stmpe11_checkid(FAR struct stmpe11_dev_s *priv) } /**************************************************************************** - * Name: stmpe11_reset + * Name: stmpe811_reset * * Description: - * Reset the STMPE11 + * Reset the STMPE811 * ****************************************************************************/ -static void stmpe11_reset(FAR struct stmpe11_dev_s *priv) +static void stmpe811_reset(FAR struct stmpe811_dev_s *priv) { - /* Power Down the STMPE11 */ + /* Power Down the STMPE811 */ - stmpe11_putreg8(priv, STMPE11_SYS_CTRL1, SYS_CTRL1_SOFTRESET); + stmpe811_putreg8(priv, STMPE811_SYS_CTRL1, SYS_CTRL1_SOFTRESET); /* Wait a bit */ @@ -257,7 +257,7 @@ static void stmpe11_reset(FAR struct stmpe11_dev_s *priv) /* Then power on again. All registers will be in their reset state. */ - stmpe11_putreg8(priv, STMPE11_SYS_CTRL1, 0); + stmpe811_putreg8(priv, STMPE811_SYS_CTRL1, 0); } /**************************************************************************** @@ -265,10 +265,10 @@ static void stmpe11_reset(FAR struct stmpe11_dev_s *priv) ****************************************************************************/ /**************************************************************************** - * Name: stmpe11_instantiate + * Name: stmpe811_instantiate * * Description: - * Instantiate and configure the STMPE11 device driver to use the provided + * Instantiate and configure the STMPE811 device driver to use the provided * I2C or SPIdevice instance. * * Input Parameters: @@ -277,41 +277,41 @@ static void stmpe11_reset(FAR struct stmpe11_dev_s *priv) * * Returned Value: * A non-zero handle is returned on success. This handle may then be used - * to configure the STMPE11 driver as necessary. A NULL handle value is + * to configure the STMPE811 driver as necessary. A NULL handle value is * returned on failure. * ****************************************************************************/ -#ifdef CONFIG_STMPE11_SPI -STMPE11_HANDLE stmpe11_instantiate(FAR struct spi_dev_s *dev, - FAR struct stmpe11_config_s *config) +#ifdef CONFIG_STMPE811_SPI +STMPE811_HANDLE stmpe811_instantiate(FAR struct spi_dev_s *dev, + FAR struct stmpe811_config_s *config) #else -STMPE11_HANDLE stmpe11_instantiate(FAR struct i2c_dev_s *dev, - FAR struct stmpe11_config_s *config) +STMPE811_HANDLE stmpe811_instantiate(FAR struct i2c_dev_s *dev, + FAR struct stmpe811_config_s *config) #endif { - FAR struct stmpe11_dev_s *priv; + FAR struct stmpe811_dev_s *priv; uint8_t regval; int ret; /* Allocate the device state structure */ -#ifdef CONFIG_STMPE11_MULTIPLE - priv = (FAR struct stmpe11_dev_s *)kzalloc(sizeof(struct stmpe11_dev_s)); +#ifdef CONFIG_STMPE811_MULTIPLE + priv = (FAR struct stmpe811_dev_s *)kzalloc(sizeof(struct stmpe811_dev_s)); if (!priv) { return NULL; } - /* And save the device structure in the list of STMPE11 so that we can find it later */ + /* And save the device structure in the list of STMPE811 so that we can find it later */ - priv->flink = g_stmpe11list; - g_stmpe11list = priv; + priv->flink = g_stmpe811list; + g_stmpe811list = priv; #else - /* Use the one-and-only STMPE11 driver instance */ + /* Use the one-and-only STMPE811 driver instance */ - priv = &g_stmpe11; + priv = &g_stmpe811; #endif /* Initialize the device state structure */ @@ -319,7 +319,7 @@ STMPE11_HANDLE stmpe11_instantiate(FAR struct i2c_dev_s *dev, sem_init(&priv->exclsem, 0, 1); priv->config = config; -#ifdef CONFIG_STMPE11_SPI +#ifdef CONFIG_STMPE811_SPI priv->spi = dev; #else priv->i2c = dev; @@ -333,79 +333,79 @@ STMPE11_HANDLE stmpe11_instantiate(FAR struct i2c_dev_s *dev, I2C_SETFREQUENCY(dev, config->frequency); #endif - /* Read and verify the STMPE11 chip ID */ + /* Read and verify the STMPE811 chip ID */ - ret = stmpe11_checkid(priv); + ret = stmpe811_checkid(priv); if (ret < 0) { -#ifdef CONFIG_STMPE11_MULTIPLE +#ifdef CONFIG_STMPE811_MULTIPLE kfree(priv); #endif return NULL; } - /* Generate STMPE11 Software reset */ + /* Generate STMPE811 Software reset */ - stmpe11_reset(priv); + stmpe811_reset(priv); /* Configure the interrupt output pin to generate interrupts on high or low level. */ - regval = stmpe11_getreg8(priv, STMPE11_INT_CTRL); -#ifdef CONFIG_STMPE11_ACTIVELOW + regval = stmpe811_getreg8(priv, STMPE811_INT_CTRL); +#ifdef CONFIG_STMPE811_ACTIVELOW regval &= ~INT_CTRL_INT_POLARITY; /* Pin polarity: Active low / falling edge */ #else regval |= INT_CTRL_INT_POLARITY; /* Pin polarity: Active high / rising edge */ #endif -#ifdef CONFIG_STMPE11_EDGE +#ifdef CONFIG_STMPE811_EDGE regval |= INT_CTRL_INT_TYPE; /* Edge interrupt */ #else regval &= ~INT_CTRL_INT_TYPE; /* Level interrupt */ #endif - stmpe11_putreg8(priv, STMPE11_INT_CTRL, regval); + stmpe811_putreg8(priv, STMPE811_INT_CTRL, regval); - /* Attach the STMPE11 interrupt handler. */ + /* Attach the STMPE811 interrupt handler. */ - config->attach(config, stmpe11_interrupt); + config->attach(config, stmpe811_interrupt); /* Clear any pending interrupts */ - stmpe11_putreg8(priv, STMPE11_INT_STA, INT_ALL); + stmpe811_putreg8(priv, STMPE811_INT_STA, INT_ALL); config->clear(config); config->enable(config, true); /* Enable global interrupts */ - regval = stmpe11_getreg8(priv, STMPE11_INT_CTRL); + regval = stmpe811_getreg8(priv, STMPE811_INT_CTRL); regval |= INT_CTRL_GLOBAL_INT; - stmpe11_putreg8(priv, STMPE11_INT_CTRL, regval); + stmpe811_putreg8(priv, STMPE811_INT_CTRL, regval); /* Return our private data structure as an opaque handle */ - return (STMPE11_HANDLE)priv; + return (STMPE811_HANDLE)priv; } /**************************************************************************** - * Name: stmpe11_getreg8 + * Name: stmpe811_getreg8 * * Description: - * Read from an 8-bit STMPE11 register + * Read from an 8-bit STMPE811 register * ****************************************************************************/ -#ifdef CONFIG_STMPE11_I2C -uint8_t stmpe11_getreg8(FAR struct stmpe11_dev_s *priv, uint8_t regaddr) +#ifdef CONFIG_STMPE811_I2C +uint8_t stmpe811_getreg8(FAR struct stmpe811_dev_s *priv, uint8_t regaddr) { /* 8-bit data read sequence: * - * Start - I2C_Write_Address - STMPE11_Reg_Address - - * Repeated_Start - I2C_Read_Address - STMPE11_Read_Data - STOP + * Start - I2C_Write_Address - STMPE811_Reg_Address - + * Repeated_Start - I2C_Read_Address - STMPE811_Read_Data - STOP */ struct i2c_msg_s msg[2]; uint8_t regval; int ret; - /* Setup 8-bit STMPE11 address write message */ + /* Setup 8-bit STMPE811 address write message */ msg[0].addr = priv->config->address; /* 7-bit address */ msg[0].flags = 0; /* Write transaction, beginning with START */ @@ -413,7 +413,7 @@ uint8_t stmpe11_getreg8(FAR struct stmpe11_dev_s *priv, uint8_t regaddr) msg[0].length = 1; /* Send one byte following the address * (no STOP) */ - /* Set up the 8-bit STMPE11 data read message */ + /* Set up the 8-bit STMPE811 data read message */ msg[1].addr = priv->config->address; /* 7-bit address */ msg[1].flags = I2C_M_READ; /* Read transaction, beginning with Re-START */ @@ -430,7 +430,7 @@ uint8_t stmpe11_getreg8(FAR struct stmpe11_dev_s *priv, uint8_t regaddr) return 0; } -#ifdef CONFIG_STMPE11_REGDEBUG +#ifdef CONFIG_STMPE811_REGDEBUG dbg("%02x->%02x\n", regaddr, regval); #endif return regval; @@ -438,38 +438,38 @@ uint8_t stmpe11_getreg8(FAR struct stmpe11_dev_s *priv, uint8_t regaddr) #endif /**************************************************************************** - * Name: stmpe11_putreg8 + * Name: stmpe811_putreg8 * * Description: - * Write a value to an 8-bit STMPE11 register + * Write a value to an 8-bit STMPE811 register * ****************************************************************************/ -#ifdef CONFIG_STMPE11_I2C -void stmpe11_putreg8(FAR struct stmpe11_dev_s *priv, - uint8_t regaddr, uint8_t regval) +#ifdef CONFIG_STMPE811_I2C +void stmpe811_putreg8(FAR struct stmpe811_dev_s *priv, + uint8_t regaddr, uint8_t regval) { /* 8-bit data read sequence: * - * Start - I2C_Write_Address - STMPE11_Reg_Address - STMPE11_Write_Data - STOP + * Start - I2C_Write_Address - STMPE811_Reg_Address - STMPE811_Write_Data - STOP */ struct i2c_msg_s msg; uint8_t txbuffer[2]; int ret; -#ifdef CONFIG_STMPE11_REGDEBUG +#ifdef CONFIG_STMPE811_REGDEBUG dbg("%02x<-%02x\n", regaddr, regval); #endif - /* Setup to the data to be transferred. Two bytes: The STMPE11 register + /* Setup to the data to be transferred. Two bytes: The STMPE811 register * address followed by one byte of data. */ txbuffer[0] = regaddr; txbuffer[1] = regval; - /* Setup 8-bit STMPE11 address write message */ + /* Setup 8-bit STMPE811 address write message */ msg.addr = priv->config->address; /* 7-bit address */ msg.flags = 0; /* Write transaction, beginning with START */ @@ -488,21 +488,21 @@ void stmpe11_putreg8(FAR struct stmpe11_dev_s *priv, #endif /**************************************************************************** - * Name: stmpe11_getreg16 + * Name: stmpe811_getreg16 * * Description: * Read 16-bits of data from an STMPE-11 register * ****************************************************************************/ -#ifdef CONFIG_STMPE11_I2C -uint16_t stmpe11_getreg16(FAR struct stmpe11_dev_s *priv, uint8_t regaddr) +#ifdef CONFIG_STMPE811_I2C +uint16_t stmpe811_getreg16(FAR struct stmpe811_dev_s *priv, uint8_t regaddr) { /* 16-bit data read sequence: * - * Start - I2C_Write_Address - STMPE11_Reg_Address - - * Repeated_Start - I2C_Read_Address - STMPE11_Read_Data_1 - - * STMPE11_Read_Data_2 - STOP + * Start - I2C_Write_Address - STMPE811_Reg_Address - + * Repeated_Start - I2C_Read_Address - STMPE811_Read_Data_1 - + * STMPE811_Read_Data_2 - STOP */ @@ -510,7 +510,7 @@ uint16_t stmpe11_getreg16(FAR struct stmpe11_dev_s *priv, uint8_t regaddr) uint8_t rxbuffer[2]; int ret; - /* Setup 8-bit STMPE11 address write message */ + /* Setup 8-bit STMPE811 address write message */ msg[0].addr = priv->config->address; /* 7-bit address */ msg[0].flags = 0; /* Write transaction, beginning with START */ @@ -518,7 +518,7 @@ uint16_t stmpe11_getreg16(FAR struct stmpe11_dev_s *priv, uint8_t regaddr) msg[0].length = 1; /* Send one byte following the address * (no STOP) */ - /* Set up the 8-bit STMPE11 data read message */ + /* Set up the 8-bit STMPE811 data read message */ msg[1].addr = priv->config->address; /* 7-bit address */ msg[1].flags = I2C_M_READ; /* Read transaction, beginning with Re-START */ @@ -535,12 +535,12 @@ uint16_t stmpe11_getreg16(FAR struct stmpe11_dev_s *priv, uint8_t regaddr) return 0; } -#ifdef CONFIG_STMPE11_REGDEBUG +#ifdef CONFIG_STMPE811_REGDEBUG dbg("%02x->%02x%02x\n", regaddr, rxbuffer[0], rxbuffer[1]); #endif return (uint16_t)rxbuffer[0] << 8 | (uint16_t)rxbuffer[1]; } #endif -#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE11 */ +#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE811 */ diff --git a/nuttx/drivers/input/stmpe811_gpio.c b/nuttx/drivers/input/stmpe811_gpio.c index 82024b4d05..b545828d12 100644 --- a/nuttx/drivers/input/stmpe811_gpio.c +++ b/nuttx/drivers/input/stmpe811_gpio.c @@ -1,5 +1,5 @@ /**************************************************************************** - * drivers/input/stmpe11_gpio.c + * drivers/input/stmpe811_gpio.c * * Copyright (C) 2012 Gregory Nutt. All rights reserved. * Author: Gregory Nutt @@ -47,11 +47,11 @@ #include #include -#include +#include -#include "stmpe11.h" +#include "stmpe811.h" -#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE11) && !defined(CONFIG_STMPE11_GPIO_DISABLE) +#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE811) && !defined(CONFIG_STMPE811_GPIO_DISABLE) /**************************************************************************** * Private Types @@ -66,13 +66,13 @@ ****************************************************************************/ /**************************************************************************** - * Name: stmpe11_gpioinit + * Name: stmpe811_gpioinit * * Description: * Initialize the GPIO interrupt subsystem * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * * Returned Value: * Zero is returned on success. Otherwise, a negated errno value is @@ -80,31 +80,31 @@ * ****************************************************************************/ -static void stmpe11_gpioinit(FAR struct stmpe11_dev_s *priv) +static void stmpe811_gpioinit(FAR struct stmpe811_dev_s *priv) { uint8_t regval; - if ((priv->flags & STMPE11_FLAGS_GPIO_INITIALIZED) == 0) + if ((priv->flags & STMPE811_FLAGS_GPIO_INITIALIZED) == 0) { /* Enable Clocking for GPIO */ - regval = stmpe11_getreg8(priv, STMPE11_SYS_CTRL2); + regval = stmpe811_getreg8(priv, STMPE811_SYS_CTRL2); regval &= ~SYS_CTRL2_GPIO_OFF; - stmpe11_putreg8(priv, STMPE11_SYS_CTRL2, regval); + stmpe811_putreg8(priv, STMPE811_SYS_CTRL2, regval); /* Disable all GPIO interrupts */ - stmpe11_putreg8(priv, STMPE11_GPIO_EN, 0); + stmpe811_putreg8(priv, STMPE811_GPIO_EN, 0); /* Enable global GPIO interrupts */ -#ifndef CONFIG_STMPE11_GPIOINT_DISABLE - regval = stmpe11_getreg8(priv, STMPE11_INT_EN); +#ifndef CONFIG_STMPE811_GPIOINT_DISABLE + regval = stmpe811_getreg8(priv, STMPE811_INT_EN); regval |= INT_GPIO; - stmpe11_putreg8(priv, STMPE11_INT_EN, regval); + stmpe811_putreg8(priv, STMPE811_INT_EN, regval); #endif - priv->flags |= STMPE11_FLAGS_GPIO_INITIALIZED; + priv->flags |= STMPE811_FLAGS_GPIO_INITIALIZED; } } @@ -113,13 +113,13 @@ static void stmpe11_gpioinit(FAR struct stmpe11_dev_s *priv) ****************************************************************************/ /**************************************************************************** - * Name: stmpe11_gpioconfig + * Name: stmpe811_gpioconfig * * Description: - * Configure an STMPE11 GPIO pin + * Configure an STMPE811 GPIO pin * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * pinconfig - Bit-encoded pin configuration * * Returned Value: @@ -128,15 +128,15 @@ static void stmpe11_gpioinit(FAR struct stmpe11_dev_s *priv) * ****************************************************************************/ -int stmpe11_gpioconfig(STMPE11_HANDLE handle, uint8_t pinconfig) +int stmpe811_gpioconfig(STMPE811_HANDLE handle, uint8_t pinconfig) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; - int pin = (pinconfig & STMPE11_GPIO_PIN_MASK) >> STMPE11_GPIO_PIN_SHIFT; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; + int pin = (pinconfig & STMPE811_GPIO_PIN_MASK) >> STMPE811_GPIO_PIN_SHIFT; uint8_t pinmask = (1 << pin); uint8_t regval; int ret; - DEBUGASSERT(handle && (unsigned)pin < STMPE11_GPIO_NPINS); + DEBUGASSERT(handle && (unsigned)pin < STMPE811_GPIO_NPINS); /* Get exclusive access to the device structure */ @@ -159,41 +159,41 @@ int stmpe11_gpioconfig(STMPE11_HANDLE handle, uint8_t pinconfig) /* Make sure that the GPIO block has been initialized */ - stmpe11_gpioinit(priv); + stmpe811_gpioinit(priv); /* Set the alternate function bit for the pin, making it a GPIO */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_AF); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_AF); regval |= pinmask; - stmpe11_putreg8(priv, STMPE11_GPIO_AF, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_AF, regval); /* Is the pin an input or an output? */ - if ((pinconfig & STMPE11_GPIO_DIR) == STMPE11_GPIO_OUTPUT) + if ((pinconfig & STMPE811_GPIO_DIR) == STMPE811_GPIO_OUTPUT) { /* The pin is an output */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_DIR); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_DIR); regval &= ~pinmask; - stmpe11_putreg8(priv, STMPE11_GPIO_DIR, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_DIR, regval); /* Set its initial output value */ - stmpe11_gpiowrite(handle, pinconfig, - (pinconfig & STMPE11_GPIO_VALUE) != STMPE11_GPIO_ZERO); + stmpe811_gpiowrite(handle, pinconfig, + (pinconfig & STMPE811_GPIO_VALUE) != STMPE811_GPIO_ZERO); } else { /* It is an input */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_DIR); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_DIR); regval |= pinmask; - stmpe11_putreg8(priv, STMPE11_GPIO_DIR, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_DIR, regval); /* Set up the falling edge detection */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_FE); - if ((pinconfig & STMPE11_GPIO_FALLING) != 0) + regval = stmpe811_getreg8(priv, STMPE811_GPIO_FE); + if ((pinconfig & STMPE811_GPIO_FALLING) != 0) { regval |= pinmask; } @@ -201,12 +201,12 @@ int stmpe11_gpioconfig(STMPE11_HANDLE handle, uint8_t pinconfig) { regval &= pinmask; } - stmpe11_putreg8(priv, STMPE11_GPIO_FE, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_FE, regval); /* Set up the rising edge detection */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_RE); - if ((pinconfig & STMPE11_GPIO_FALLING) != 0) + regval = stmpe811_getreg8(priv, STMPE811_GPIO_RE); + if ((pinconfig & STMPE811_GPIO_FALLING) != 0) { regval |= pinmask; } @@ -214,13 +214,13 @@ int stmpe11_gpioconfig(STMPE11_HANDLE handle, uint8_t pinconfig) { regval &= pinmask; } - stmpe11_putreg8(priv, STMPE11_GPIO_RE, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_RE, regval); /* Disable interrupts for now */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_EN); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_EN); regval &= ~pinmask; - stmpe11_putreg8(priv, STMPE11_GPIO_EN, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_EN, regval); } /* Mark the pin as 'in use' */ @@ -231,13 +231,13 @@ int stmpe11_gpioconfig(STMPE11_HANDLE handle, uint8_t pinconfig) } /**************************************************************************** - * Name: stmpe11_gpiowrite + * Name: stmpe811_gpiowrite * * Description: * Set or clear the GPIO output * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * pinconfig - Bit-encoded pin configuration * value = true: write logic '1'; false: write logic '0; * @@ -246,13 +246,13 @@ int stmpe11_gpioconfig(STMPE11_HANDLE handle, uint8_t pinconfig) * ****************************************************************************/ -void stmpe11_gpiowrite(STMPE11_HANDLE handle, uint8_t pinconfig, bool value) +void stmpe811_gpiowrite(STMPE811_HANDLE handle, uint8_t pinconfig, bool value) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; - int pin = (pinconfig & STMPE11_GPIO_PIN_MASK) >> STMPE11_GPIO_PIN_SHIFT; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; + int pin = (pinconfig & STMPE811_GPIO_PIN_MASK) >> STMPE811_GPIO_PIN_SHIFT; int ret; - DEBUGASSERT(handle && (unsigned)pin < STMPE11_GPIO_NPINS); + DEBUGASSERT(handle && (unsigned)pin < STMPE811_GPIO_NPINS); /* Get exclusive access to the device structure */ @@ -269,26 +269,26 @@ void stmpe11_gpiowrite(STMPE11_HANDLE handle, uint8_t pinconfig, bool value) { /* Set the output valu(s)e by writing to the SET register */ - stmpe11_putreg8(priv, STMPE11_GPIO_SETPIN, (1 << pin)); + stmpe811_putreg8(priv, STMPE811_GPIO_SETPIN, (1 << pin)); } else { /* Clear the output value(s) by writing to the CLR register */ - stmpe11_putreg8(priv, STMPE11_GPIO_CLRPIN, (1 << pin)); + stmpe811_putreg8(priv, STMPE811_GPIO_CLRPIN, (1 << pin)); } sem_post(&priv->exclsem); } /**************************************************************************** - * Name: stmpe11_gpioread + * Name: stmpe811_gpioread * * Description: * Set or clear the GPIO output * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * pinconfig - Bit-encoded pin configuration * value - The location to return the state of the GPIO pin * @@ -298,14 +298,14 @@ void stmpe11_gpiowrite(STMPE11_HANDLE handle, uint8_t pinconfig, bool value) * ****************************************************************************/ -int stmpe11_gpioread(STMPE11_HANDLE handle, uint8_t pinconfig, bool *value) +int stmpe811_gpioread(STMPE811_HANDLE handle, uint8_t pinconfig, bool *value) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; - int pin = (pinconfig & STMPE11_GPIO_PIN_MASK) >> STMPE11_GPIO_PIN_SHIFT; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; + int pin = (pinconfig & STMPE811_GPIO_PIN_MASK) >> STMPE811_GPIO_PIN_SHIFT; uint8_t regval; int ret; - DEBUGASSERT(handle && (unsigned)pin < STMPE11_GPIO_NPINS); + DEBUGASSERT(handle && (unsigned)pin < STMPE811_GPIO_NPINS); /* Get exclusive access to the device structure */ @@ -317,14 +317,14 @@ int stmpe11_gpioread(STMPE11_HANDLE handle, uint8_t pinconfig, bool *value) return -errval; } - regval = stmpe11_getreg8(priv, STMPE11_GPIO_MPSTA); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_MPSTA); *value = ((regval & GPIO_PIN(pin)) != 0); sem_post(&priv->exclsem); return OK; } /*********************************************************************************** - * Name: stmpe11_gpioattach + * Name: stmpe811_gpioattach * * Description: * Attach to a GPIO interrupt input pin and enable interrupts on the pin. Using @@ -335,7 +335,7 @@ int stmpe11_gpioread(STMPE11_HANDLE handle, uint8_t pinconfig, bool *value) * context of the worker thread. * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * pinconfig - Bit-encoded pin configuration * handler - The handler that will be called when the interrupt occurs. * @@ -345,16 +345,16 @@ int stmpe11_gpioread(STMPE11_HANDLE handle, uint8_t pinconfig, bool *value) * ************************************************************************************/ -#ifndef CONFIG_STMPE11_GPIOINT_DISABLE -int stmpe11_gpioattach(STMPE11_HANDLE handle, uint8_t pinconfig, - stmpe11_handler_t handler) +#ifndef CONFIG_STMPE811_GPIOINT_DISABLE +int stmpe811_gpioattach(STMPE811_HANDLE handle, uint8_t pinconfig, + stmpe811_handler_t handler) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; - int pin = (pinconfig & STMPE11_GPIO_PIN_MASK) >> STMPE11_GPIO_PIN_SHIFT; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; + int pin = (pinconfig & STMPE811_GPIO_PIN_MASK) >> STMPE811_GPIO_PIN_SHIFT; uint8_t regval; int ret; - DEBUGASSERT(handle && (unsigned)pin < STMPE11_GPIO_NPINS); + DEBUGASSERT(handle && (unsigned)pin < STMPE811_GPIO_NPINS); /* Get exclusive access to the device structure */ @@ -368,7 +368,7 @@ int stmpe11_gpioattach(STMPE11_HANDLE handle, uint8_t pinconfig, /* Make sure that the GPIO interrupt system has been gpioinitialized */ - stmpe11_gpioinit(priv); + stmpe811_gpioinit(priv); /* Set/clear the handler */ @@ -376,7 +376,7 @@ int stmpe11_gpioattach(STMPE11_HANDLE handle, uint8_t pinconfig, /* If an handler has provided, then we are enabling interrupts */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_EN); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_EN); if (handler) { /* Enable interrupts for this GPIO */ @@ -389,7 +389,7 @@ int stmpe11_gpioattach(STMPE11_HANDLE handle, uint8_t pinconfig, regval &= ~GPIO_PIN(pin); } - stmpe11_putreg8(priv, STMPE11_GPIO_EN, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_EN, regval); sem_post(&priv->exclsem); return OK; @@ -397,7 +397,7 @@ int stmpe11_gpioattach(STMPE11_HANDLE handle, uint8_t pinconfig, #endif /**************************************************************************** - * Name: stmpe11_gpioworker + * Name: stmpe811_gpioworker * * Description: * Handle GPIO interrupt events (this function actually executes in the @@ -405,8 +405,8 @@ int stmpe11_gpioattach(STMPE11_HANDLE handle, uint8_t pinconfig, * ****************************************************************************/ -#ifndef CONFIG_STMPE11_GPIOINT_DISABLE -void stmpe11_gpioworker(FAR struct stmpe11_dev_s *priv) +#ifndef CONFIG_STMPE811_GPIOINT_DISABLE +void stmpe811_gpioworker(FAR struct stmpe811_dev_s *priv) { uint8_t regval; uint8_t pinmask; @@ -414,11 +414,11 @@ void stmpe11_gpioworker(FAR struct stmpe11_dev_s *priv) /* Get the set of pending GPIO interrupts */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_INTSTA); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_INTSTA); /* Look at each pin */ - for (pin = 0; pin < SMTPE11_GPIO_NPINS; pin++) + for (pin = 0; pin < STMPE811_GPIO_NPINS; pin++) { pinmask = GPIO_INT(pin); if ((regval & pinmask) != 0) @@ -444,11 +444,11 @@ void stmpe11_gpioworker(FAR struct stmpe11_dev_s *priv) * pin position in the status register. */ - stmpe11_putreg8(priv, STMPE11_GPIO_INTSTA, pinmask); + stmpe811_putreg8(priv, STMPE811_GPIO_INTSTA, pinmask); } } } #endif -#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE11 && !CONFIG_STMPE11_GPIO_DISABLE */ +#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE811 && !CONFIG_STMPE811_GPIO_DISABLE */ diff --git a/nuttx/drivers/input/stmpe811_temp.c b/nuttx/drivers/input/stmpe811_temp.c index b3eb8f6c58..0fefd20699 100644 --- a/nuttx/drivers/input/stmpe811_temp.c +++ b/nuttx/drivers/input/stmpe811_temp.c @@ -1,5 +1,5 @@ /**************************************************************************** - * drivers/input/stmpe11_temp.c + * drivers/input/stmpe811_temp.c * * Copyright (C) 2012 Gregory Nutt. All rights reserved. * Author: Gregory Nutt @@ -47,11 +47,11 @@ #include #include -#include +#include -#include "stmpe11.h" +#include "stmpe811.h" -#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE11) && !defined(CONFIG_STMPE11_TEMP_DISABLE) +#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE811) && !defined(CONFIG_STMPE811_TEMP_DISABLE) /**************************************************************************** * Private Types @@ -70,13 +70,13 @@ ****************************************************************************/ /**************************************************************************** - * Name: stmpe11_tempinitialize + * Name: stmpe811_tempinitialize * * Description: * Configure the temperature sensor. * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * * Returned Value: * Zero is returned on success. Otherwise, a negated errno value is @@ -84,36 +84,36 @@ * ****************************************************************************/ -int stmpe11_tempinitialize(STMPE11_HANDLE handle) +int stmpe811_tempinitialize(STMPE811_HANDLE handle) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; uint8_t regval; /* Enable clocking for ADC and the temperature sensor */ - regval = stmpe11_getreg8(priv, STMPE11_SYS_CTRL2); + regval = stmpe811_getreg8(priv, STMPE811_SYS_CTRL2); regval &= ~(SYS_CTRL2_TS_OFF | SYS_CTRL2_ADC_OFF); - stmpe11_putreg8(priv, STMPE11_SYS_CTRL2, regval); + stmpe811_putreg8(priv, STMPE811_SYS_CTRL2, regval); /* Enable the temperature sensor */ - stmpe11_putreg8(priv, STMPE11_TEMP_CTRL, TEMP_CTRL_ENABLE); + stmpe811_putreg8(priv, STMPE811_TEMP_CTRL, TEMP_CTRL_ENABLE); /* Aquire data enable */ - stmpe11_putreg8(priv, STMPE11_TEMP_CTRL, (TEMP_CTRL_ACQ|TEMP_CTRL_ENABLE)); + stmpe811_putreg8(priv, STMPE811_TEMP_CTRL, (TEMP_CTRL_ACQ|TEMP_CTRL_ENABLE)); return OK; } /**************************************************************************** - * Name: stmpe11_tempread + * Name: stmpe811_tempread * * Description: * Configure the temperature sensor. * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * * Returned Value: * Zero is returned on success. Otherwise, a negated errno value is @@ -121,21 +121,21 @@ int stmpe11_tempinitialize(STMPE11_HANDLE handle) * ****************************************************************************/ -uint16_t stmpe11_tempread(STMPE11_HANDLE handle) +uint16_t stmpe811_tempread(STMPE811_HANDLE handle) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; uint32_t temp = 0; uint8_t temp1; uint8_t temp2; /* Acquire data enable */ - stmpe11_putreg8(priv, STMPE11_TEMP_CTRL, (TEMP_CTRL_ACQ|TEMP_CTRL_ENABLE)); + stmpe811_putreg8(priv, STMPE811_TEMP_CTRL, (TEMP_CTRL_ACQ|TEMP_CTRL_ENABLE)); /* Read the temperature */ - temp1 = stmpe11_getreg8(priv, STMPE11_SYS_CTRL2); - temp2 = stmpe11_getreg8(priv, STMPE11_SYS_CTRL2+1); + temp1 = stmpe811_getreg8(priv, STMPE811_SYS_CTRL2); + temp2 = stmpe811_getreg8(priv, STMPE811_SYS_CTRL2+1); /* Scale the temperature (where Vio is assumed to be .33) */ @@ -147,7 +147,7 @@ uint16_t stmpe11_tempread(STMPE11_HANDLE handle) } /**************************************************************************** - * Name: stmpe11_tempinterrupt + * Name: stmpe811_tempinterrupt * * Description: * Configure the temperature sensor to sample the temperature periodically. @@ -155,7 +155,7 @@ uint16_t stmpe11_tempread(STMPE11_HANDLE handle) * to the client using the provide callback function pointer. * * Input Parameters: - * handle - The handle previously returned by stmpe11_instantiate + * handle - The handle previously returned by stmpe811_instantiate * threshold - The threshold temperature value * direction - True: Generate an interrupt if the temperate exceeds the * threshold value; False: Generate an interrupt if the @@ -170,5 +170,5 @@ uint16_t stmpe11_tempread(STMPE11_HANDLE handle) ****************************************************************************/ /* Not implemented */ -#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE11 && !CONFIG_STMPE11_TEMP_DISABLE */ +#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE811 && !CONFIG_STMPE811_TEMP_DISABLE */ diff --git a/nuttx/drivers/input/stmpe811_tsc.c b/nuttx/drivers/input/stmpe811_tsc.c index 03ede7302c..e2ab2827d5 100644 --- a/nuttx/drivers/input/stmpe811_tsc.c +++ b/nuttx/drivers/input/stmpe811_tsc.c @@ -1,5 +1,5 @@ /**************************************************************************** - * drivers/input/stmpe11_tsc.c + * drivers/input/stmpe811_tsc.c * * Copyright (C) 2012 Gregory Nutt. All rights reserved. * Author: Gregory Nutt @@ -65,11 +65,11 @@ #include #include -#include +#include -#include "stmpe11.h" +#include "stmpe811.h" -#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE11) && !defined(CONFIG_STMPE11_TSC_DISABLE) +#if defined(CONFIG_INPUT) && defined(CONFIG_INPUT_STMPE811) && !defined(CONFIG_STMPE811_TSC_DISABLE) /**************************************************************************** * Pre-processor Definitions @@ -110,28 +110,28 @@ ****************************************************************************/ /* Internal logic */ -static void stmpe11_notify(FAR struct stmpe11_dev_s *priv); -static int stmpe11_sample(FAR struct stmpe11_dev_s *priv, - FAR struct stmpe11_sample_s *sample); -static inline int stmpe11_waitsample(FAR struct stmpe11_dev_s *priv, - FAR struct stmpe11_sample_s *sample); +static void stmpe811_notify(FAR struct stmpe811_dev_s *priv); +static int stmpe811_sample(FAR struct stmpe811_dev_s *priv, + FAR struct stmpe811_sample_s *sample); +static inline int stmpe811_waitsample(FAR struct stmpe811_dev_s *priv, + FAR struct stmpe811_sample_s *sample); /* Character driver methods */ -static int stmpe11_open(FAR struct file *filep); -static int stmpe11_close(FAR struct file *filep); -static ssize_t stmpe11_read(FAR struct file *filep, FAR char *buffer, +static int stmpe811_open(FAR struct file *filep); +static int stmpe811_close(FAR struct file *filep); +static ssize_t stmpe811_read(FAR struct file *filep, FAR char *buffer, size_t len); -static int stmpe11_ioctl(FAR struct file *filep, int cmd, +static int stmpe811_ioctl(FAR struct file *filep, int cmd, unsigned long arg); #ifndef CONFIG_DISABLE_POLL -static int stmpe11_poll(FAR struct file *filep, struct pollfd *fds, +static int stmpe811_poll(FAR struct file *filep, struct pollfd *fds, bool setup); #endif /* Initialization logic */ -static inline void stmpe11_tscinitialize(FAR struct stmpe11_dev_s *priv); +static inline void stmpe811_tscinitialize(FAR struct stmpe811_dev_s *priv); /**************************************************************************** * Private Data @@ -139,16 +139,16 @@ static inline void stmpe11_tscinitialize(FAR struct stmpe11_dev_s *priv); /* This the the vtable that supports the character driver interface */ -static const struct file_operations g_stmpe11fops = +static const struct file_operations g_stmpe811fops = { - stmpe11_open, /* open */ - stmpe11_close, /* close */ - stmpe11_read, /* read */ + stmpe811_open, /* open */ + stmpe811_close, /* close */ + stmpe811_read, /* read */ 0, /* write */ 0, /* seek */ - stmpe11_ioctl /* ioctl */ + stmpe811_ioctl /* ioctl */ #ifndef CONFIG_DISABLE_POLL - , stmpe11_poll /* poll */ + , stmpe811_poll /* poll */ #endif }; @@ -156,7 +156,7 @@ static const struct file_operations g_stmpe11fops = * Private Functions ****************************************************************************/ /**************************************************************************** - * Name: stmpe11_notify + * Name: stmpe811_notify * * Description: * Notify any threads waiting on touchscreen data that data is now @@ -164,7 +164,7 @@ static const struct file_operations g_stmpe11fops = * ****************************************************************************/ -static void stmpe11_notify(FAR struct stmpe11_dev_s *priv) +static void stmpe811_notify(FAR struct stmpe811_dev_s *priv) { #ifndef CONFIG_DISABLE_POLL int i; @@ -176,21 +176,21 @@ static void stmpe11_notify(FAR struct stmpe11_dev_s *priv) if (priv->nwaiters > 0) { - /* After posting this semaphore, we need to exit because the STMPE11 + /* After posting this semaphore, we need to exit because the STMPE811 * is no longer available. */ sem_post(&priv->waitsem); } - /* If there are threads waiting on poll() for STMPE11 data to become available, + /* If there are threads waiting on poll() for STMPE811 data to become available, * then wake them up now. NOTE: we wake up all waiting threads because we * do not know that they are going to do. If they all try to read the data, * then some make end up blocking after all. */ #ifndef CONFIG_DISABLE_POLL - for (i = 0; i < CONFIG_STMPE11_NPOLLWAITERS; i++) + for (i = 0; i < CONFIG_STMPE811_NPOLLWAITERS; i++) { struct pollfd *fds = priv->fds[i]; if (fds) @@ -204,11 +204,11 @@ static void stmpe11_notify(FAR struct stmpe11_dev_s *priv) } /**************************************************************************** - * Name: stmpe11_sample + * Name: stmpe811_sample * * Description: * Check if touchscreen sample data is available now and, if so, return - * the sample data. This is part of the stmpe11_read logic. + * the sample data. This is part of the stmpe811_read logic. * * Assumption: * Pre-emption is disable to prevent the worker thread from running. @@ -216,12 +216,12 @@ static void stmpe11_notify(FAR struct stmpe11_dev_s *priv) * ****************************************************************************/ -static int stmpe11_sample(FAR struct stmpe11_dev_s *priv, - FAR struct stmpe11_sample_s *sample) +static int stmpe811_sample(FAR struct stmpe811_dev_s *priv, + FAR struct stmpe811_sample_s *sample) { int ret = -EAGAIN; - /* Is there new STMPE11 sample data available? */ + /* Is there new STMPE811 sample data available? */ if (priv->penchange) { @@ -229,7 +229,7 @@ static int stmpe11_sample(FAR struct stmpe11_dev_s *priv, * sampled data. */ - memcpy(sample, &priv->sample, sizeof(struct stmpe11_sample_s)); + memcpy(sample, &priv->sample, sizeof(struct stmpe811_sample_s)); /* Now manage state transitions */ @@ -264,16 +264,16 @@ static int stmpe11_sample(FAR struct stmpe11_dev_s *priv, } /**************************************************************************** - * Name: stmpe11_waitsample + * Name: stmpe811_waitsample * * Description: * Wait for a sample to become available (this is really part of the - * stmpe11_read logic). + * stmpe811_read logic). * ****************************************************************************/ -static inline int stmpe11_waitsample(FAR struct stmpe11_dev_s *priv, - FAR struct stmpe11_sample_s *sample) +static inline int stmpe811_waitsample(FAR struct stmpe811_dev_s *priv, + FAR struct stmpe811_sample_s *sample) { int ret; @@ -294,9 +294,9 @@ static inline int stmpe11_waitsample(FAR struct stmpe11_dev_s *priv, * that is posted when new sample data is availble. */ - while (stmpe11_sample(priv, sample) < 0) + while (stmpe811_sample(priv, sample) < 0) { - /* Wait for a change in the STMPE11 state */ + /* Wait for a change in the STMPE811 state */ priv->nwaiters++; ret = sem_wait(&priv->waitsem); @@ -333,7 +333,7 @@ static inline int stmpe11_waitsample(FAR struct stmpe11_dev_s *priv, errout: /* Restore pre-emption. We might get suspended here but that is okay * because we already have our sample. Note: this means that if there - * were two threads reading from the STMPE11 for some reason, the data + * were two threads reading from the STMPE811 for some reason, the data * might be read out of order. */ @@ -342,18 +342,18 @@ errout: } /**************************************************************************** - * Name: stmpe11_open + * Name: stmpe811_open * * Description: * Standard character driver open method. * ****************************************************************************/ -static int stmpe11_open(FAR struct file *filep) +static int stmpe811_open(FAR struct file *filep) { -#ifdef CONFIG_STMPE11_REFCNT +#ifdef CONFIG_STMPE811_REFCNT FAR struct inode *inode; - FAR struct stmpe11_dev_s *priv; + FAR struct stmpe811_dev_s *priv; uint8_t tmp; int ret; @@ -361,7 +361,7 @@ static int stmpe11_open(FAR struct file *filep) inode = filep->f_inode; DEBUGASSERT(inode && inode->i_private); - priv = (FAR struct stmpe11_dev_s *)inode->i_private; + priv = (FAR struct stmpe811_dev_s *)inode->i_private; /* Get exclusive access to the driver data structure */ @@ -402,25 +402,25 @@ errout_with_sem: } /**************************************************************************** - * Name: stmpe11_close + * Name: stmpe811_close * * Description: * Standard character driver close method. * ****************************************************************************/ -static int stmpe11_close(FAR struct file *filep) +static int stmpe811_close(FAR struct file *filep) { -#ifdef CONFIG_STMPE11_REFCNT +#ifdef CONFIG_STMPE811_REFCNT FAR struct inode *inode; - FAR struct stmpe11_dev_s *priv; + FAR struct stmpe811_dev_s *priv; int ret; DEBUGASSERT(filep); inode = filep->f_inode; DEBUGASSERT(inode && inode->i_private); - priv = (FAR struct stmpe11_dev_s *)inode->i_private; + priv = (FAR struct stmpe811_dev_s *)inode->i_private; /* Get exclusive access to the driver data structure */ @@ -449,19 +449,19 @@ static int stmpe11_close(FAR struct file *filep) } /**************************************************************************** - * Name: stmpe11_read + * Name: stmpe811_read * * Description: * Standard character driver read method. * ****************************************************************************/ -static ssize_t stmpe11_read(FAR struct file *filep, FAR char *buffer, size_t len) +static ssize_t stmpe811_read(FAR struct file *filep, FAR char *buffer, size_t len) { FAR struct inode *inode; - FAR struct stmpe11_dev_s *priv; + FAR struct stmpe811_dev_s *priv; FAR struct touch_sample_s *report; - struct stmpe11_sample_s sample; + struct stmpe811_sample_s sample; int ret; ivdbg("len=%d\n", len); @@ -469,7 +469,7 @@ static ssize_t stmpe11_read(FAR struct file *filep, FAR char *buffer, size_t len inode = filep->f_inode; DEBUGASSERT(inode && inode->i_private); - priv = (FAR struct stmpe11_dev_s *)inode->i_private; + priv = (FAR struct stmpe811_dev_s *)inode->i_private; /* Verify that the caller has provided a buffer large enough to receive * the touch data. @@ -497,7 +497,7 @@ static ssize_t stmpe11_read(FAR struct file *filep, FAR char *buffer, size_t len /* Try to read sample data. */ - ret = stmpe11_sample(priv, &sample); + ret = stmpe811_sample(priv, &sample); if (ret < 0) { /* Sample data is not available now. We would ave to wait to get @@ -513,7 +513,7 @@ static ssize_t stmpe11_read(FAR struct file *filep, FAR char *buffer, size_t len /* Wait for sample data */ - ret = stmpe11_waitsample(priv, &sample); + ret = stmpe811_waitsample(priv, &sample); if (ret < 0) { /* We might have been awakened by a signal */ @@ -522,7 +522,7 @@ static ssize_t stmpe11_read(FAR struct file *filep, FAR char *buffer, size_t len } } - /* In any event, we now have sampled STMPE11 data that we can report + /* In any event, we now have sampled STMPE811 data that we can report * to the caller. */ @@ -576,25 +576,25 @@ errout: } /**************************************************************************** - * Name: stmpe11_ioctl + * Name: stmpe811_ioctl * * Description: * Standard character driver ioctl method. * ****************************************************************************/ -static int stmpe11_ioctl(FAR struct file *filep, int cmd, unsigned long arg) +static int stmpe811_ioctl(FAR struct file *filep, int cmd, unsigned long arg) { - FAR struct inode *inode; - FAR struct stmpe11_dev_s *priv; - int ret; + FAR struct inode *inode; + FAR struct stmpe811_dev_s *priv; + int ret; ivdbg("cmd: %d arg: %ld\n", cmd, arg); DEBUGASSERT(filep); inode = filep->f_inode; DEBUGASSERT(inode && inode->i_private); - priv = (FAR struct stmpe11_dev_s *)inode->i_private; + priv = (FAR struct stmpe811_dev_s *)inode->i_private; /* Get exclusive access to the driver data structure */ @@ -637,7 +637,7 @@ static int stmpe11_ioctl(FAR struct file *filep, int cmd, unsigned long arg) } /**************************************************************************** - * Name: stmpe11_poll + * Name: stmpe811_poll * * Description: * Standard character driver poll method. @@ -645,20 +645,20 @@ static int stmpe11_ioctl(FAR struct file *filep, int cmd, unsigned long arg) ****************************************************************************/ #ifndef CONFIG_DISABLE_POLL -static int stmpe11_poll(FAR struct file *filep, FAR struct pollfd *fds, - bool setup) +static int stmpe811_poll(FAR struct file *filep, FAR struct pollfd *fds, + bool setup) { - FAR struct inode *inode; - FAR struct stmpe11_dev_s *priv; - int ret; - int i; + FAR struct inode *inode; + FAR struct stmpe811_dev_s *priv; + int ret; + int i; ivdbg("setup: %d\n", (int)setup); DEBUGASSERT(filep && fds); inode = filep->f_inode; DEBUGASSERT(inode && inode->i_private); - priv = (FAR struct stmpe11_dev_s *)inode->i_private; + priv = (FAR struct stmpe811_dev_s *)inode->i_private; /* Are we setting up the poll? Or tearing it down? */ @@ -686,7 +686,7 @@ static int stmpe11_poll(FAR struct file *filep, FAR struct pollfd *fds, * slot for the poll structure reference */ - for (i = 0; i < CONFIG_STMPE11_NPOLLWAITERS; i++) + for (i = 0; i < CONFIG_STMPE811_NPOLLWAITERS; i++) { /* Find an available slot */ @@ -700,7 +700,7 @@ static int stmpe11_poll(FAR struct file *filep, FAR struct pollfd *fds, } } - if (i >= CONFIG_STMPE11_NPOLLWAITERS) + if (i >= CONFIG_STMPE811_NPOLLWAITERS) { idbg("ERROR: No availabled slot found: %d\n", i); fds->priv = NULL; @@ -712,7 +712,7 @@ static int stmpe11_poll(FAR struct file *filep, FAR struct pollfd *fds, if (priv->penchange) { - stmpe11_notify(priv); + stmpe811_notify(priv); } } else if (fds->priv) @@ -735,26 +735,26 @@ errout: #endif /**************************************************************************** - * Name: stmpe11_timeoutworker + * Name: stmpe811_timeoutworker * * Description: * A timer has expired without receiving a pen up event. Check again. * ****************************************************************************/ -static void stmpe11_timeoutworker(FAR void *arg) +static void stmpe811_timeoutworker(FAR void *arg) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)arg; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)arg; DEBUGASSERT(priv); /* Treat the timeout just like an interrupt occurred */ - stmpe11_tscworker(priv, stmpe11_getreg8(priv, STMPE11_INT_STA)); + stmpe811_tscworker(priv, stmpe811_getreg8(priv, STMPE811_INT_STA)); } /**************************************************************************** - * Name: stmpe11_timeout + * Name: stmpe811_timeout * * Description: * A timer has expired without receiving a pen up event. Schedule work @@ -762,9 +762,9 @@ static void stmpe11_timeoutworker(FAR void *arg) * ****************************************************************************/ -static void stmpe11_timeout(int argc, uint32_t arg1, ...) +static void stmpe811_timeout(int argc, uint32_t arg1, ...) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)((uintptr_t)arg1); + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)((uintptr_t)arg1); int ret; /* Are we still stuck in the pen down state? */ @@ -778,12 +778,12 @@ static void stmpe11_timeout(int argc, uint32_t arg1, ...) if (work_available(&priv->timeout)) { - /* Yes.. Transfer processing to the worker thread. Since STMPE11 + /* Yes.. Transfer processing to the worker thread. Since STMPE811 * interrupts are disabled while the work is pending, no special * action should be required to protect the work queue. */ - ret = work_queue(&priv->timeout, stmpe11_timeoutworker, priv, 0); + ret = work_queue(&priv->timeout, stmpe811_timeoutworker, priv, 0); if (ret != 0) { illdbg("Failed to queue work: %d\n", ret); @@ -793,15 +793,15 @@ static void stmpe11_timeout(int argc, uint32_t arg1, ...) } /**************************************************************************** - * Name: stmpe11_tscinitialize + * Name: stmpe811_tscinitialize * * Description: * Initialize the touchscreen controller. This is really a part of the - * stmpe11_register logic, + * stmpe811_register logic, * ****************************************************************************/ -static inline void stmpe11_tscinitialize(FAR struct stmpe11_dev_s *priv) +static inline void stmpe811_tscinitialize(FAR struct stmpe811_dev_s *priv) { uint8_t regval; @@ -809,19 +809,19 @@ static inline void stmpe11_tscinitialize(FAR struct stmpe11_dev_s *priv) /* Enable TSC and ADC functions */ - regval = stmpe11_getreg8(priv, STMPE11_SYS_CTRL2); + regval = stmpe811_getreg8(priv, STMPE811_SYS_CTRL2); regval &= ~(SYS_CTRL2_TSC_OFF | SYS_CTRL2_ADC_OFF); - stmpe11_putreg8(priv, STMPE11_SYS_CTRL2, regval); + stmpe811_putreg8(priv, STMPE811_SYS_CTRL2, regval); /* Enable the TSC global interrupts */ - regval = stmpe11_getreg8(priv, STMPE11_INT_EN); + regval = stmpe811_getreg8(priv, STMPE811_INT_EN); regval |= (uint32_t)(INT_TOUCH_DET | INT_FIFO_TH | INT_FIFO_OFLOW); - stmpe11_putreg8(priv, STMPE11_INT_EN, regval); + stmpe811_putreg8(priv, STMPE811_INT_EN, regval); /* Select Sample Time, bit number and ADC Reference */ - stmpe11_putreg8(priv, STMPE11_ADC_CTRL1, priv->config->ctrl1); + stmpe811_putreg8(priv, STMPE811_ADC_CTRL1, priv->config->ctrl1); /* Wait for 20 ms */ @@ -829,45 +829,45 @@ static inline void stmpe11_tscinitialize(FAR struct stmpe11_dev_s *priv) /* Select the ADC clock speed */ - stmpe11_putreg8(priv, STMPE11_ADC_CTRL2, priv->config->ctrl2); + stmpe811_putreg8(priv, STMPE811_ADC_CTRL2, priv->config->ctrl2); /* Select TSC pins in non-GPIO mode (AF=0) */ - regval = stmpe11_getreg8(priv, STMPE11_GPIO_AF); + regval = stmpe811_getreg8(priv, STMPE811_GPIO_AF); regval &= ~(uint8_t)TSC_PIN_SET; - stmpe11_putreg8(priv, STMPE11_GPIO_AF, regval); + stmpe811_putreg8(priv, STMPE811_GPIO_AF, regval); /* Select 2 nF filter capacitor */ - stmpe11_putreg8(priv, STMPE11_TSC_CFG, + stmpe811_putreg8(priv, STMPE811_TSC_CFG, (TSC_CFG_AVE_CTRL_4SAMPLES | TSC_CFG_TOUCH_DELAY_500US | TSC_CFG_SETTLING_500US)); /* Select single point reading */ - stmpe11_putreg8(priv, STMPE11_FIFO_TH, 1); + stmpe811_putreg8(priv, STMPE811_FIFO_TH, 1); /* Reset and clear the FIFO. */ - stmpe11_putreg8(priv, STMPE11_FIFO_STA, FIFO_STA_FIFO_RESET); - stmpe11_putreg8(priv, STMPE11_FIFO_STA, 0); + stmpe811_putreg8(priv, STMPE811_FIFO_STA, FIFO_STA_FIFO_RESET); + stmpe811_putreg8(priv, STMPE811_FIFO_STA, 0); /* set the data format for Z value: 7 fractional part and 1 whole part */ - stmpe11_putreg8(priv, STMPE11_TSC_FRACTIONZ, 0x01); + stmpe811_putreg8(priv, STMPE811_TSC_FRACTIONZ, 0x01); /* Set the driving capability of the device for TSC pins: 50mA */ - stmpe11_putreg8(priv, STMPE11_TSC_IDRIVE, TSC_IDRIVE_50MA); + stmpe811_putreg8(priv, STMPE811_TSC_IDRIVE, TSC_IDRIVE_50MA); /* Enable the TSC. Use no tracking index, touch-screen controller * operation mode (XYZ). */ - stmpe11_putreg8(priv, STMPE11_TSC_CTRL, TSC_CTRL_EN); + stmpe811_putreg8(priv, STMPE811_TSC_CTRL, TSC_CTRL_EN); /* Clear all the status pending bits */ - stmpe11_putreg8(priv, STMPE11_INT_STA, INT_ALL); + stmpe811_putreg8(priv, STMPE811_INT_STA, INT_ALL); } /**************************************************************************** @@ -875,7 +875,7 @@ static inline void stmpe11_tscinitialize(FAR struct stmpe11_dev_s *priv) ****************************************************************************/ /**************************************************************************** - * Name: stmpe11_register + * Name: stmpe811_register * * Description: * Enable TSC functionality. GPIO4-7 must be available. This function @@ -883,7 +883,7 @@ static inline void stmpe11_tscinitialize(FAR struct stmpe11_dev_s *priv) * device number * * Input Parameters: - * handle - The handle previously returned by stmpe11_register + * handle - The handle previously returned by stmpe811_register * minor - The input device minor number * * Returned Value: @@ -892,9 +892,9 @@ static inline void stmpe11_tscinitialize(FAR struct stmpe11_dev_s *priv) * ****************************************************************************/ -int stmpe11_register(STMPE11_HANDLE handle, int minor) +int stmpe811_register(STMPE811_HANDLE handle, int minor) { - FAR struct stmpe11_dev_s *priv = (FAR struct stmpe11_dev_s *)handle; + FAR struct stmpe811_dev_s *priv = (FAR struct stmpe811_dev_s *)handle; char devname[DEV_NAMELEN]; int ret; @@ -940,7 +940,7 @@ int stmpe11_register(STMPE11_HANDLE handle, int minor) /* Register the character driver */ snprintf(devname, DEV_NAMELEN, DEV_FORMAT, minor); - ret = register_driver(devname, &g_stmpe11fops, 0666, priv); + ret = register_driver(devname, &g_stmpe811fops, 0666, priv); if (ret < 0) { idbg("ERROR: Failed to register driver %s: %d\n", devname, ret); @@ -950,34 +950,34 @@ int stmpe11_register(STMPE11_HANDLE handle, int minor) /* Initialize the touchscreen controller */ - stmpe11_tscinitialize(priv); + stmpe811_tscinitialize(priv); /* Inidicate that the touchscreen controller was successfully initialized */ priv->inuse |= TSC_PIN_SET; /* Pins 4-7 are now in-use */ - priv->flags |= STMPE11_FLAGS_TSC_INITIALIZED; /* TSC function is initialized */ + priv->flags |= STMPE811_FLAGS_TSC_INITIALIZED; /* TSC function is initialized */ sem_post(&priv->exclsem); return ret; } /**************************************************************************** - * Name: stmpe11_tscworker + * Name: stmpe811_tscworker * * Description: * This function is called to handle a TSC interrupt. It is not really - * an interrupt handle because it is called from the STMPE11 "bottom half" + * an interrupt handle because it is called from the STMPE811 "bottom half" * logic that runs on the worker thread. * ****************************************************************************/ -void stmpe11_tscworker(FAR struct stmpe11_dev_s *priv, uint8_t intsta) +void stmpe811_tscworker(FAR struct stmpe811_dev_s *priv, uint8_t intsta) { - FAR struct stmpe11_config_s *config; /* Convenience pointer */ - bool pendown; /* true: pend is down */ - uint16_t xdiff; /* X difference used in thresholding */ - uint16_t ydiff; /* Y difference used in thresholding */ - uint16_t x; /* X position */ - uint16_t y; /* Y position */ + FAR struct stmpe811_config_s *config; /* Convenience pointer */ + bool pendown; /* true: pend is down */ + uint16_t xdiff; /* X difference used in thresholding */ + uint16_t ydiff; /* Y difference used in thresholding */ + uint16_t x; /* X position */ + uint16_t y; /* Y position */ ASSERT(priv != NULL); @@ -992,9 +992,9 @@ void stmpe11_tscworker(FAR struct stmpe11_dev_s *priv, uint8_t intsta) config = priv->config; DEBUGASSERT(config != NULL); - /* Check for pen up or down from the TSC_STA ibit n the STMPE11_TSC_CTRL register. */ + /* Check for pen up or down from the TSC_STA ibit n the STMPE811_TSC_CTRL register. */ - pendown = (stmpe11_getreg8(priv, STMPE11_TSC_CTRL) & TSC_CTRL_TSC_STA) != 0; + pendown = (stmpe811_getreg8(priv, STMPE811_TSC_CTRL) & TSC_CTRL_TSC_STA) != 0; /* Handle the change from pen down to pen up */ @@ -1031,12 +1031,12 @@ void stmpe11_tscworker(FAR struct stmpe11_dev_s *priv, uint8_t intsta) { /* Read the next x and y positions from the FIFO. */ -#ifdef CONFIG_STMPE11_SWAPXY - x = stmpe11_getreg16(priv, STMPE11_TSC_DATAX); - y = stmpe11_getreg16(priv, STMPE11_TSC_DATAY); +#ifdef CONFIG_STMPE811_SWAPXY + x = stmpe811_getreg16(priv, STMPE811_TSC_DATAX); + y = stmpe811_getreg16(priv, STMPE811_TSC_DATAY); #else - x = stmpe11_getreg16(priv, STMPE11_TSC_DATAY); - y = stmpe11_getreg16(priv, STMPE11_TSC_DATAX); + x = stmpe811_getreg16(priv, STMPE811_TSC_DATAY); + y = stmpe811_getreg16(priv, STMPE811_TSC_DATAX); #endif /* If we have not yet processed the last pen up event, then we @@ -1066,7 +1066,7 @@ void stmpe11_tscworker(FAR struct stmpe11_dev_s *priv, uint8_t intsta) xdiff = x > priv->threshx ? (x - priv->threshx) : (priv->threshx - x); ydiff = y > priv->threshy ? (y - priv->threshy) : (priv->threshy - y); - if (xdiff < CONFIG_STMPE11_THRESHX && ydiff < CONFIG_STMPE11_THRESHY) + if (xdiff < CONFIG_STMPE811_THRESHX && ydiff < CONFIG_STMPE811_THRESHY) { /* Little or no change in either direction ... don't report anything. */ @@ -1085,7 +1085,7 @@ void stmpe11_tscworker(FAR struct stmpe11_dev_s *priv, uint8_t intsta) /* Update the Z pressure index */ - priv->sample.z = stmpe11_getreg8(priv, STMPE11_TSC_DATAZ); + priv->sample.z = stmpe811_getreg8(priv, STMPE811_TSC_DATAZ); priv->sample.valid = true; /* If this is the first (acknowledged) pen down report, then report @@ -1118,9 +1118,9 @@ void stmpe11_tscworker(FAR struct stmpe11_dev_s *priv, uint8_t intsta) priv->sample.id = priv->id; priv->penchange = true; - /* Notify any waiters that new STMPE11 data is available */ + /* Notify any waiters that new STMPE811 data is available */ - stmpe11_notify(priv); + stmpe811_notify(priv); /* If we think that the pend is still down, the start/re-start the pen up * timer. @@ -1130,15 +1130,15 @@ ignored: if (priv->sample.contact == CONTACT_MOVE || priv->sample.contact == CONTACT_MOVE) { - (void)wd_start(priv->wdog, STMPE11_PENUP_TICKS, stmpe11_timeout, + (void)wd_start(priv->wdog, STMPE811_PENUP_TICKS, stmpe811_timeout, 1, (uint32_t)((uintptr_t)priv)); } /* Reset and clear all data in the FIFO */ - stmpe11_putreg8(priv, STMPE11_FIFO_STA, FIFO_STA_FIFO_RESET); - stmpe11_putreg8(priv, STMPE11_FIFO_STA, 0); + stmpe811_putreg8(priv, STMPE811_FIFO_STA, FIFO_STA_FIFO_RESET); + stmpe811_putreg8(priv, STMPE811_FIFO_STA, 0); } -#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE11 && !CONFIG_STMPE11_TSC_DISABLE */ +#endif /* CONFIG_INPUT && CONFIG_INPUT_STMPE811 && !CONFIG_STMPE811_TSC_DISABLE */ diff --git a/nuttx/include/nuttx/input/stmpe811.h b/nuttx/include/nuttx/input/stmpe811.h index 489ac333c5..cea54a34f3 100644 --- a/nuttx/include/nuttx/input/stmpe811.h +++ b/nuttx/include/nuttx/input/stmpe811.h @@ -546,10 +546,10 @@ extern "C" { #ifdef CONFIG_STMPE811_SPI EXTERN STMPE811_HANDLE stmpe811_instantiate(FAR struct spi_dev_s *dev, - FAR struct stmpe811_config_s *config); + FAR struct stmpe811_config_s *config); #else EXTERN STMPE811_HANDLE stmpe811_instantiate(FAR struct i2c_dev_s *dev, - FAR struct stmpe811_config_s *config); + FAR struct stmpe811_config_s *config); #endif /******************************************************************************************** @@ -657,7 +657,7 @@ EXTERN int stmpe811_gpioread(STMPE811_HANDLE handle, uint8_t pinconfig, bool *va #if !defined(CONFIG_STMPE811_GPIO_DISABLE) && !defined(CONFIG_STMPE811_GPIOINT_DISABLE) EXTERN int stmpe811_gpioattach(STMPE811_HANDLE handle, uint8_t pinconfig, - stmpe811_handler_t handler); + stmpe811_handler_t handler); #endif /********************************************************************************************