Subversion Repositories openrisc

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

//

//        atmel_support.c

//

//        SA1110/iPAQ - Atmel micro-controller support routines

//

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

// ####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:          2001-02-27

// Description:   Simple Atmel support

//####DESCRIPTIONEND####

#include <pkgconf/system.h>

#include <pkgconf/hal.h>

#ifdef CYGPKG_REDBOOT

#include <redboot.h>

#endif

#include <cyg/infra/diag.h>

#include <cyg/hal/hal_if.h>       // Virtual vector functions

#include <cyg/hal/hal_io.h>       // IO macros

#include <cyg/hal/hal_arch.h>     // Register state info

#include <cyg/hal/hal_intr.h>     // HAL interrupt macros

#include <cyg/hal/hal_sa11x0.h>   // Board definitions

#include <cyg/hal/ipaq.h>

#include <cyg/hal/hal_cache.h>

#ifdef CYGPKG_IO

// Need to export interrupt driven interfaces

#include <cyg/hal/drv_api.h>

#define ATMEL_INT CYGNUM_HAL_INTERRUPT_UART1

static cyg_interrupt atmel_interrupt;

static cyg_handle_t  atmel_interrupt_handle;

#endif

#include <cyg/hal/atmel_support.h>        // Interfaces, commands

externC void *memcpy(void *, const void *, size_t);

struct sa11x0_serial {

  volatile cyg_uint32 utcr0;

  volatile cyg_uint32 utcr1;

  volatile cyg_uint32 utcr2;

  volatile cyg_uint32 utcr3;

  volatile cyg_uint32 pad0010;

  volatile cyg_uint32 utdr;

  volatile cyg_uint32 pad0018;

  volatile cyg_uint32 utsr0;

  volatile cyg_uint32 utsr1;

};

#define ATMEL_PUTQ_SIZE 32

unsigned char atmel_putq[ATMEL_PUTQ_SIZE];

int atmel_putq_put, atmel_putq_get;

bool atmel_use_ints;

void

atmel_putc(unsigned char c)

{

    atmel_putq[atmel_putq_put++] = c;

    if (atmel_putq_put == ATMEL_PUTQ_SIZE) {

        atmel_putq_put = 0;

    }

}

static atmel_handler *handlers[NUM_ATMEL_CMDS];

static void

null_handler(atmel_pkt *pkt)

{

    diag_printf("Atmel - packet ignored: %x\n", pkt->data[0]);

    diag_dump_buf(pkt->data, 16);

}

//

// Register a handler for a particular packet type

//

void

atmel_register(int cmd, atmel_handler *fun)

{

    handlers[cmd] = fun;

}

//

// This routine is called to process an input character from the

// Atmel micro-controller.  Since command packets are multiple

// characters, this routine has to keep state for the packet.  Once

// a complete packet is received, the appropriate handler function

// will be called (if the checksum matches)

//

static void

atmel_in(unsigned char ch)

{

    static atmel_pkt pkt;

    static unsigned char cksum;

    static bool sof = false;

    if (!sof) {

        // Wait for start of packet (SOF)

        if (ch != SOF) {

            return;  // Just ignore out of order characters

        }

        sof = true;

        pkt.size = 0;

        return;

    }

    if (pkt.size == 0) {

        // First byte of packet - command+length;

        pkt.len = (ch & 0x0F) + 1;

        cksum = 0;

    }

    pkt.data[pkt.size++] = ch;

    if (pkt.size > pkt.len) {

        // End of packet data

        if (cksum == ch) {

            (*handlers[pkt.data[0] >> 4])(&pkt);

        }

        sof = false;

    } else {

        cksum += ch;

    }

}

//

// This [internal] routine is used to handle data from the Atmel micro-controller

//

static void

atmel_poll(void)

{

    volatile struct sa11x0_serial *base = (volatile struct sa11x0_serial *)SA11X0_UART1_BASE;

    unsigned char ch;

    while ((base->utsr1 & SA11X0_UART_RX_FIFO_NOT_EMPTY) != 0) {

        ch = (char)base->utdr;

        atmel_in(ch);

    }

}

//

// This [internal] routine is used to send data to the Atmel micro-controller

//

static void

atmel_flush(void)

{

    volatile struct sa11x0_serial *base = (volatile struct sa11x0_serial *)SA11X0_UART1_BASE;

#ifdef CYGPKG_IO

    cyg_drv_isr_lock();

#endif

    while (atmel_putq_get != atmel_putq_put) {

        if ((base->utsr1 & SA11X0_UART_TX_FIFO_NOT_FULL) == 0) {

            // Wait forever if in non-interrupt mode

            if (atmel_use_ints) {

                break;

            }

        } else {

            base->utdr = atmel_putq[atmel_putq_get++];

            if (atmel_putq_get == ATMEL_PUTQ_SIZE) {

                atmel_putq_get = 0;

            }

        }

    }

#ifdef CYGPKG_IO

    cyg_drv_isr_unlock();

#endif

}

#ifdef CYGPKG_IO

// Low level interrupt handler (ISR)

static cyg_uint32

atmel_ISR(cyg_vector_t vector, cyg_addrword_t data)

{

    cyg_drv_interrupt_mask(vector);

    cyg_drv_interrupt_acknowledge(vector);

    return CYG_ISR_CALL_DSR;  // Cause DSR to be run

}

// High level interrupt handler (DSR)

static void

atmel_DSR(cyg_vector_t vector, cyg_ucount32 count, cyg_addrword_t data)

{

    volatile struct sa11x0_serial *base = (volatile struct sa11x0_serial *)SA11X0_UART1_BASE;

    unsigned int stat0 = base->utsr0;

    if (stat0 & SA11X0_UART_TX_SERVICE_REQUEST) {

        atmel_flush();

    }

    if (stat0 & (SA11X0_UART_RX_SERVICE_REQUEST|SA11X0_UART_RX_IDLE)) {

        atmel_poll();

        base->utsr0 = SA11X0_UART_RX_IDLE;  // Need to clear this manually

    }

    cyg_drv_interrupt_unmask(vector);

}

//

// Connect/disconnect interrupt processing

//

void

atmel_interrupt_mode(bool enable)

{

    volatile struct sa11x0_serial *base = (volatile struct sa11x0_serial *)SA11X0_UART1_BASE;

    if (enable) {

        // Enable the receiver (with interrupts) and the transmitter.

        base->utcr3 = SA11X0_UART_RX_ENABLED |

                      SA11X0_UART_TX_ENABLED |

                      SA11X0_UART_RX_FIFO_INT_ENABLED;

        cyg_drv_interrupt_unmask(ATMEL_INT);

    } else {

        cyg_drv_interrupt_mask(ATMEL_INT);

    }

    atmel_use_ints = enable;

}

#endif

//

// Set up the Atmel micro-controller environment

//

void

atmel_init(void)

{

    volatile struct sa11x0_serial *base = (volatile struct sa11x0_serial *)SA11X0_UART1_BASE;

    cyg_uint32 brd;

    int i;

    static bool _init = false;

    if (_init) return;

    // Disable Receiver and Transmitter (clears FIFOs)

    base->utcr3 = SA11X0_UART_RX_DISABLED | SA11X0_UART_TX_DISABLED;

    // Clear sticky (writable) status bits.

    base->utsr0 = SA11X0_UART_RX_IDLE | SA11X0_UART_RX_BEGIN_OF_BREAK |

                  SA11X0_UART_RX_END_OF_BREAK;

    // Set UART to 8N1 (8 data bits, no partity, 1 stop bit)

    base->utcr0 = SA11X0_UART_PARITY_DISABLED | SA11X0_UART_STOP_BITS_1 |

                  SA11X0_UART_DATA_BITS_8;

    // Set the desired baud rate.

    brd = SA11X0_UART_BAUD_RATE_DIVISOR(115200);

    base->utcr1 = (brd >> 8) & SA11X0_UART_H_BAUD_RATE_DIVISOR_MASK;

    base->utcr2 = brd & SA11X0_UART_L_BAUD_RATE_DIVISOR_MASK;

    // Enable the receiver and the transmitter.

    base->utcr3 = SA11X0_UART_RX_ENABLED | SA11X0_UART_TX_ENABLED;

    // Set up character queues

    atmel_putq_put = atmel_putq_get = 0;

    atmel_use_ints = false;

    // Set up handlers

    for (i = 0;  i < NUM_ATMEL_CMDS;  i++) {

        atmel_register(i, null_handler);

    }

#ifdef CYGPKG_IO

    cyg_drv_interrupt_create(ATMEL_INT,

                             99,                     // Priority - unused

                             (cyg_addrword_t)base,   // Data item passed to interrupt handler

                             atmel_ISR,

                             atmel_DSR,

                             &atmel_interrupt_handle,

                             &atmel_interrupt);

    cyg_drv_interrupt_attach(atmel_interrupt_handle);

#endif

    _init = true;

}

static void

atmel_pkt_send(atmel_pkt *pkt)

{

    int i;

    for (i = 0;  i < pkt->len;  i++) {

        atmel_putc(pkt->data[i]);

    }

    atmel_flush();

}

bool

atmel_send(int cmd, unsigned char *data, int len)

{

    atmel_pkt pkt;

    unsigned char cksum, *dp;

    int i;

    dp = pkt.data;

    *dp++ = SOF;

    *dp++ = cksum = (cmd << 4) | len;

    for (i = 0;  i < len;  i++) {

        *dp++ = data[i];

        cksum += data[i];

    }

    *dp = cksum;

    pkt.len = len + 3;

    atmel_pkt_send(&pkt);

    return true;

}

#define MAX_TS_EVENTS      32

static struct ts_event ts_event_list[MAX_TS_EVENTS];

static int num_ts_events = 0;

static int ts_event_get, ts_event_put;

static void

ts_event_handler(atmel_pkt *pkt)

{

    unsigned char *buf = pkt->data;

    static bool up = true;

    static int down_count = 0;

    struct ts_event *tse;

    if (num_ts_events == MAX_TS_EVENTS) {

        return;

    }

    if ((buf[0] & 0x0F) == 0) {

        // Stylus up

        up = true;

        down_count = 0;

        tse = &ts_event_list[ts_event_put++];

        if (ts_event_put == MAX_TS_EVENTS) {

            ts_event_put = 0;

        }

        num_ts_events++;

        tse->x = (buf[1] << 8) | buf[2];

        tse->y = (buf[3] << 8) | buf[4];

        tse->up = up;

    } else {

        up = false;

        if (down_count++ == 0) {

            // First 'down' event

        } else {

        }

        {

            tse = &ts_event_list[ts_event_put++];

            if (ts_event_put == MAX_TS_EVENTS) {

                ts_event_put = 0;

            }

            num_ts_events++;

            tse->x = (buf[1] << 8) | buf[2];

            tse->y = (buf[3] << 8) | buf[4];

            tse->up = up;

        }

    }

}

bool

ts_get_event(struct ts_event *tse)

{

    static bool _init = false;

    if (!_init) {

        atmel_register(ATMEL_CMD_TOUCH, ts_event_handler);

        atmel_register(ATMEL_CMD_UNKNOWN, ts_event_handler);

        _init = true;

    }

    if (num_ts_events == 0) {

        atmel_poll();

    }

    if (num_ts_events) {

        num_ts_events--;

        memcpy(tse, &ts_event_list[ts_event_get++], sizeof(*tse));

        if (ts_event_get == MAX_TS_EVENTS) {

            ts_event_get = 0;

        }

        return true;

    } else {

        return false;

    }

}

#define MAX_KEY_EVENTS     8

static struct key_event key_event_list[MAX_KEY_EVENTS];

static int num_key_events = 0;

static int key_event_get, key_event_put;

static void

kbd_event_handler(atmel_pkt *pkt)

{

    unsigned char *buf = pkt->data;

    struct key_event *ke;

    if (num_key_events == MAX_KEY_EVENTS) {

        return;

    }

//    printf("Keybd = %x\n", buf[1]);

    ke = &key_event_list[key_event_put++];

    if (key_event_put == MAX_KEY_EVENTS) {

        key_event_put = 0;

    }

    ke->button_info = buf[1];

    num_key_events++;

}

bool

key_get_event(struct key_event *ke)

{

    static bool _init = false;

    if (!_init) {

        atmel_register(ATMEL_CMD_KEYBD, kbd_event_handler);

        _init = true;

    }

    if (num_key_events == 0) {

        atmel_poll();

    }

    if (num_key_events) {

        num_key_events--;

        memcpy(ke, &key_event_list[key_event_get++], sizeof(*ke));

        if (key_event_get == MAX_KEY_EVENTS) {

            key_event_get = 0;

        }

        return true;

    } else {

        return false;

    }

}

#ifdef CYGPKG_REDBOOT

void

atmel_check(bool is_idle)

{

}

RedBoot_idle(atmel_check, RedBoot_BEFORE_NETIO);

#endif