Subversion Repositories openrisc

//==========================================================================

//

//      aaed2000_ts.c

//

//      Touchscreen driver for the Agilent aaed2000

//

//==========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####                                            

// -------------------------------------------                              

// This file is part of eCos, the Embedded Configurable Operating System.   

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under    

// the terms of the GNU General Public License as published by the Free     

// Software Foundation; either version 2 or (at your option) any later      

// version.                                                                 

//

// eCos is distributed in the hope that it will be useful, but WITHOUT      

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or    

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    

// for more details.                                                        

//

// You should have received a copy of the GNU General Public License        

// along with eCos; if not, write to the Free Software Foundation, Inc.,    

// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            

//

// As a special exception, if other files instantiate templates or use      

// macros or inline functions from this file, or you compile this file      

// and link it with other works to produce a work based on this file,       

// this file does not by itself cause the resulting work to be covered by   

// the GNU General Public License. However the source code for this file    

// must still be made available in accordance with section (3) of the GNU   

// General Public License v2.                                               

//

// This exception does not invalidate any other reasons why a work based    

// on this file might be covered by the GNU General Public License.         

// -------------------------------------------                              

// ####ECOSGPLCOPYRIGHTEND####                                              

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):    gthomas

// Contributors: gthomas

// Date:         2002-03-05

// Purpose:      

// Description:  Touchscreen driver for Agilent AAED2000

//

//####DESCRIPTIONEND####

//

//==========================================================================

#include <pkgconf/devs_touch_aaed2000.h>

#include <cyg/kernel/kapi.h>

#include <cyg/hal/hal_io.h>

#include <cyg/hal/hal_arch.h>

#include <cyg/hal/drv_api.h>

#include <cyg/hal/hal_intr.h>

#include <cyg/hal/aaed2000.h>

#include <cyg/infra/cyg_type.h>

#include <cyg/infra/cyg_ass.h>

#include <cyg/infra/diag.h>

#include <cyg/fileio/fileio.h>  // For select() functionality

static cyg_selinfo      ts_select_info;

static cyg_bool         ts_select_active;

#include <cyg/io/devtab.h>

/* ADS7846 flags */

#define ADS_START               (1 << 7)

#define ADS_MEASURE_Y           (0x01 << 4)

#define ADS_MEASURE_X           (0x05 << 4)

#define ADS_MODE_12_BIT         0

#define ADS_PD0                 0

// Misc constants

#define TS_INT (1<<0)

#define X_THRESHOLD 0x80

#define Y_THRESHOLD 0x80

// Functions in this module

static Cyg_ErrNo ts_read(cyg_io_handle_t handle,

                         void *buffer,

                         cyg_uint32 *len);

static cyg_bool  ts_select(cyg_io_handle_t handle,

                           cyg_uint32 which,

                           cyg_addrword_t info);

static Cyg_ErrNo ts_set_config(cyg_io_handle_t handle,

                               cyg_uint32 key,

                               const void *buffer,

                               cyg_uint32 *len);

static Cyg_ErrNo ts_get_config(cyg_io_handle_t handle,

                               cyg_uint32 key,

                               void *buffer,

                               cyg_uint32 *len);

static bool      ts_init(struct cyg_devtab_entry *tab);

static Cyg_ErrNo ts_lookup(struct cyg_devtab_entry **tab,

                           struct cyg_devtab_entry *st,

                           const char *name);

CHAR_DEVIO_TABLE(aaed2000_ts_handlers,

                 NULL,                                   // Unsupported write() function

                 ts_read,

                 ts_select,

                 ts_get_config,

                 ts_set_config);

CHAR_DEVTAB_ENTRY(aaed2000_ts_device,

                  CYGDAT_DEVS_TOUCH_AAED2000_NAME,

                  NULL,                                   // Base device name

                  &aaed2000_ts_handlers,

                  ts_init,

                  ts_lookup,

                  NULL);                                  // Private data pointer

struct _event {

    short button_state;

    short xPos, yPos;

    short _unused;

};

#define MAX_EVENTS CYGNUM_DEVS_TOUCH_AAED2000_EVENT_BUFFER_SIZE

static int   num_events;

static int   _event_put, _event_get;

static struct _event _events[MAX_EVENTS];

static bool _is_open = false;

#ifdef DEBUG_RAW_EVENTS

static unsigned char _ts_buf[512];

static int _ts_buf_ptr = 0;

#endif

#define STACK_SIZE CYGNUM_HAL_STACK_SIZE_TYPICAL

static char ts_scan_stack[STACK_SIZE];

static cyg_thread ts_scan_thread_data;

static cyg_handle_t ts_scan_thread_handle;

#define SCAN_FREQ 20 // Hz

//#define SCAN_FREQ 5 // Hz

#define SCAN_DELAY ((1000/SCAN_FREQ)/10)

typedef struct {

    short min;

    short max;

    short span;

} bounds;

static bounds xBounds = {1024, 0, 1024};

static bounds yBounds = {1024, 0, 1024};

static Cyg_ErrNo

ts_read(cyg_io_handle_t handle,

        void *buffer,

        cyg_uint32 *len)

{

    struct _event *ev;

    int tot = *len;

    unsigned char *bp = (unsigned char *)buffer;

    cyg_scheduler_lock();  // Prevent interaction with DSR code

    while (tot >= sizeof(struct _event)) {

        if (num_events > 0) {

            ev = &_events[_event_get++];

            if (_event_get == MAX_EVENTS) {

                _event_get = 0;

            }

            // Self calibrate

            if (ev->xPos > xBounds.max) xBounds.max = ev->xPos;

            if (ev->xPos < xBounds.min) xBounds.min = ev->xPos;

            if (ev->yPos > yBounds.max) yBounds.max = ev->yPos;

            if (ev->yPos < yBounds.min) yBounds.min = ev->yPos;

            if ((xBounds.span = xBounds.max - xBounds.min) <= 1) {

                xBounds.span = 1;

            }

            if ((yBounds.span = yBounds.max - yBounds.min) <= 1) {

                yBounds.span = 1;

            }

            // Scale values - done here so these potentially lengthy

            // operations take place outside of interrupt processing

#ifdef DEBUG

            diag_printf("Raw[%d,%d], X[%d,%d,%d], Y[%d,%d,%d]",

                        ev->xPos, ev->yPos,

                        xBounds.max, xBounds.min, xBounds.span,

                        yBounds.max, yBounds.min, yBounds.span);

#endif

            ev->xPos = 640 - (((xBounds.max - ev->xPos) * 640) / xBounds.span);

            ev->yPos = 480 - (((yBounds.max - ev->yPos) * 480) / yBounds.span);

#ifdef DEBUG

            diag_printf(", Cooked[%d,%d]\n",

                        ev->xPos, ev->yPos);

#endif

            memcpy(bp, ev, sizeof(*ev));

            bp += sizeof(*ev);

            tot -= sizeof(*ev);

            num_events--;

        } else {

            break;  // No more events

        }

    }

    cyg_scheduler_unlock(); // Allow DSRs again

    *len -= tot;

    return ENOERR;

}

static cyg_bool

ts_select(cyg_io_handle_t handle,

          cyg_uint32 which,

          cyg_addrword_t info)

{

    if (which == CYG_FREAD) {

        cyg_scheduler_lock();  // Prevent interaction with DSR code

        if (num_events > 0) {

            cyg_scheduler_unlock();  // Reallow interaction with DSR code

            return true;

        }

        if (!ts_select_active) {

            ts_select_active = true;

            cyg_selrecord(info, &ts_select_info);

        }

        cyg_scheduler_unlock();  // Reallow interaction with DSR code

    }

    return false;

}

static Cyg_ErrNo

ts_set_config(cyg_io_handle_t handle,

              cyg_uint32 key,

              const void *buffer,

              cyg_uint32 *len)

{

    return EINVAL;

}

static Cyg_ErrNo

ts_get_config(cyg_io_handle_t handle,

              cyg_uint32 key,

              void *buffer,

              cyg_uint32 *len)

{

    return EINVAL;

}

static bool

ts_init(struct cyg_devtab_entry *tab)

{

    cyg_uint32 _dummy;

    // Initialize SSP interface

#if 0

    while (*(volatile cyg_uint32 *)AAEC_SSP_SR & AAEC_SSP_SR_RNE) {

        _dummy = *(volatile cyg_uint32 *)AAEC_SSP_DR;  // Drain FIFO

    }

#endif

    *(volatile cyg_uint32 *)AAEC_SSP_CR0 =

        (1 << AAEC_SSP_CR0_SSE) |                    // SSP enable

        (37 << AAEC_SSP_CR0_SCR) |                   // Serial clock rate

        (AAEC_SSP_CR0_FRF_NAT << AAEC_SSP_CR0_FRF) | // MicroWire

        ((12-1) << AAEC_SSP_CR0_SIZE);               // 12 bit words

    *(volatile cyg_uint32 *)AAEC_SSP_CR1 =

        (1 << AAEC_SSP_CR1_FEN);                     // Enable FIFO

    *(volatile cyg_uint32 *)AAEC_SSP_CPSR = 2;       // Clock prescale

    *(volatile cyg_uint32 *)AAEC_PFDDR &= ~(1<<0);  // TS uses port F bit 0

    cyg_drv_interrupt_acknowledge(CYGNUM_HAL_INTERRUPT_TS);

    cyg_selinit(&ts_select_info);

    return true;

}

static cyg_uint32

read_ts(int axis)

{

    cyg_uint32 res;

    *(volatile cyg_uint32 *)AAEC_SSP_DR = (axis | ADS_START | ADS_MODE_12_BIT | ADS_PD0);

    *(volatile cyg_uint32 *)AAEC_SSP_DR = (axis | ADS_START | ADS_MODE_12_BIT);

    // Wait for data

    while ((*(volatile cyg_uint32 *)AAEC_SSP_SR & AAEC_SSP_SR_RNE) == 0);

    res = *(volatile cyg_uint32 *)AAEC_SSP_DR;  // ignore first datum

    // Wait for data

    while ((*(volatile cyg_uint32 *)AAEC_SSP_SR & AAEC_SSP_SR_RNE) == 0);

    res = *(volatile cyg_uint32 *)AAEC_SSP_DR;

    return res;

}

static void

ts_scan(cyg_addrword_t param)

{

    short lastX, lastY;

    short x, y;

    struct _event *ev;

    bool pen_down;

    diag_printf("Touch Screen thread started\n");

    // Discard the first sample - it's always 0

    x = read_ts(ADS_MEASURE_X);

    y = read_ts(ADS_MEASURE_Y);

    lastX = lastY = -1;

    pen_down = false;

    while (true) {

        cyg_thread_delay(SCAN_DELAY);

        if ((*(volatile cyg_uint32 *)AAEC_PFDR & TS_INT) == 0) {

            // Pen is down

            x = read_ts(ADS_MEASURE_X);

            y = read_ts(ADS_MEASURE_Y);

//            diag_printf("X = %x, Y = %x\n", x, y);

            if ((x < X_THRESHOLD) || (y < Y_THRESHOLD)) {

                // Ignore 'bad' samples

                continue;

            }

            lastX = x;  lastY = y;

            pen_down = true;

        } else {

            if (pen_down) {

                // Capture first 'up' event

                pen_down = false;

                x = lastX;

                y = lastY;

            } else {

                continue;  // Nothing new to report

            }

        }

        if (num_events < MAX_EVENTS) {

            num_events++;

            ev = &_events[_event_put++];

            if (_event_put == MAX_EVENTS) {

                _event_put = 0;

            }

            ev->button_state = pen_down ? 0x04 : 0x00;

            ev->xPos = x;

            ev->yPos = y;

            if (ts_select_active) {

                ts_select_active = false;

                cyg_selwakeup(&ts_select_info);

            }

        }

#ifdef DEBUG_RAW_EVENTS

        memcpy(&_ts_buf[_ts_buf_ptr], pkt->data, 8);

        _ts_buf_ptr += 8;

        if (_ts_buf_ptr == 512) {

            diag_printf("TS handler\n");

            diag_dump_buf(_ts_buf, 512);

            _ts_buf_ptr = 0;

        }

#endif

    }

}

static Cyg_ErrNo

ts_lookup(struct cyg_devtab_entry **tab,

          struct cyg_devtab_entry *st,

          const char *name)

{

    if (!_is_open) {

        _is_open = true;

        cyg_thread_create(1,                      // Priority

                          ts_scan,                // entry

                          0,                      // entry parameter

                          "Touch Screen scan",    // Name

                          &ts_scan_stack[0],      // Stack

                          STACK_SIZE,             // Size

                          &ts_scan_thread_handle, // Handle

                          &ts_scan_thread_data    // Thread data structure

        );

        cyg_thread_resume(ts_scan_thread_handle);    // Start it

    }

    return ENOERR;

}