Subversion Repositories igor

#include <avr/io.h>

#include <avr/interrupt.h>

#include "global.h"

#include <stdint.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "encdec.h"

#include "req.h"

#include "device.h"

#include "dispatch.h"

#include "dev/7seg.h"

#include "dev/spi.h"

#include "req.h"

#include "bus.h"

#include "uip/telnetd.h"

#include "uip/uip.h"

#include "uip/uip-conf.h"

#include "uip/uip_arp.h"

#include "uip/timer.h"

#include "uip/clock.h"

#include "dev/nic.h"

#include "dev/enc28j60-uip.c"

#define swap32(x)                       \

        ((((x) & 0xff000000) >> 24) |   \

        (((x) & 0x00ff0000) >>  8) |    \

        (((x) & 0x0000ff00) <<  8) |    \

        (((x) & 0x000000ff) << 24))

/* Peripherals we know of. */

//extern struct igordev igordev_boot;

extern struct igordev igordev_usart;

//extern struct igordev igordev_mmc;

//extern struct igordev igordev_kvga;

#define NUMDEV 1

struct igordev *idevs[NUMDEV];

// Currently seleted device

volatile uint32_t curdev;

// Last device performing interrupt.

volatile uint32_t intrdev;

volatile struct req *rqueue[MAXREQ];

static void     dispatch_request_perform(volatile struct req *);

void init_network_stuff(void);

void do_network_stuff(void);

#ifdef WITH_DEBUG

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)

#else

#define DEBUG(...)

#endif

/* Contains the dispatcher and its routines. */

int

main(void)

{

        struct idev_mgmt *imgmt;

        volatile struct req *req;

        uint32_t i, data;

        cli();

        curdev = DEVTYPE_BOOT;

        /* Initialize device structure with the different device types. */

//      idevs[DEVTYPE_BOOT] = &igordev_boot;

        idevs[DEVTYPE_SERIAL] = &igordev_usart;

//      idevs[DEVTYPE_STORAGE] = &igordev_mmc;

//      idevs[DEVTYPE_TERM] = &igordev_kvga;

        for (i = 0; i < MAXREQ; i++)

                rqueue[i] = NULL;

        init_fpgabus();

        req_init();

        _delay_ms(1);

//      display_init(); // 7Seg init

        DEBUG("Initializing devices\n");

        configure_spi(); //Must run before Ethernet/MMC init

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

                idevs[i]->init();

                imgmt = &idevs[i]->imgmt;

                imgmt->irqenable = 0;

                imgmt->baseaddr = 0;

                imgmt->curaddr = 0;

                imgmt->size = 0;

        }

        init_network_stuff();

        DEBUG("Done initializing devices\n");

        /* Boot load test. */

//      for (i = 0; i < 10; i++) {

//              display_char(i);

//              _delay_ms(50.0);

//      }

//      display_char(curdev);

/*

   BOOT BLOCK LAYOUT

   +---------------------------+----------+

   | Boot program size         | 4 bytes  |

   +---------------------------+----------+

   | Data area size            | 4 bytes  |

   +---------------------------+----------+

   |                           |          |

   |  Boot program             | Variable |

   |                           |          |

   +---------------------------+----------+

   |                           |          |

   |  Data area                | Variable |

   |                           |          |

   +---------------------------+----------+

 */

        /* Initialize the device boot block layout. */

        /* Read boot program size */

//      igordev_mmc.read(0, (uint8_t *)&data, 4);

//      igordev_boot.imgmt.size = swap32(data);

//      igordev_mmc.read(0, (uint8_t *)&data, 4);

//      igordev_mmc.imgmt.size = swap32(data);

        /* Set up segments. */

//      igordev_boot.imgmt.baseaddr = 8;

//      igordev_mmc.imgmt.baseaddr = 8 + igordev_boot.imgmt.size;

        _delay_ms(10);

        sei();

//      avr_online();

        while (1) {

                /* Look through all active requests. */

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

                        if (rqueue[i] == NULL)

                                continue;

                        req = rqueue[i];

                        dispatch_request_perform(req);

                        rqueue[i] = NULL;

                        req_free(req);

                }

                do_network_stuff();

        }

        return (0);

}

static void

dispatch_request_perform(volatile struct req *req)

{

        struct igordev *idev;

        struct idev_mgmt *imgmt;

        volatile struct req *nreq;

        uint32_t data, d;

        uint8_t num, osize, total, *ptr;

        idev = req->dev;

        imgmt = &idev->imgmt;

        switch (req->type) {

        case REQ_TYPE_READ:

                /* Wait until device is ready. */

                while (idev->read_status != IDEV_STATUS_OK);

                total = DATA_SIZE_TYPE(DATA_TYPE_DEV(req->devnum));

                ptr = (uint8_t *)&data;

                while (idev->read_status != IDEV_STATUS_ERROR) {

                        num = idev->read(imgmt->curaddr + imgmt->baseaddr, ptr,

                            total);

                        total -= num;

                        imgmt->curaddr += num;

                        if (total <= 0)

                                break;

                        ptr += num;

                }

                if (idev->read_status == IDEV_STATUS_ERROR)

                        return;

                if (req->flags & REQ_CALLBACK) {

                        d = encode_object(data, req->devnum);

                        DEBUG("Perform buffer read from main: '%c'\n", d);

                        fpga_finish_read(d);

                }

                break;

        case REQ_TYPE_WRITE:

                /* Wait until device is ready. */

                while (idev->write_status != IDEV_STATUS_OK);

                data = decode_object(fpga_delayed_write(), req->devnum, &osize);

                total = osize;

//              if (imgmt->curaddr + total >= imgmt->size)

//                      imgmt->curaddr = 0;

                /* Write until we have been able to write the data. */

                ptr = (uint8_t *)&data;

                while (idev->write_status != IDEV_STATUS_ERROR) {

                        num = idev->write(imgmt->curaddr + imgmt->baseaddr, ptr,

                            osize);

                        // Try and flush if we can't write

                        // XXX: Should count and report error if it doesn't

                        // help.

                        if (num == 0)

                                idev->flush();

                        total -= num;

                        imgmt->curaddr += num;

                        if (total <= 0)

                                break;

                        ptr += num;

                }

                if (idev->write_status == IDEV_STATUS_ERROR)

                        return;

                // Request a flush now that we finished the write.

                nreq = req_make(idev, REQ_TYPE_FLUSH, 0, req->devnum, NULL);

                if (nreq != NULL)

                        dispatch_request_notify(nreq);

                break;

        case REQ_TYPE_FLUSH:

                idev->flush();

                break;

        case REQ_TYPE_FUNC:

                req->func(idev->priv);

                break;

        }

}

/*

 * Notify the dispatcher of an I/O request. Note that the request is dropped if

 * there is no space for it in the queue!

 */

void

dispatch_request_notify(volatile struct req *req)

{

        uint8_t i;

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

                if (rqueue[i] == NULL) {

                        rqueue[i] = req;

                        return;

                }

        }

}

int8_t

dispatch_request_read(uint8_t addr, uint32_t *data)

{

        struct igordev *idev;

        struct idev_mgmt *imgmt;

        volatile struct req *req;

        uint32_t status;

        /* See what address we want to read from. */

        switch (addr) {

        case DEVICES:

                *data = OBJECT_NEW(TYPE_INT, NUMDEV);

                return (0);

        case CURDEV:

                *data = OBJECT_NEW(TYPE_INT, curdev);

                return (0);

        case CLI:

        case SAI:

                *data = 0;

                return (0);

        case INTRDEV:

                *data = OBJECT_NEW(TYPE_INT, intrdev);

                return (0);

        };

        /* Device-specific operation, so fetch currently enabled device. */

        idev = idevs[curdev];

        imgmt = &idev->imgmt;

        switch (addr) {

        /* Read an object from current device. */

        case OBJECT:

                break;

        /* Read lower 26 bits of current address from device. */

        case ADDR_L:

                *data = OBJECT_NEW(TYPE_INT, (uint32_t)(imgmt->curaddr >> 2));

                return (0);

        /* Read upper 26 bits of current address from device. */

        case ADDR_H:

                *data = OBJECT_NEW(TYPE_INT, (uint32_t)((imgmt->curaddr >> 2) >>

                    SIZE_INT));

                return (0);

        /* Read lower 26 bits of device size. */

        case SIZE_L:

                *data = OBJECT_NEW(TYPE_INT, (uint32_t)(imgmt->size >> 2));

                return (0);

        /* Read upper 26 bits of device size. */

        case SIZE_H:

                *data = OBJECT_NEW(TYPE_INT, (uint32_t)((imgmt->size >> 2) >>

                    SIZE_INT));

                return (0);

        /* Read status register of device. */

        case STATUS:

                status = (idev->read_status == IDEV_STATUS_OK);

                status |= ((idev->write_status == IDEV_STATUS_OK) <<

                    1);

                /* XXX: Error codes. */

                *data = OBJECT_NEW(TYPE_INT, status);

                return (0);

        /* Device identification. */

        case IDENTIFICATION:

                *data = OBJECT_NEW(TYPE_INT, idev->id);

                return (0);

        /* Read irq enable for device. */

        case IRQENABLE:

                *data = OBJECT_NEW(TYPE_INT, (uint32_t)imgmt->irqenable);

                return (0);

        default: /* XXX: Invalid address. */

                return (0);

        }

        DEBUG("Reading object of size %d\n", osize);

        /* Request for a read. */

        req = req_make(idev, REQ_TYPE_READ, REQ_CALLBACK, curdev, NULL);

        if (req == NULL)

                return (-1); /* XXX: Set error. */

        dispatch_request_notify(req);

        return (-1);

}

int8_t

dispatch_request_write(uint8_t addr, uint32_t data)

{

        struct igordev *idev;

        struct idev_mgmt *imgmt;

        volatile struct req *req;

        uint32_t status;

        uint64_t newaddr;

        uint8_t i; //num, osize;

        /* See what address we want to read from. */

        switch (addr) {

        /* Read-only */

        case DEVICES:

        case INTRDEV:

                return (0);

        case CURDEV:

                DEBUG("Setting current device\n");

                /* Should perhaps have some error signalling. */

                if (OBJECT_DATUM(data) >= NUMDEV)

                        return (0); /* Invalid device. */

                curdev = OBJECT_DATUM(data);

                display_char(curdev);

                return (0);

        case CLI:

                for (i = 0; i < NUMDEV; i++)

                        idevs[i]->imgmt.irqenable = 0;

                return (0);

        case SAI:

                for (i = 0; i < NUMDEV; i++)

                        idevs[i]->imgmt.irqenable = 1;

                return (0);

        };

        idev = idevs[curdev];

        imgmt = &idev->imgmt;

        switch (addr) {

        /* Read-only. */

        case SIZE_L:

        case SIZE_H:

        case IDENTIFICATION:

                return (0);

        /* Write an object from current device. */

        case OBJECT:

                break;

        /* Write lower 26 bits of current address from device. */

        case ADDR_L:

                newaddr = (OBJECT_DATUM(data) << 2) |

                    ((uint64_t)((uint32_t)(imgmt->curaddr >> BSIZE_INT)) <<

                    BSIZE_INT);

                // Only set it if it does not exceed the device space.

                if (newaddr + imgmt->baseaddr < imgmt->size)

                        imgmt->curaddr = newaddr;

                return (0);

        /* Read upper 26 bits of current address from device. */

        case ADDR_H:

                newaddr = ((OBJECT_DATUM(data) << 2) << BSIZE_INT) |

                    ((uint32_t)imgmt->curaddr);

                // Only set it if it does not exceed the device space.

                if (newaddr + imgmt->baseaddr < imgmt->size)

                        imgmt->curaddr = newaddr;

                return (0);

        /* Read status register of device. */

        case STATUS:

                /* Writing 0 resets the error codes. */

                status = OBJECT_DATUM(data);

                if (status != 0)

                        return (0); /* Not allowed. */

                /* XXX: reset error codes. */

                return (0);

        /* Set irq enable for device. */

        case IRQENABLE:

                imgmt->irqenable = OBJECT_DATUM(data);

                return (0);

        default: /* XXX: Invalid address. */

                return (0);

        }

        display_char(11);

        if ( idev == NULL )

            display_char(13);

        req = req_make(idev, REQ_TYPE_WRITE, REQ_CALLBACK, curdev, NULL);

        display_char(4);

        if (req == NULL) {

                display_char(5);

                return (-2); /* XXX: panic */

        }

        display_char(6);

        dispatch_request_notify(req);

        display_char(7);

        return (-1);

}

/* Read data from kvga and put it in usart output buffer. */

/*void

dispatch_vga_to_usart(void *args)

{

        uint8_t data[MAXBUFLEN];

        uint8_t num;

        num = igordev_kvga.read(1, data, MAXBUFLEN);

        igordev_usart.write(1, data, num);

        while (igordev_usart.write_status != IDEV_STATUS_OK);

}

*/

//Network stuff - cleanup and integrate into driver framework later

#define BUF ((struct uip_eth_hdr *)&uip_buf[0])

struct timer periodic_timer, arp_timer;

void init_network_stuff(void)

{

        uip_ipaddr_t ipaddr;

        clock_init(); //This also activates interrupts

        timer_set(&periodic_timer, (clock_time_t)(F_CPU / 2));

        timer_set(&arp_timer, (clock_time_t)(F_CPU * 10));

        network_init();

        uip_init();

        uip_ipaddr(ipaddr, 192,168,0,25);

        uip_sethostaddr(ipaddr);

        uip_ipaddr(ipaddr, 255,255,255,0);

        uip_setnetmask(ipaddr);

        //Init applications

        telnetd_init();

}

void do_network_stuff(void)

{

        int i;

        uip_len = network_read();

        if(uip_len > 0) {

                if(BUF->type == htons(UIP_ETHTYPE_IP)) {

                        uip_arp_ipin();

                        uip_input();

        /* If the above function invocation resulted in data that

           should be sent out on the network, the global variable

           uip_len is set to a value > 0. */

                        if(uip_len > 0) {

                                uip_arp_out();

                                network_send();

                        }

                } else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {

                        uip_arp_arpin();

        /* If the above function invocation resulted in data that

           should be sent out on the network, the global variable

           uip_len is set to a value > 0. */

                        if(uip_len > 0) {

                                network_send();

                        }

                }

        } else if(timer_expired(&periodic_timer)) {

                timer_reset(&periodic_timer);

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

                        uip_periodic(i);

        /* If the above function invocation resulted in data that

           should be sent out on the network, the global variable

           uip_len is set to a value > 0. */

                        if(uip_len > 0) {

                                uip_arp_out();

                                network_send();

                        }

                }

#if UIP_UDP

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

                        uip_udp_periodic(i);

        /* If the above function invocation resulted in data that

           should be sent out on the network, the global variable

           uip_len is set to a value > 0. */

                        if(uip_len > 0) {

                                uip_arp_out();

                                network_send();

                        }

                }

#endif /* UIP_UDP */

        /* Call the ARP timer function every 10 seconds. */

                if(timer_expired(&arp_timer)) {

                        timer_reset(&arp_timer);

                        uip_arp_timer();

                }

        }

}