From a280d993608d0c40ad0b4efc8adcbf72f67d53a4 Mon Sep 17 00:00:00 2001 From: patacongo Date: Fri, 11 May 2012 00:05:25 +0000 Subject: NxWM: Finishes touchscreen implementation; NuttX: Standardize touchscreen initialization interfaces for all boards git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@4721 42af7a65-404d-4744-a932-0658087f49c3 --- NxWidgets/UnitTests/nxwm/main.cxx | 72 ++-- NxWidgets/libnxwidgets/src/cnxserver.cxx | 86 ++--- NxWidgets/nxwm/include/ccalibration.hxx | 7 +- NxWidgets/nxwm/include/ctaskbar.hxx | 12 + NxWidgets/nxwm/include/ctouchscreen.hxx | 119 ++++++- NxWidgets/nxwm/include/nxwmconfig.hxx | 34 ++ NxWidgets/nxwm/src/ccalibration.cxx | 5 +- NxWidgets/nxwm/src/ctouchscreen.cxx | 385 ++++++++++++++++++++- apps/ChangeLog.txt | 2 + apps/examples/touchscreen/tc.h | 24 -- nuttx/ChangeLog | 4 + nuttx/arch/sim/src/up_touchscreen.c | 8 +- .../hymini-stm32v/src/hymini_stm32v-internal.h | 13 - nuttx/configs/hymini-stm32v/src/up_ts.c | 33 +- nuttx/configs/sam3u-ek/src/up_touchscreen.c | 30 +- nuttx/configs/sim/README.txt | 2 +- nuttx/configs/sim/src/up_touchscreen.c | 4 +- nuttx/configs/stm3240g-eval/nxwm/appconfig | 5 +- nuttx/configs/stm3240g-eval/src/up_stmpe11.c | 27 +- nuttx/drivers/input/stmpe11_tsc.c | 7 +- nuttx/include/nuttx/input/touchscreen.h | 24 +- 21 files changed, 723 insertions(+), 180 deletions(-) diff --git a/NxWidgets/UnitTests/nxwm/main.cxx b/NxWidgets/UnitTests/nxwm/main.cxx index 7cdc778e0..291267eb8 100644 --- a/NxWidgets/UnitTests/nxwm/main.cxx +++ b/NxWidgets/UnitTests/nxwm/main.cxx @@ -46,6 +46,7 @@ #include "ctaskbar.hxx" #include "cstartwindow.hxx" +#include "ctouchscreen.hxx" #include "ccalibration.hxx" #include "cnxconsole.hxx" @@ -260,10 +261,10 @@ static bool createTaskbar(void) // Connect to the NX server - printf(MAIN_STRING "Connect the CTaskbar instance to the NX server\n"); + printf(MAIN_STRING "Connect CTaskbar instance to the NX server\n"); if (!g_nxwmtest.taskbar->connect()) { - printf(MAIN_STRING "ERROR: Failed to connect the CTaskbar instance to the NX server\n"); + printf(MAIN_STRING "ERROR: Failed to connect CTaskbar instance to the NX server\n"); return false; } showTestCaseMemory("After connecting to the server"); @@ -274,10 +275,10 @@ static bool createTaskbar(void) // CTaskBar::startWindowManager() brings the window manager up with those applications // in place. - printf(MAIN_STRING "Initialize the CTaskbar instance\n"); + printf(MAIN_STRING "Initialize CTaskbar instance\n"); if (!g_nxwmtest.taskbar->initWindowManager()) { - printf(MAIN_STRING "ERROR: Failed to intialize the CTaskbar instance\n"); + printf(MAIN_STRING "ERROR: Failed to intialize CTaskbar instance\n"); return false; } @@ -309,10 +310,10 @@ static bool createStartWindow(void) } showTestCaseMemory("After creating start window application window"); - printf(MAIN_STRING "Initialize the CApplicationWindow\n"); + printf(MAIN_STRING "Initialize CApplicationWindow\n"); if (!window->open()) { - printf(MAIN_STRING "ERROR: Failed to open the CApplicationWindow \n"); + printf(MAIN_STRING "ERROR: Failed to open CApplicationWindow \n"); delete window; return false; } @@ -367,25 +368,30 @@ static bool startWindowManager(void) #ifdef CONFIG_NXWM_TOUCHSCREEN static bool createTouchScreen(void) { - // Create the touchscreen device + // Get the physical size of the device in pixels + + struct nxgl_size_s windowSize; + (void)g_nxwmtest.taskbar->getWindowSize(&windowSize); + + // Create the touchscreen device printf(MAIN_STRING "Creating CTouchscreen\n"); - g_nxwmtest.touchscreen = new NxWM::CTouchscreen; + g_nxwmtest.touchscreen = new NxWM::CTouchscreen(g_nxwmtest.taskbar, &windowSize); if (!g_nxwmtest.touchscreen) { printf(MAIN_STRING "ERROR: Failed to create CTouchscreen\n"); return false; } - printf(MAIN_STRING "Initialize the CTouchscreen\n"); - if (!g_nxwmtest.touchscreen->open()) + printf(MAIN_STRING "Start touchscreen listener\n"); + if (!g_nxwmtest.touchscreen->start()) { - printf(MAIN_STRING "ERROR: Failed to open the CTouchscreen \n"); + printf(MAIN_STRING "ERROR: Failed start the touchscreen listener\n"); delete g_nxwmtest.touchscreen; return false; } - showTestCaseMemory("After initializing CTouchscreen"); + showTestCaseMemory("After starting the touchscreen listener"); return true; } #endif @@ -414,16 +420,16 @@ static bool createCalibration(void) } showTestCaseMemory("After creating calibration full screen window"); - printf(MAIN_STRING "Initialize the CFullScreenWindow\n"); + printf(MAIN_STRING "Initialize CFullScreenWindow\n"); if (!window->open()) { - printf(MAIN_STRING "ERROR: Failed to open the CFullScreenWindow \n"); + printf(MAIN_STRING "ERROR: Failed to open CFullScreenWindow \n"); delete window; return false; } showTestCaseMemory("After initializing the calibration full screen window"); - printf(MAIN_STRING "Creating the CCalibration application\n"); + printf(MAIN_STRING "Creating CCalibration application\n"); g_nxwmtest.calibration = new NxWM::CCalibration(window, g_nxwmtest.touchscreen); if (!g_nxwmtest.calibration) { @@ -431,9 +437,9 @@ static bool createCalibration(void) delete window; return false; } - showTestCaseMemory("After creating the CCalibration application"); + showTestCaseMemory("After creating CCalibration application"); - printf(MAIN_STRING "Adding the CCalibration application to the start window\n"); + printf(MAIN_STRING "Adding CCalibration application to the start window\n"); if (!g_nxwmtest.startwindow->addApplication(g_nxwmtest.calibration)) { printf(MAIN_STRING "ERROR: Failed to add CCalibration to the start window\n"); @@ -441,7 +447,7 @@ static bool createCalibration(void) return false; } - showTestCaseMemory("After adding the CCalibration application"); + showTestCaseMemory("After adding CCalibration application"); return true; } #endif @@ -501,10 +507,10 @@ static bool createNxConsole(void) } showTestCaseMemory("After creating the NxConsole application window"); - printf(MAIN_STRING "Initialize the CApplicationWindow\n"); + printf(MAIN_STRING "Initialize CApplicationWindow\n"); if (!window->open()) { - printf(MAIN_STRING "ERROR: Failed to open the CApplicationWindow \n"); + printf(MAIN_STRING "ERROR: Failed to open CApplicationWindow \n"); delete window; return false; } @@ -583,7 +589,7 @@ int MAIN_NAME(int argc, char *argv[]) if (!createTaskbar()) { - printf(MAIN_STRING "Failed to create the task bar\n"); + printf(MAIN_STRING "ERROR: Failed to create the task bar\n"); testCleanUpAndExit(EXIT_FAILURE); } @@ -591,7 +597,7 @@ int MAIN_NAME(int argc, char *argv[]) if (!createStartWindow()) { - printf(MAIN_STRING "Failed to create the start window\n"); + printf(MAIN_STRING "ERROR: Failed to create the start window\n"); testCleanUpAndExit(EXIT_FAILURE); } @@ -600,27 +606,21 @@ int MAIN_NAME(int argc, char *argv[]) #ifdef CONFIG_NXWM_TOUCHSCREEN if (!createTouchScreen()) { - printf(MAIN_STRING "Failed to create the start window\n"); + printf(MAIN_STRING "ERROR: Failed to create the touchscreen\n"); testCleanUpAndExit(EXIT_FAILURE); } #endif - // Perform touchscreen calibration + // Perform touchscreen calibration. In a real system, you would only do this + // if you have no saved touchscreen calibration. In this Unit Test, we run + // the calibration unconditionally. #ifdef CONFIG_NXWM_TOUCHSCREEN - // Create the touchscreen device - - if (!createTouchScreen()) - { - printf(MAIN_STRING "Failed to create the touchscreen\n"); - testCleanUpAndExit(EXIT_FAILURE); - } - // Create the calibration application if (!createCalibration()) { - printf(MAIN_STRING "Failed to create the calibration application\n"); + printf(MAIN_STRING "ERROR: Failed to create the calibration application\n"); testCleanUpAndExit(EXIT_FAILURE); } @@ -628,7 +628,7 @@ int MAIN_NAME(int argc, char *argv[]) if (!runCalibration()) { - printf(MAIN_STRING "Touchscreen Calibration failed\n"); + printf(MAIN_STRING "ERROR: Touchscreen Calibration failed\n"); testCleanUpAndExit(EXIT_FAILURE); } #endif @@ -637,7 +637,7 @@ int MAIN_NAME(int argc, char *argv[]) if (!createNxConsole()) { - printf(MAIN_STRING "Failed to create the NxConsole application\n"); + printf(MAIN_STRING "ERROR: Failed to create the NxConsole application\n"); testCleanUpAndExit(EXIT_FAILURE); } @@ -645,7 +645,7 @@ int MAIN_NAME(int argc, char *argv[]) if (!startWindowManager()) { - printf(MAIN_STRING "Failed to start the window manager\n"); + printf(MAIN_STRING "ERROR: Failed to start the window manager\n"); testCleanUpAndExit(EXIT_FAILURE); } diff --git a/NxWidgets/libnxwidgets/src/cnxserver.cxx b/NxWidgets/libnxwidgets/src/cnxserver.cxx index dc6316835..be67e5641 100644 --- a/NxWidgets/libnxwidgets/src/cnxserver.cxx +++ b/NxWidgets/libnxwidgets/src/cnxserver.cxx @@ -232,47 +232,51 @@ bool CNxServer::connect(void) m_hNxServer = nx_connect(); if (m_hNxServer) { - pthread_attr_t attr; - - // Start a separate thread to listen for server events. This is probably - // the least efficient way to do this, but it makes this logic flow more - // smoothly. - - (void)pthread_attr_init(&attr); - param.sched_priority = CONFIG_NXWIDGETS_LISTENERPRIO; - (void)pthread_attr_setschedparam(&attr, ¶m); - (void)pthread_attr_setstacksize(&attr, CONFIG_NXWIDGETS_LISTENERSTACK); - - m_stop = false; - m_running = true; - - ret = pthread_create(&thread, &attr, listener, (FAR void *)this); - if (ret != 0) - { - gdbg("NxServer::connect: pthread_create failed: %d\n", ret); - m_running = false; - disconnect(); - return false; - } - - // Don't return until we are connected to the server - - while (!m_connected && m_running) - { - // Wait for the listener thread to wake us up when we really - // are connected. - - (void)sem_wait(&m_connsem); - } - - // In the successful case, the listener is still running (m_running) - // and the server is connected (m_connected). Anything else is a failure. - - if (!m_connected || !m_running) - { - disconnect(); - return false; - } + pthread_attr_t attr; + + // Start a separate thread to listen for server events. This is probably + // the least efficient way to do this, but it makes this logic flow more + // smoothly. + + (void)pthread_attr_init(&attr); + param.sched_priority = CONFIG_NXWIDGETS_LISTENERPRIO; + (void)pthread_attr_setschedparam(&attr, ¶m); + (void)pthread_attr_setstacksize(&attr, CONFIG_NXWIDGETS_LISTENERSTACK); + + m_stop = false; + m_running = true; + + ret = pthread_create(&thread, &attr, listener, (FAR void *)this); + if (ret != 0) + { + gdbg("NxServer::connect: pthread_create failed: %d\n", ret); + m_running = false; + disconnect(); + return false; + } + + // Detach from the thread + + (void)pthread_detach(thread); + + // Don't return until we are connected to the server + + while (!m_connected && m_running) + { + // Wait for the listener thread to wake us up when we really + // are connected. + + (void)sem_wait(&m_connsem); + } + + // In the successful case, the listener is still running (m_running) + // and the server is connected (m_connected). Anything else is a failure. + + if (!m_connected || !m_running) + { + disconnect(); + return false; + } } else { diff --git a/NxWidgets/nxwm/include/ccalibration.hxx b/NxWidgets/nxwm/include/ccalibration.hxx index 0adcd894f..42eb56ad2 100644 --- a/NxWidgets/nxwm/include/ccalibration.hxx +++ b/NxWidgets/nxwm/include/ccalibration.hxx @@ -50,7 +50,6 @@ #include "iapplication.hxx" #include "cfullscreenwindow.hxx" -#include "ctouchscreen.hxx" /**************************************************************************** * Pre-processor Definitions @@ -72,6 +71,12 @@ namespace NxWM { + /** + * Forward references + */ + + struct CTouchscreen; + /** * Touchscreen calibration data */ diff --git a/NxWidgets/nxwm/include/ctaskbar.hxx b/NxWidgets/nxwm/include/ctaskbar.hxx index 69595163c..398087f84 100644 --- a/NxWidgets/nxwm/include/ctaskbar.hxx +++ b/NxWidgets/nxwm/include/ctaskbar.hxx @@ -385,6 +385,18 @@ namespace NxWM bool stopApplication(IApplication *app); + /** + * Get the size of the physical display device as it is known to the task + * bar. + * + * @return The size of the display + */ + + inline bool getWindowSize(FAR struct nxgl_size_s *size) + { + return m_taskbar->getSize(size); + } + /** * Simulate a mouse click on the icon at index. This inline method is only * used during automated testing of NxWM. diff --git a/NxWidgets/nxwm/include/ctouchscreen.hxx b/NxWidgets/nxwm/include/ctouchscreen.hxx index f8eaeaee8..c3aa198cb 100644 --- a/NxWidgets/nxwm/include/ctouchscreen.hxx +++ b/NxWidgets/nxwm/include/ctouchscreen.hxx @@ -43,8 +43,13 @@ #include #include +#include + #include +#include "cnxserver.hxx" +#include "ccalibration.hxx" + /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ @@ -63,16 +68,68 @@ namespace NxWM class CTouchscreen { private: - int m_touchFd; /**< File descriptor of the opened touchscreen device */ - sem_t m_waitSem; /**< Semaphore the supports waits for touchscreen data */ + /** + * The state of the listener thread. + */ + + enum EListenerState + { + LISTENER_NOTRUNNING = 0, /**< The listener thread has not yet been started */ + LISTENER_STARTED, /**< The listener thread has been started, but is not yet running */ + LISTENER_RUNNING, /**< The listener thread is running normally */ + LISTENER_STOPREQUESTED, /**< The listener thread has been requested to stop */ + LISTENER_TERMINATED, /**< The listener thread terminated normally */ + LISTENER_FAILED /**< The listener thread terminated abnormally */ + }; + + /** + * CTouchscreen state data + */ + + NXWidgets::CNxServer *m_server; /**< The current NX server */ + int m_touchFd; /**< File descriptor of the opened touchscreen device */ + sem_t m_waitSem; /**< Semaphore the supports waits for touchscreen data */ + pthread_t m_thread; /**< The listener thread ID */ + volatile enum EListenerState m_state; /**< The state of the listener thread */ + volatile bool m_enabled; /**< True: Normal touchscreen processing */ + volatile bool m_capture; /**< True: There is a thread waiting for raw touch data */ + volatile bool m_calibrated; /**< True: If have calibration data */ + struct nxgl_size_s m_windowSize; /**< The size of the physical display */ + struct SCalibrationData m_calibData; /**< Calibration data */ + struct touch_sample_s m_sample; /**< In normal mode, touch data is collected here */ + struct touch_sample_s *m_touch; /**< Points to the current touch data buffer */ + + /** + * The touchscreen listener thread. This is the entry point of a thread that + * listeners for and dispatches touchscreens events to the NX server. + * + * @param arg. The CTouchscreen 'this' pointer cast to a void*. + * @return This function normally does not return but may return NULL on + * error conditions. + */ + + static FAR void *listener(FAR void *arg); + + /** + * Inject touchscreen data into NX as mouse intput + * + * @param sample. The buffer where data was collected. + */ + + void handleMouseInput(struct touch_sample_s *sample); public: /** * CTouchscreen Constructor + * + * @param server. An instance of the NX server. This will be needed for + * injecting mouse data. + * @param windowSize. The size of the physical window in pixels. This + * is needed for touchscreen scaling. */ - CTouchscreen(void); + CTouchscreen(NXWidgets::CNxServer *server, struct nxgl_size_s *windowSize); /** * CTouchscreen Destructor @@ -81,22 +138,66 @@ namespace NxWM ~CTouchscreen(void); /** - * Initialize the touchscreen device. Initialization is separate from - * object instantiation so that failures can be reported. + * Start the touchscreen listener thread. * - * @return True if the touchscreen device was correctly initialized + * @return True if the touchscreen listener thread was correctly started. */ - bool open(void); + bool start(void); + + /** + * Enable/disable touchscreen data processing. When enabled, touchscreen events + * are calibrated and forwarded to the NX layer which dispatches the touchscreen + * events in window-relative positions to the correct NX window. + * + * When disabled, touchscreen data is not forwarded to NX, but is instead captured + * and made available for touchscreen calibration. The touchscreen driver is + * initially disabled and must be specifically enabled be begin normal processing. + * Normal processing also requires calibration data (see method setCalibrationData) + * + * @param capture. True enables capture mode; false disables. + */ + + inline void setEnabled(bool enable) + { + // Set the capture flag. m_calibrated must also be set to get to normal + // mode where touchscreen data is forwarded to NX. + + m_enabled = enable; + } + + /** + * Provide touchscreen calibration data. If calibration data is received (and + * the touchscreen is enabled), then received touchscreen data will be scaled + * using the calibration data and forward to the NX layer which dispatches the + * touchscreen events in window-relative positions to the correct NX window. + * + * @param data. A reference to the touchscreen data. + */ + + inline void setCalibrationData(struct SCalibrationData &caldata) + { + // Save a copy of the calibration data + + m_calibData = caldata; + + // Note that we have calibration data. Data will now be scaled and forwarded + // to NX (unless we are still in cpature mode) + + m_calibrated = true; + } /** - * Capture raw driver data. + * Capture raw driver data. This method will capture mode one raw touchscreen + * input. The normal use of this method is for touchscreen calibration. * + * This function is not re-entrant: There may be only one thread waiting for + * raw touchscreen data. * * @return True if the raw touchscreen data was sucessfully obtained */ - bool waitRawTouchData(struct touch_sample_s &touch); + bool waitRawTouchData(struct touch_sample_s *touch); }; } diff --git a/NxWidgets/nxwm/include/nxwmconfig.hxx b/NxWidgets/nxwm/include/nxwmconfig.hxx index 4e08b0481..4e51cea1d 100644 --- a/NxWidgets/nxwm/include/nxwmconfig.hxx +++ b/NxWidgets/nxwm/include/nxwmconfig.hxx @@ -42,6 +42,8 @@ #include +#include + #include "nxconfig.hxx" #include "crlepalettebitmap.hxx" @@ -322,12 +324,43 @@ #endif /* Touchscreen device *******************************************************/ +/** + * Touchscreen device settings + * + * CONFIG_NXWM_TOUCHSCREEN_DEVNO - Touchscreen device minor number, i.e., the + * N in /dev/inputN. Default: 0 + * CONFIG_NXWM_TOUCHSCREEN_DEVNO - The full path to the touchscreen device. + * Default: "/dev/input0" + * CONFIG_NXWM_TOUCHSCREEN_SIGNO - The realtime signal used to wake up the + * touchscreen listener thread. Default: 5 + */ + +#ifndef CONFIG_NXWM_TOUCHSCREEN_DEVNO +# define CONFIG_NXWM_TOUCHSCREEN_DEVNO 0 +#endif #ifndef CONFIG_NXWM_TOUCHSCREEN_DEVPATH # define CONFIG_NXWM_TOUCHSCREEN_DEVPATH "/dev/input0" #endif +#ifndef CONFIG_NXWM_TOUCHSCREEN_SIGNO +# define CONFIG_NXWM_TOUCHSCREEN_SIGNO 5 +#endif + /* Calibration display ******************************************************/ +/** + * Calibration display settings: + * + * CONFIG_NXWM_CALIBRATION_BACKGROUNDCOLOR - The background color of the + * touchscreen calibration display. Default: Same as + * CONFIG_NXWM_DEFAULT_BACKGROUNDCOLOR + * CONFIG_NXWM_CALIBRATION_LINECOLOR - The color of the lines used in the + * touchscreen calibration display. Default: MKRGB(0, 0, 128) (dark blue) + * CONFIG_NXWM_CALIBRATION_BACKGROUNDCOLOR - The background color of the + * touchscreen calibration display. Default: MKRGB(255, 255, 255) (white) + * CONFIG_NXWM_CALIBRATION_ICON - The ICON to use for the touchscreen + * calibration application. Default: NxWM::g_calibrationBitmap + */ #ifndef CONFIG_NXWM_CALIBRATION_BACKGROUNDCOLOR # define CONFIG_NXWM_CALIBRATION_BACKGROUNDCOLOR CONFIG_NXWM_DEFAULT_BACKGROUNDCOLOR @@ -344,6 +377,7 @@ #ifndef CONFIG_NXWM_CALIBRATION_ICON # define CONFIG_NXWM_CALIBRATION_ICON NxWM::g_calibrationBitmap #endif + /**************************************************************************** * Global Function Prototypes ****************************************************************************/ diff --git a/NxWidgets/nxwm/src/ccalibration.cxx b/NxWidgets/nxwm/src/ccalibration.cxx index 6e66f3028..82c12ebb3 100644 --- a/NxWidgets/nxwm/src/ccalibration.cxx +++ b/NxWidgets/nxwm/src/ccalibration.cxx @@ -43,6 +43,7 @@ #include "nxwmconfig.hxx" #include "nxwmglyphs.hxx" +#include "ctouchscreen.hxx" #include "ccalibration.hxx" /**************************************************************************** @@ -161,7 +162,7 @@ bool CCalibration::run(void) // Wait for the next raw touchscreen input struct touch_sample_s sample; - while (!m_touchscreen->waitRawTouchData(sample)); + while (!m_touchscreen->waitRawTouchData(&sample)); // Then process the raw touchscreen input @@ -190,7 +191,7 @@ void CCalibration::stop(void) void CCalibration::hide(void) { -#warning "Revisit" + // REVISIT } /** diff --git a/NxWidgets/nxwm/src/ctouchscreen.cxx b/NxWidgets/nxwm/src/ctouchscreen.cxx index 215e50064..737c7d9e3 100644 --- a/NxWidgets/nxwm/src/ctouchscreen.cxx +++ b/NxWidgets/nxwm/src/ctouchscreen.cxx @@ -43,6 +43,9 @@ #include #include +#include +#include +#include #include #include @@ -58,6 +61,21 @@ /******************************************************************************************** * Pre-Processor Definitions ********************************************************************************************/ +/* We want debug output from this file if either input/touchscreen or graphics debug is + * enabled. + */ + +#if !defined(CONFIG_DEBUG_INPUT) && !defined(CONFIG_DEBUG_GRAPHICS) +# undef dbg +# undef vdbg +# ifdef CONFIG_CPP_HAVE_VARARGS +# define dbg(x...) +# define vdbg(x...) +# else +# define dbg (void) +# define vdbg (void) +# endif +#endif /******************************************************************************************** * CTouchscreen Method Implementations @@ -67,11 +85,32 @@ using namespace NxWM; /** * CTouchscreen Constructor + * + * @param server. An instance of the NX server. This will be needed for + * injecting mouse data. + * @param windowSize. The size of the physical window in pixels. This + * is needed for touchscreen scaling. */ -CTouchscreen::CTouchscreen(void) +CTouchscreen::CTouchscreen(NXWidgets::CNxServer *server, struct nxgl_size_s *windowSize) { - m_touchFd = -1; + m_server = server; // Save the NX server + m_touchFd = -1; // Device driver is not opened + m_state = LISTENER_NOTRUNNING; // The listener thread is not running yet + m_enabled = false; // Normal forwarding is not enabled + m_capture = false; // There is no thread waiting for touchscreen data + m_calibrated = false; // We have no calibration data + + // Save the window size + + m_windowSize = *windowSize; + + // Use the default touch data buffer + + m_touch = &m_sample; + + // Initialize the m_waitSem semaphore so that any waits for data will block + sem_init(&m_waitSem, 0, 0); } @@ -81,45 +120,359 @@ CTouchscreen::CTouchscreen(void) CTouchscreen::~CTouchscreen(void) { + // Stop the listener thread + + m_state = LISTENER_STOPREQUESTED; + + // Wake up the listener thread so that it will use our buffer + // to receive data + // REVISIT: Need wait here for the listener thread to terminate + + (void)pthread_kill(m_thread, CONFIG_NXWM_TOUCHSCREEN_SIGNO); + + // Close the touchscreen device (or should these be done when the thread exits?) + if (m_touchFd >= 0) { std::close(m_touchFd); } + // Destroy the semaphores that we created. + sem_destroy(&m_waitSem); } /** - * Initialize the touchscreen device. Initialization is separate from - * object instantiation so that failures can be reported. + * Start the touchscreen listener thread. * - * @return True if the touchscreen device was correctly initialized + * @return True if the touchscreen listener thread was correctly started. */ -bool CTouchscreen::open(void) +bool CTouchscreen::start(void) { - // Open the touchscreen device + pthread_attr_t attr; + + vdbg("Starting listener\n"); + + // Start a separate thread to listen for touchscreen events - m_touchFd = std::open(CONFIG_NXWM_TOUCHSCREEN_DEVPATH, O_RDONLY); - if (m_touchFd < 0) + (void)pthread_attr_init(&attr); + + struct sched_param param; + param.sched_priority = CONFIG_NXWIDGETS_LISTENERPRIO; + (void)pthread_attr_setschedparam(&attr, ¶m); + + (void)pthread_attr_setstacksize(&attr, CONFIG_NXWIDGETS_LISTENERSTACK); + + m_state = LISTENER_STARTED; // The listener thread has been started, but is not yet running + + int ret = pthread_create(&m_thread, &attr, listener, (FAR void *)this); + if (ret != 0) { - gdbg("ERROR Failed to open %s for reading: %d\n", - CONFIG_NXWM_TOUCHSCREEN_DEVPATH, errno); + dbg("NxServer::connect: pthread_create failed: %d\n", ret); return false; } - return true; + // Detach from the thread + + (void)pthread_detach(m_thread); + + // Don't return until we are sure that the listener thread is running + // (or until it reports an error). + + while (m_state == LISTENER_STARTED) + { + // Wait for the listener thread to wake us up when we really + // are connected. + + (void)sem_wait(&m_waitSem); + } + + // Then return true only if the listener thread reported successful + // initialization. + + vdbg("Listener m_state=%d\n", (int)m_state); + return m_state == LISTENER_RUNNING; } /** - * Capture raw driver data. + * Capture raw driver data. This method will capture mode one raw touchscreen + * input. The normal use of this method is for touchscreen calibration. * + * This function is not re-entrant: There may be only one thread waiting for + * raw touchscreen data. * * @return True if the raw touchscreen data was sucessfully obtained */ -bool CTouchscreen::waitRawTouchData(struct touch_sample_s &touch) +bool CTouchscreen::waitRawTouchData(struct touch_sample_s *touch) { -#warning "Missing logic" - return true; + vdbg("Capturing touch input\n"); + + // Setup to cpature raw data into the user provided buffer + + sched_lock(); + m_touch = touch; + m_capture = true; + + // Wake up the listener thread so that it will use our buffer + // to receive data + + (void)pthread_kill(m_thread, CONFIG_NXWM_TOUCHSCREEN_SIGNO); + + // And wait for touch data + + int ret = OK; + while (m_capture) + { + ret = sem_wait(&m_waitSem); + DEBUGASSERT(ret == 0 || errno == EINTR); + } + sched_unlock(); + + // And return success. The listener thread will have (1) reset both + // m_touch and m_capture and (2) posted m_waitSem + + vdbg("Returning touch input: %d\n", ret); + return ret == OK; } + +/** + * The touchscreen listener thread. This is the entry point of a thread that + * listeners for and dispatches touchscreens events to the NX server. + * + * @param arg. The CTouchscreen 'this' pointer cast to a void*. + * @return This function normally does not return but may return NULL on + * error conditions. + */ + +FAR void *CTouchscreen::listener(FAR void *arg) +{ + CTouchscreen *This = (CTouchscreen *)arg; + + vdbg("Listener started\n"); + + // Initialize the touchscreen device + + int ret = arch_tcinitialize(CONFIG_NXWM_TOUCHSCREEN_DEVNO); + if (ret < 0) + { + dbg("ERROR Failed initialize the touchscreen device: %d\n", ret); + This->m_state = LISTENER_FAILED; + sem_post(&This->m_waitSem); + return (FAR void *)0; + } + + // Open the touchscreen device that we just created. + + This->m_touchFd = std::open(CONFIG_NXWM_TOUCHSCREEN_DEVPATH, O_RDONLY); + if (This->m_touchFd < 0) + { + dbg("ERROR Failed to open %s for reading: %d\n", + CONFIG_NXWM_TOUCHSCREEN_DEVPATH, errno); + This->m_state = LISTENER_FAILED; + sem_post(&This->m_waitSem); + return (FAR void *)0; + } + + // Indicate that we have successfully initialized + + This->m_state = LISTENER_RUNNING; + sem_post(&This->m_waitSem); + + // Now loop, reading and dispatching touchscreen data + + while (This->m_state == LISTENER_RUNNING) + { + // The sample pointer can change dynamically let's sample it once + // and stick with that pointer. + + struct touch_sample_s *sample = This->m_touch; + + // Read one touchscreen sample + + vdbg("Listening for sample %p\n", sample); + DEBUGASSERT(sample); + ssize_t nbytes = read(This->m_touchFd, sample, + sizeof(struct touch_sample_s)); + vdbg("Received nbytes=%d\n", nbytes); + + // Check for errors + + if (nbytes < 0) + { + // The only expect error is to be interrupt by a signal + + int errval = errno; + + dbg("read %s failed: %d\n", + CONFIG_NXWM_TOUCHSCREEN_DEVPATH, errval); + DEBUGASSERT(errval == EINTR); + } + + // On a truly success read, the size of the returned data will + // be exactly the size of one touchscreen sample + + else if (nbytes == sizeof(struct touch_sample_s)) + { + // Looks like good touchscreen input... process it + + This->handleMouseInput(sample); + } + else + { + dbg("ERROR Unexpected read size=%d, expected=%d\n", + nbytes, sizeof(struct touch_sample_s)); + } + } + + // We should get here only if we were asked to terminate via + // m_state = LISTENER_STOPREQUESTED + + vdbg("Listener exiting\n"); + This->m_state = LISTENER_TERMINATED; + return (FAR void *)0; +} + +/** + * Inject touchscreen data into NX as mouse intput + */ + +void CTouchscreen::handleMouseInput(struct touch_sample_s *sample) +{ + vdbg("Touch id: %d flags: %02x x: %d y: %d h: %d w: %d pressure: %d\n", + sample->point[0].id, sample->point[0].flags, sample->point[0].x, + sample->point[0].y, sample->point[0].h, sample->point[0].w, + sample->point[0].pressure); + + // Verify the touchscreen data + + if (sample->npoints < 1 || + ((sample->point[0].flags & TOUCH_POS_VALID) == 0 && + (sample->point[0].flags & TOUCH_UP) == 0)) + { + // The pen is (probably) down, but we have do not have valid + // X/Y position data to report. This should not happen. + + return; + } + + // Was this data captured by some external logic? (probably the + // touchscreen calibration logic) + + if (m_capture && sample != &m_sample) + { + // Yes.. let waitRawTouchData know that the data is available + // and restore normal buffering + + m_touch = &m_sample; + m_capture = false; + sem_post(&m_waitSem); + return; + } + + // Sanity checks. Re-directed touch data should never reach this point. + // After posting m_waitSem, m_touch might change asynchronously. + + DEBUGASSERT(sample == &m_sample); + + // Check if normal processing of touchscreen data is enaable. Check if + // we have been given calibration data. + + if (!m_enabled || !m_calibrated) + { + // No.. we are not yet ready to process touchscreen data + + return; + } + + // Now we will inject the touchscreen into NX as mouse input. First + // massage the data a litle so that it behaves a little more like a + // mouse with only a left button + // + // Was the button up or down? + + uint8_t buttons; + if ((sample->point[0].flags & (TOUCH_DOWN|TOUCH_MOVE)) != 0) + { + buttons = NX_MOUSE_LEFTBUTTON; + } + else if ((sample->point[0].flags & TOUCH_UP) != 0) + { + buttons = NX_MOUSE_NOBUTTONS; + } + else + { + // The pen is neither up nor down. This should not happen + + return; + } + + // Get the "raw" touch coordinates (if they are valid) + + nxgl_coord_t x; + nxgl_coord_t y; + + if ((sample->point[0].flags & TOUCH_POS_VALID) == 0) + { + x = 0; + y = 0; + } + else + { + // We have valid coordinates. Get the raw touch + // position from the sample + + uint32_t rawX = (uint32_t)sample->point[0].x; + uint32_t rawY = (uint32_t)sample->point[0].y; + + // Get the fixed precision, scaled X and Y values + + b16_t scaledX = rawX * m_calibData.xSlope + m_calibData.xOffset; + b16_t scaledY = rawY * m_calibData.ySlope + m_calibData.yOffset; + + // Get integer scaled X and Y positions and clip + // to fix in the window + + int32_t bigX = b16toi(scaledX + b16HALF); + int32_t bigY = b16toi(scaledY + b16HALF); + + // Clip to the display + + if (bigX < 0) + { + x = 0; + } + else if (bigX >= m_windowSize.w) + { + x = m_windowSize.w - 1; + } + else + { + x = (nxgl_coord_t)bigX; + } + + if (bigY < 0) + { + y = 0; + } + else if (bigY >= m_windowSize.h) + { + y = m_windowSize.h - 1; + } + else + { + y = (nxgl_coord_t)bigY; + } + + vdbg("raw: (%d, %d) scaled: (%d, %d)\n", rawX, rawY, x, y); + } + + // Get the server handle and "inject the mouse data + + NXHANDLE handle = m_server->getServer(); + (void)nx_mousein(handle, x, y, buttons); +} + + + diff --git a/apps/ChangeLog.txt b/apps/ChangeLog.txt index 9dcb3ad1f..9934e1fe4 100755 --- a/apps/ChangeLog.txt +++ b/apps/ChangeLog.txt @@ -226,3 +226,5 @@ basis in the ChangeLog) * apps/examples/watchdog: Add a watchdog timer example. * apps/examples/tiff: Fix wrong path used for temporary file. + * apps/examples/touchscreen: Standardize the board-specific, touchscreen + initialization interfaces. diff --git a/apps/examples/touchscreen/tc.h b/apps/examples/touchscreen/tc.h index 173ed491f..f3e6ea634 100644 --- a/apps/examples/touchscreen/tc.h +++ b/apps/examples/touchscreen/tc.h @@ -110,28 +110,4 @@ * Public Function Prototypes ****************************************************************************/ -/**************************************************************************** - * Name: arch_tcinitialize() - * - * Description: - * Perform architecuture-specific initialization of the touchscreen - * hardware. This interface must be provided by all configurations - * using apps/examples/touchscreen - * - ****************************************************************************/ - -int arch_tcinitialize(int minor); - -/**************************************************************************** - * Name: arch_tcuninitialize() - * - * Description: - * Perform architecuture-specific un-initialization of the touchscreen - * hardware. This interface must be provided by all configurations - * using apps/examples/touchscreen - * - ****************************************************************************/ - -void arch_tcuninitialize(void); - #endif /* __APPS_EXAMPLES_TOUCHSCREEN_TC_H */ diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog index 3d1324759..0f7e5af3a 100644 --- a/nuttx/ChangeLog +++ b/nuttx/ChangeLog @@ -2726,5 +2726,9 @@ * include/cxx/cfcntl: Added std:: header file. * graphics/nxbe/nxbe_filltrapezoid.c and graphics/nxglib/fb/nxglib_filltrapezoid.c: Fix several errors in the trapezoid fill logic. + * include/nuttx/input/touchscreen.h, configs/hymini-stm32, configs/stm3240g-evel, + * configs/sam3u-ek, configs/sim, arch/sim/src/up_touchscreen.c, and + apps/examples/touchscreen: Standardize the board-specific, touchscreen + initialization interfaces. diff --git a/nuttx/arch/sim/src/up_touchscreen.c b/nuttx/arch/sim/src/up_touchscreen.c index 53e8e0d0d..a05b42c74 100644 --- a/nuttx/arch/sim/src/up_touchscreen.c +++ b/nuttx/arch/sim/src/up_touchscreen.c @@ -625,7 +625,7 @@ errout: ****************************************************************************/ /**************************************************************************** - * Name: sim_tcinitialize + * Name: arch_tcinitialize * * Description: * Configure the simulated touchscreen. This will register the driver as @@ -640,7 +640,7 @@ errout: * ****************************************************************************/ -int sim_tcinitialize(int minor) +int arch_tcinitialize(int minor) { FAR struct up_dev_s *priv = ( FAR struct up_dev_s *)&g_simtouchscreen; char devname[DEV_NAMELEN]; @@ -687,7 +687,7 @@ errout_with_priv: } /**************************************************************************** - * Name: sim_tcuninitialize + * Name: arch_tcuninitialize * * Description: * Uninitialized the simulated touchscreen @@ -700,7 +700,7 @@ errout_with_priv: * ****************************************************************************/ -void sim_tcuninitialize(void) +void arch_tcuninitialize(void) { FAR struct up_dev_s *priv = ( FAR struct up_dev_s *)&g_simtouchscreen; char devname[DEV_NAMELEN]; diff --git a/nuttx/configs/hymini-stm32v/src/hymini_stm32v-internal.h b/nuttx/configs/hymini-stm32v/src/hymini_stm32v-internal.h index 718220454..03dceea19 100644 --- a/nuttx/configs/hymini-stm32v/src/hymini_stm32v-internal.h +++ b/nuttx/configs/hymini-stm32v/src/hymini_stm32v-internal.h @@ -135,19 +135,6 @@ extern void weak_function stm32_spiinitialize(void); extern void weak_function stm32_usbinitialize(void); -#if defined(CONFIG_INPUT_ADS7843E) - -/************************************************************************************ - * Name: Touchscreen initialization - * - ************************************************************************************/ - -extern int arch_tcinitialize(int minor); - -extern void arch_tcuninitialize(void); - -#endif /* CONFIG_INPUT_ADS7843E */ - #endif /* __ASSEMBLY__ */ #endif /* __CONFIGS_HYMINI_STM32V_INTERNAL_H */ diff --git a/nuttx/configs/hymini-stm32v/src/up_ts.c b/nuttx/configs/hymini-stm32v/src/up_ts.c index 6c4decf7c..e5a779605 100644 --- a/nuttx/configs/hymini-stm32v/src/up_ts.c +++ b/nuttx/configs/hymini-stm32v/src/up_ts.c @@ -46,6 +46,7 @@ #include "stm32_internal.h" #include "hymini_stm32v-internal.h" +#include #include #if !defined(CONFIG_STM32_SPI1) @@ -120,11 +121,20 @@ static bool hymini_ts_pendown(FAR struct ads7843e_config_s *state) } /**************************************************************************** - * Name: arch_tcinitialize() + * Name: arch_tcinitialize * * Description: - * Perform architecture-specific initialization of the touchscreen. - * This function must be called directly from application. + * Each board that supports a touchscreen device must provide this function. + * This function is called by application-specific, setup logic to + * configure the touchscreen device. This function will register the driver + * as /dev/inputN where N is the minor device number. + * + * Input Parameters: + * minor - The input device minor number + * + * Returned Value: + * Zero is returned on success. Otherwise, a negated errno value is + * returned to indicate the nature of the failure. * ****************************************************************************/ @@ -132,12 +142,12 @@ int arch_tcinitialize(int minor) { FAR struct spi_dev_s *dev; - idbg("arch_tcinitialize: minor %d\n", minor); + idbg("minor %d\n", minor); dev = up_spiinitialize(1); if (!dev) { - idbg("arch_tcinitialize: Failed to initialize SPI bus\n"); + idbg("Failed to initialize SPI bus\n"); return -ENODEV; } @@ -149,11 +159,18 @@ int arch_tcinitialize(int minor) } /**************************************************************************** - * Name: arch_tcuninitialize() + * Name: arch_tcuninitialize * * Description: - * Perform architecture-specific un-initialization of the touchscreen - * hardware. This function must be called directly from application. + * Each board that supports a touchscreen device must provide this function. + * This function is called by application-specific, setup logic to + * uninitialize the touchscreen device. + * + * Input Parameters: + * None + * + * Returned Value: + * None. * ****************************************************************************/ diff --git a/nuttx/configs/sam3u-ek/src/up_touchscreen.c b/nuttx/configs/sam3u-ek/src/up_touchscreen.c index 0de367ec9..35ab43859 100644 --- a/nuttx/configs/sam3u-ek/src/up_touchscreen.c +++ b/nuttx/configs/sam3u-ek/src/up_touchscreen.c @@ -2,7 +2,7 @@ * configs/sam3u-ek/src/up_touchscreen.c * arch/arm/src/board/up_touchscreen.c * - * Copyright (C) 2011 Gregory Nutt. All rights reserved. + * Copyright (C) 2011-2012 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -43,6 +43,7 @@ #include #include #include +#include #include #include @@ -213,16 +214,27 @@ static bool tsc_pendown(FAR struct ads7843e_config_s *state) * Name: arch_tcinitialize * * Description: - * Initialize the touchscreen device + * Each board that supports a touchscreen device must provide this function. + * This function is called by application-specific, setup logic to + * configure the touchscreen device. This function will register the driver + * as /dev/inputN where N is the minor device number. + * + * Input Parameters: + * minor - The input device minor number + * + * Returned Value: + * Zero is returned on success. Otherwise, a negated errno value is + * returned to indicate the nature of the failure. * ****************************************************************************/ -int arch_tcinitialize(void) +int arch_tcinitialize(int minor) { FAR struct spi_dev_s *dev; int ret; - ivdbg("Initializing\n"); + idbg("minor %d\n", minor); + DEBUGASSERT(minor == 0); /* Configure and enable the ADS7843E interrupt pin as an input */ @@ -259,7 +271,15 @@ int arch_tcinitialize(void) * Name: arch_tcuninitialize * * Description: - * Un-initialize the touchscreen device + * Each board that supports a touchscreen device must provide this function. + * This function is called by application-specific, setup logic to + * uninitialize the touchscreen device. + * + * Input Parameters: + * None + * + * Returned Value: + * None. * ****************************************************************************/ diff --git a/nuttx/configs/sim/README.txt b/nuttx/configs/sim/README.txt index 3be43bf80..833ec58dc 100644 --- a/nuttx/configs/sim/README.txt +++ b/nuttx/configs/sim/README.txt @@ -342,7 +342,7 @@ nx11 CONFIG_SIM_TOUCHSCREEN=y Then you must also have some application logic that will call - sim_tcinitialize(0) to register the touchscreen driver. See + arch_tcinitialize(0) to register the touchscreen driver. See also configuration "touchscreen" NOTES: diff --git a/nuttx/configs/sim/src/up_touchscreen.c b/nuttx/configs/sim/src/up_touchscreen.c index 54d6d0cb3..ef3686288 100644 --- a/nuttx/configs/sim/src/up_touchscreen.c +++ b/nuttx/configs/sim/src/up_touchscreen.c @@ -143,10 +143,10 @@ int arch_tcinitialize(int minor) /* Finally, initialize the touchscreen simulation on the X window */ - ret = sim_tcinitialize(minor); + ret = arch_tcinitialize(minor); if (ret < 0) { - idbg("sim_tcinitialize failed: %d\n", ret); + idbg("arch_tcinitialize failed: %d\n", ret); goto errout_with_nx; } return OK; diff --git a/nuttx/configs/stm3240g-eval/nxwm/appconfig b/nuttx/configs/stm3240g-eval/nxwm/appconfig index 212e36680..6a5864fb1 100644 --- a/nuttx/configs/stm3240g-eval/nxwm/appconfig +++ b/nuttx/configs/stm3240g-eval/nxwm/appconfig @@ -33,8 +33,9 @@ # ############################################################################ -# The NSH Library -- NOTE: The NxWM unit must be installed in order -# to build this example. +# The NSH Library -- NOTE: The NxWM unit test must be installed at +# apps/external in order to build this example. See +# NxWidgets/UnitTests/README.txt for additional information CONFIGURED_APPS += system/readline CONFIGURED_APPS += nshlib diff --git a/nuttx/configs/stm3240g-eval/src/up_stmpe11.c b/nuttx/configs/stm3240g-eval/src/up_stmpe11.c index a9402eda7..e06e203e7 100644 --- a/nuttx/configs/stm3240g-eval/src/up_stmpe11.c +++ b/nuttx/configs/stm3240g-eval/src/up_stmpe11.c @@ -252,16 +252,29 @@ static void stmpe11_clear(FAR struct stmpe11_config_s *state) * Name: arch_tcinitialize * * Description: - * Initialize the touchscreen device + * Each board that supports a touchscreen device must provide this function. + * This function is called by application-specific, setup logic to + * configure the touchscreen device. This function will register the driver + * as /dev/inputN where N is the minor device number. + * + * Input Parameters: + * minor - The input device minor number + * + * Returned Value: + * Zero is returned on success. Otherwise, a negated errno value is + * returned to indicate the nature of the failure. * ****************************************************************************/ -int arch_tcinitialize(void) +int arch_tcinitialize(int minor) { #ifndef CONFIG_STMPE11_TSC_DISABLE FAR struct i2c_dev_s *dev; int ret; + idbg("minor %d\n", minor); + DEBUGASSERT(minor == 0); + /* Check if we are already initialized */ if (!g_stmpe11config.handle) @@ -312,7 +325,15 @@ int arch_tcinitialize(void) * Name: arch_tcuninitialize * * Description: - * Un-initialize the touchscreen device + * Each board that supports a touchscreen device must provide this function. + * This function is called by application-specific, setup logic to + * uninitialize the touchscreen device. + * + * Input Parameters: + * None + * + * Returned Value: + * None. * ****************************************************************************/ diff --git a/nuttx/drivers/input/stmpe11_tsc.c b/nuttx/drivers/input/stmpe11_tsc.c index a452d8798..29dc51d02 100644 --- a/nuttx/drivers/input/stmpe11_tsc.c +++ b/nuttx/drivers/input/stmpe11_tsc.c @@ -306,11 +306,16 @@ static inline int stmpe11_waitsample(FAR struct stmpe11_dev_s *priv, if (ret < 0) { + // Sample the errno (debug output could change it) + + int errval = errno; + /* If we are awakened by a signal, then we need to return * the failure now. */ - DEBUGASSERT(errno == EINTR); + idbg("sem_wait failed: %d\n", errval); + DEBUGASSERT(errval == EINTR); ret = -EINTR; goto errout; } diff --git a/nuttx/include/nuttx/input/touchscreen.h b/nuttx/include/nuttx/input/touchscreen.h index dce898fcc..04fc13dd7 100644 --- a/nuttx/include/nuttx/input/touchscreen.h +++ b/nuttx/include/nuttx/input/touchscreen.h @@ -1,7 +1,7 @@ /************************************************************************************ * include/nuttx/input/touchscreen.h * - * Copyright (C) 2011 Gregory Nutt. All rights reserved. + * Copyright (C) 2011-2012 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -134,11 +134,13 @@ extern "C" { #endif /**************************************************************************** - * Name: sim_tcinitialize + * Name: arch_tcinitialize * * Description: - * Configure the simulated touchscreen. This will register the driver as - * /dev/inputN where N is the minor device number. + * Each board that supports a touchscreen device must provide this function. + * This function is called by application-specific, setup logic to + * configure the touchscreen device. This function will register the driver + * as /dev/inputN where N is the minor device number. * * Input Parameters: * minor - The input device minor number @@ -149,15 +151,15 @@ extern "C" { * ****************************************************************************/ -#if defined(CONFIG_SIM_X11FB) && defined(CONFIG_SIM_TOUCHSCREEN) -EXTERN int sim_tcinitialize(int minor); -#endif +EXTERN int arch_tcinitialize(int minor); /**************************************************************************** - * Name: sim_tcuninitialize + * Name: arch_tcuninitialize * * Description: - * Uninitialized the simulated touchscreen + * Each board that supports a touchscreen device must provide this function. + * This function is called by application-specific, setup logic to + * uninitialize the touchscreen device. * * Input Parameters: * None @@ -167,9 +169,7 @@ EXTERN int sim_tcinitialize(int minor); * ****************************************************************************/ -#if defined(CONFIG_SIM_X11FB) && defined(CONFIG_SIM_TOUCHSCREEN) -EXTERN void sim_tcuninitialize(void); -#endif +EXTERN void arch_tcuninitialize(void); #undef EXTERN #ifdef __cplusplus -- cgit v1.2.3