Removed old code.

ipac-base-27JAN2011/Makefile

@@ -1,93 +0,0 @@
-TARGET	= ipac
-
-# Application source en include includes
-SRC_DIR	= ./source
-INC_DIR = ./include
-
-# NutOS location (includes and libs)
-NUT_INC = c:/ethernut-4.3.3/nut/include
-NUT_BUILD_INC = c:/ethernut-4.3.3/build/gcc/atmega2561/lib/include
-NUT_LIB_DIR = c:/ethernut-4.3.3/build/gcc/atmega2561/lib
-
-# WinAvr includes
-AVR_INC = c:/winavr/avr/include
-
-
-# Compiler, assembler & linker (flags)
-CC		= 	avr-gcc
-CFLAGS	= 	-mmcu=atmega2561 -Os -Wall -Wstrict-prototypes -DNUT_CPU_FREQ=14745600 \
-			-D__HARVARD_ARCH__ -DNUTOS_VERSION=433 \
-			-Wa,-ahlms=$(SRC_DIR)/$*lst
-ASFLAGS = 	-mmcu=atmega2561 -I. -x assembler-with-cpp -Wa,-ahlms=$(SRC_DIR)/$*lst,-gstabs 
-LDFLAGS	=	-mmcu=atmega2561 -Wl,--defsym=main=0,-Map=TIStreamer.map,--cref
-
-
-# =================================================================================
-# Source files
-CFILES =        main.c			\
-				uart0driver.c	\
-				log.c			\
-                led.c			\
-				keyboard.c		\
-				display.c		\
-                vs10xx.c		\
-                remcon.c		\
-                watchdog.c		\
-				mmc.c			\
-				spidrv.c        \
-                mmcdrv.c        \
-                fat.c			\
-				flash.c			\
-				rtc.c
-			
-				
-# Header files.
-HFILES =        display.h        keyboard.h              \
-                led.h                            \
-                portio.h         remcon.h         log.h          \
-                system.h                 settings.h     \
-                                  inet.h         \
-                platform.h       version.h        update.h       \
-                           uart0driver.h    typedefs.h     \
-                       vs10xx.h         audio.h        \
-                watchdog.h       mmc.h             \
-                flash.h          spidrv.h         command.h      \
-                parse.h          mmcdrv.h         fat.h          \
-                fatdrv.h         flash.h	  	rtc.h
-
-
-# Alle source files in de ./source dir
-SRCS =	$(addprefix $(SRC_DIR)/,$(CFILES))
-OBJS = 	$(SRCS:.c=.o)
-
-NUT_LIBS = $(NUT_LIB_DIR)/nutinit.o -lnutpro -lnutnet -lnutpro -lnutfs -lnutos -lnutdev -lnutarch -lnutnet -lnutcrt -lnutdev
-
-
-# Alle includes (header files) in de ./header dir
-INCS =	$(addprefix $(INC_DIR)/,$(HFILES))
-
-# Linking rule. All *.o to elf file. Then convert to *.hex
-$(TARGET):	$(OBJS)
-	$(CC) $(OBJS) $(LDFLAGS) -L$(NUT_LIB_DIR) $(NUT_LIBS) -o $@.elf
-	avr-objcopy -O ihex $@.elf $@.hex
-#	hex2bin -ebin $@.hex
-
-# Compiling the objs's. avr-gcc autocalls assembler	
-$(SRC_DIR)/%o:	$(SRC_DIR)/%c 
-	$(CC) -c $< $(CFLAGS) -I$(INC_DIR) -I$(NUT_INC) -I$(AVR_INC) -o $@
-
-	
-all: $(TARGET)
-
-debug:
-	
-	@echo $(OBJS)
-
-
-.PHONY: clean
-clean:
-	-rm -f $(OBJS)
-	-rm -f $(SRCS:.c=.lst)
-	-rm -f *.hex *.elf *.map *.bin
-
-

ipac-base-27JAN2011/include/display.h

@@ -1,63 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR100
- * [MODULE]     Display
- * [TITLE]      display header file
- * [FILE]       display.h
- * [VSN]        1.0
- * [CREATED]    030414
- * [LASTCHNGD]  030414
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    API and gobal defines for display module
- * ======================================================================== */
-
-#ifndef _Display_H
-#define _Display_H
-
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-#define DISPLAY_SIZE                16
-#define NROF_LINES                  2
-#define MAX_SCREEN_CHARS            (NROF_LINES*DISPLAY_SIZE)
-
-#define LINE_0                      0
-#define LINE_1                      1
-
-#define FIRSTPOS_LINE_0             0
-#define FIRSTPOS_LINE_1             0x40
-
-
-#define LCD_BACKLIGHT_ON            1
-#define LCD_BACKLIGHT_OFF           0
-
-#define ALL_ZERO          			0x00      // 0000 0000 B
-#define WRITE_COMMAND     			0x02      // 0000 0010 B
-#define WRITE_DATA        			0x03      // 0000 0011 B
-#define READ_COMMAND      			0x04      // 0000 0100 B
-#define READ_DATA         			0x06      // 0000 0110 B
-
-
-/*-------------------------------------------------------------------------*/
-/* typedefs & structs                                                      */
-/*-------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-extern void LcdChar(char);
-extern void LcdBackLight(u_char);
-extern void LcdInit(void);
-extern void LcdLowLevelInit(void);
-
-#endif /* _Display_H */
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-
-
-
-

ipac-base-27JAN2011/include/fat.h

@@ -1,119 +0,0 @@
-/****************************************************************************
-*  This file is part of the AVRIDE device driver.
-*
-*  Copyright (c) 2002-2004 by Michael Fischer. All rights reserved.
-*
-*  Redistribution and use in source and binary forms, with or without 
-*  modification, are permitted provided that the following conditions 
-*  are met:
-*  
-*  1. Redistributions of source code must retain the above copyright 
-*     notice, this list of conditions and the following disclaimer.
-*  2. Redistributions in binary form must reproduce the above copyright
-*     notice, this list of conditions and the following disclaimer in the 
-*     documentation and/or other materials provided with the distribution.
-*  3. Neither the name of the author nor the names of its contributors may 
-*     be used to endorse or promote products derived from this software 
-*     without specific prior written permission.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
-*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
-*  THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
-*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
-*  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
-*  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
-*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
-*  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
-*  SUCH DAMAGE.
-*
-****************************************************************************
-*  History:
-*
-*  14.12.02  mifi   First Version 
-*  18.01.03  mifi   Change Licence from GPL to BSD
-*  25.01.03  mifi   Change FAT32Init 
-*                   New function FAT32MountDrive and FAT32UnMountDrive
-*                   Remove FAT32_MAX_FILES, a file handle will be 
-*                   allocated by NutHeapAlloc, therefore we have no
-*                   restrictions about the count of the open file handle.
-*                   (Only by available memory)
-*  27.01.03  mifi   Rename all FAT32xxx function to FATxxx.
-*
-*  28.01.03  mifi   Start porting to Nut/OS 3.X.X
-*  29.06.03  mifi   First ATAPI-Version
-*  24.07.04  mifi   Some changes to support more than one drive (datanut)
-*  25.07.04  mifi   Add support for the PCMCIA_11 hardware.
-*  27.07.04  mifi   Add support for IOCTL function
-****************************************************************************/
-#ifndef __FAT_H__
-#define __FAT_H__
-
-#include <sys/device.h>
-#include "fatdrv.h"
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-
-/*
- * Device mode
- */
-#define FAT_MODE_IDE_HD           0x0000
-#define FAT_MODE_IDE_CF           0x0001
-#define FAT_MODE_MEM_CF           0x0002
-#define FAT_MODE_DATANUT_CF       0x0003
-#define FAT_MODE_DATANUT_IDECF    0x0004
-#define FAT_MODE_DATANUT_IDEWLAN  0x0005
-#define FAT_MODE_USB              0x0006
-#define FAT_MODE_MMC              0x0007
-
-
-/*
- * If the function should be 
- * supported, set it to 1
- */
-#define FAT_SUPPORT_FORMAT        1
-
-/*
- * IOCTL-Function
- */
-#define FAT_IOCTL_QUICK_FORMAT    0x1000
-
-/*-------------------------------------------------------------------------*/
-/* global types                                                            */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* global macros                                                           */
-/*-------------------------------------------------------------------------*/
-#define FAT_IOCTL(_a,_b,_c)   ((NUTDEVICE *)_a)->dev_ioctl((_a), (_b), (_c))
-
-#define FATQuickFormat(_a)    FAT_IOCTL(_a, FAT_IOCTL_QUICK_FORMAT, NULL)
- 
-
-/*-------------------------------------------------------------------------*/
-/* Prototypes                                                              */
-/*-------------------------------------------------------------------------*/
-extern NUTDEVICE devFAT;
-
-#if (FAT_USE_IDE_INTERFACE >= 1)
-extern NUTDEVICE devFATCF;
-extern NUTDEVICE devFATIDE0;
-extern NUTDEVICE devFATIDE1;
-#endif
-
-#if (FAT_USE_USB_INTERFACE >= 1)
-extern NUTDEVICE devFATUSB0;
-#endif
-
-#if (FAT_USE_MMC_INTERFACE >= 1)
-extern NUTDEVICE devFATMMC0;
-extern void FATRelease(void);
-
-#endif
-
-
-#endif                          /* !__FAT_H__ */

ipac-base-27JAN2011/include/fatdrv.h

@@ -1,153 +0,0 @@
-/****************************************************************************
-*  This file is part of the FAT device driver.
-*
-*  Copyright (c) 2002-2004 by Michael Fischer. All rights reserved.
-*
-*  Redistribution and use in source and binary forms, with or without 
-*  modification, are permitted provided that the following conditions 
-*  are met:
-*  
-*  1. Redistributions of source code must retain the above copyright 
-*     notice, this list of conditions and the following disclaimer.
-*  2. Redistributions in binary form must reproduce the above copyright
-*     notice, this list of conditions and the following disclaimer in the 
-*     documentation and/or other materials provided with the distribution.
-*  3. Neither the name of the author nor the names of its contributors may 
-*     be used to endorse or promote products derived from this software 
-*     without specific prior written permission.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
-*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
-*  THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
-*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
-*  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
-*  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
-*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
-*  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
-*  SUCH DAMAGE.
-*
-****************************************************************************
-*  History:
-*
-*  03.08.04  mifi   First Version
-****************************************************************************/
-#ifndef __FATDRV_H__
-#define __FATDRV_H__
-
-#include "typedefs.h"
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-
-/*
- * Define the hardware here
- */
-#define FAT_USE_IDE_INTERFACE     0 
-#define FAT_USE_USB_INTERFACE     0
-#define FAT_USE_MMC_INTERFACE     1 
-
-
-#if (FAT_USE_IDE_INTERFACE >= 1)
-#include "ide.h"
-
-#define HW_SUPPORT_WRITE  IDE_SUPPORT_WRITE
-#define HW_SUPPORT_ATAPI  IDE_SUPPORT_ATAPI
-
-#define HW_OK             IDE_OK
-#define HW_ERROR          IDE_ERROR
-
-#define HW_DRIVE_C        IDE_DRIVE_C
-#define HW_DRIVE_D        IDE_DRIVE_D
-#define HW_DRIVE_E        IDE_DRIVE_E
-
-#define HW_SECTOR_SIZE    IDE_SECTOR_SIZE
-#endif /* (FAT_USE_IDE_INTERFACE >= 1) */ 
-
-
-#if (FAT_USE_USB_INTERFACE >= 1)
-#include "usbdrv.h"
-
-#define HW_SUPPORT_WRITE  USB_SUPPORT_WRITE
-#define HW_SUPPORT_ATAPI  USB_SUPPORT_ATAPI
-
-#define HW_OK             USB_OK
-#define HW_ERROR          USB_ERROR
-
-#define HW_DRIVE_C        USB_DRIVE_C
-#define HW_DRIVE_D        USB_DRIVE_D
-#define HW_DRIVE_E        USB_DRIVE_E
-
-#define HW_SECTOR_SIZE    USB_SECTOR_SIZE
-
-#endif /* (FAT_USE_USB_INTERFACE >= 1) */
-
-
-#if (FAT_USE_MMC_INTERFACE >= 1)
-#include "mmcdrv.h"
-
-#define HW_SUPPORT_WRITE  MMC_SUPPORT_WRITE
-#define HW_SUPPORT_ATAPI  MMC_SUPPORT_ATAPI
-
-#define HW_OK             MMC_OK
-#define HW_ERROR          MMC_ERROR
-
-#define HW_DRIVE_C        MMC_DRIVE_C
-#define HW_DRIVE_D        MMC_DRIVE_C
-#define HW_DRIVE_E        MMC_DRIVE_C
-
-#define HW_SECTOR_SIZE    MMC_SECTOR_SIZE
-
-#endif /* (FAT_USE_MMC_INTERFACE >= 1) */
-
-/*-------------------------------------------------------------------------*/
-/* global types                                                            */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* global macros                                                           */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* Prototypes                                                              */
-/*-------------------------------------------------------------------------*/
-#if (FAT_USE_IDE_INTERFACE >= 1)
-#define HWInit              IDEInit
-#define HWMountAllDevices   IDEMountAllDevices
-#define HWGetSectorSize     IDEGetSectorSize
-#define HWIsCDROMDevice     IDEIsCDROMDevice
-#define HWIsZIPDevice       IDEIsZIPDevice
-#define HWUnMountDevice     IDEUnMountDevice
-#define HWGetTotalSectors   IDEGetTotalSectors
-#define HWReadSectors       IDEReadSectors  
-#define HWWriteSectors      IDEWriteSectors
-#endif /* (FAT_USE_IDE_INTERFACE >= 1) */ 
-
-#if (FAT_USE_USB_INTERFACE >= 1)
-#define HWInit              USBInit
-#define HWMountAllDevices   USBMountAllDevices
-#define HWGetSectorSize     USBGetSectorSize
-#define HWIsCDROMDevice     USBIsCDROMDevice
-#define HWIsZIPDevice       USBIsZIPDevice
-#define HWUnMountDevice     USBUnMountDevice
-#define HWGetTotalSectors   USBGetTotalSectors
-#define HWReadSectors       USBReadSectors  
-#define HWWriteSectors      USBWriteSectors
-#endif /* (FAT_USE_USB_INTERFACE == 1) */
-
-#if (FAT_USE_MMC_INTERFACE >= 1)
-#define HWInit              MMCInit
-#define HWMountAllDevices   MMCMountAllDevices
-#define HWGetSectorSize     MMCGetSectorSize
-#define HWIsCDROMDevice     MMCIsCDROMDevice
-#define HWIsZIPDevice       MMCIsZIPDevice
-#define HWUnMountDevice     MMCUnMountDevice
-#define HWGetTotalSectors   MMCGetTotalSectors
-#define HWReadSectors       MMCReadSectors  
-#define HWWriteSectors      MMCWriteSectors
-#endif /* (FAT_USE_MMC_INTERFACE == 1) */
-
-#endif /* !__FATDRV_H__ */

ipac-base-27JAN2011/include/flash.h

@@ -1,68 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     Flash
- * [TITLE]      Routines for Atmel AT45 serial dataflash memory chips.
- * [FILE]       flash.c
- * [VSN]        1.0
- * [CREATED]    11042007
- * [LASTCHNGD]  11042007
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    contains all interface- and low-level routines to
- *              read/write/delete blocks in the serial DataFlash (AT45DBXX)
- * ======================================================================== */
-#ifndef _Flash_H
-#define _Flash_H
-
-
-#include <sys/types.h>
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-
-/*
- *  next defines have a 1-1 relationship to the index in the 'at45_devt'
- *  array, so do not change the values
- */
-#define AT45DB011B  0
-#define AT45DB021B  1
-#define AT45DB041B  2
-#define AT45DB081B  3
-#define AT45DB0161B 4
-#define AT45DB0321B 5
-#define AT45DB0642  6
-
-/*-------------------------------------------------------------------------*/
-/* typedefs & structs                                                      */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/*  Global variables                                                       */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-
-extern int At45dbSendCmd(u_char op, u_long parm, int len, CONST void *tdata, void *rdata, int datalen);
-extern u_char At45dbGetStatus(void);
-extern int At45dbWaitReady(u_long tmo, int poll);
-extern int At45dbInit(void);
-extern int At45dbPageErase(u_int off);
-extern int At45dbChipErase(void);
-extern int At45dbPageRead(u_long pgn, void *data, u_int len);
-extern int At45dbPageWrite(u_long pgn, CONST void *data, u_int len);
-
-#ifdef USE_FLASH_PARAM_PAGE
-extern int At45dbParamRead(u_int pos, void *data, u_int len);
-extern int At45dbParamWrite(u_int pos, CONST void *data, u_int len);
-#endif // USE_FLASH_PARAM_PAGE
-
-#endif /* _Flash_H */
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-
-
-
-
-

ipac-base-27JAN2011/include/keyboard.h

@@ -1,112 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     Keyboard module
- * [TITLE]      keyboard module source file
- * [FILE]       keyboard.h
- * [VSN]        1.0
- * [CREATED]    28 july 2003
- * [LASTCHNGD]  18 august 2003
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    Keyboard routines
- * ======================================================================== */
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-#define KB_COL_0       3
-#define KB_COL_1       4
-#define KB_COL_2       3
-#define KB_COL_3       2
-
-#define KB_ROW_0       0
-#define KB_ROW_1       1
-#define KB_ROW_2       2
-#define KB_ROW_3       3
-
-#define KB_ROW_MASK    0xF0
-
-#define KB_OK          0x00
-#define KB_ERROR       0x01
-
-/* state machine defines -------------------------------------------------- */
-#define KB_IDLE        0x00
-#define KB_KEY         0x01
-#define KB_VALID       0x02
-#define KB_RELEASE     0x03
-
-#define KB_COUNTER_OK  0x03    // # a key must be seen before declared 'valid'
-#define KB_LONG_HOLD_TIME 500  // 500 x 4.4 msec = 2200 msec
-#define KB_BUFFER_SIZE 1
-
-
-/*
- *  below are the keys after they where remapped to 8-bit values
- *  These definitions are used by the application
- */
-
-#define KEY_SPEC       0
-#define KEY_01         1
-#define KEY_02         2
-#define KEY_03         3
-#define KEY_04         4
-#define KEY_05         5
-#define KEY_ALT        6
-
-#define KEY_ESC        7
-#define KEY_UP         8
-#define KEY_OK         9
-#define KEY_LEFT       10
-#define KEY_DOWN       11
-#define KEY_RIGHT      12
-
-#define KEY_POWER      13
-#define KEY_SETUP      14
-#define KEY_LCD        15       // virtual key, generated when '1' is pressed and hold for > 2 secs
-
-#define KEY_07         18       // only on RC and only used for selftest
-
-#define KEY_NROF_KEYS  16
-
-// next 2 'keys' are simulated when inserting or removing a MMC
-#define KEY_MMC_IN     16
-#define KEY_MMC_OUT    17
-
-
-// remove these, not available on SIR100
-#define KEY_00         0xFC
-
-#define IS_IR_KEY(key)  (((key>=KEY_01) && (key<=KEY_09)) || (key==KEY_00))
-
-/* definition of virtual special keys ------------------------------------- */
-#define KEY_UNDEFINED  0x88
-#define KEY_TIMEOUT    0xAA
-#define KEY_NO_KEY     0xFFFF   // yes, indeed no u_char....
-
-#define KEY_REPEAT_TIME     100 // 100 * 4.48 = about half a second
-#define KEY_REPEAT          1
-#define KEY_NO_REPEAT       2
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-void    KbInit(void);
-void    KbScan(void);
-int     KbWaitForKeyEvent(u_long);
-u_char  KbGetKey(void);
-void    KbSetKeyRepeating(u_char, u_char);
-void    KbInjectKey(u_char VirtualKey);
-
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-
-
-
-
-
-
-
-
-
-
-
-

ipac-base-27JAN2011/include/led.h

@@ -1,49 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     LED
- * [TITLE]      LED control header file
- * [FILE]       led.h
- * [VSN]        1.0
- * [CREATED]    1 augustus 2003
- * [LASTCHNGD]  23 augustus 2003
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    LED control routines for SIR
- * ======================================================================== */
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-
-#define LED_OFF         0
-#define LED_ON          1
-#define LED_POWER_ON    2
-#define LED_POWER_OFF   3
-#define LED_TOGGLE      4
-#define LED_FLASH_ON    5
-#define LED_FLASH_OFF   6
-
-/*-------------------------------------------------------------------------*/
-/* typedefs & structs                                                      */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-void LedInit(void);
-void LedControl(u_char);
-u_char LedGetStatus(void);
-
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-
-
-
-
-
-
-
-
-
-
-
-

ipac-base-27JAN2011/include/log.h

@@ -1,131 +0,0 @@
-#ifndef _Log_H
-#define _Log_H
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : Log
- *  File name  $Workfile: Log.h  $
- *       Last Save $Date: 2003/08/16 15:01:36  $
- *             $Revision: 0.1  $
- *  Creation Date       : 2003/08/16 15:01:36
- *
- *  Description         :
- *
- */
-
-/*!
- *\ brief Define this to output raw unformatted output.
- *
- * Advantage of RAW is you can use fprintf(stdout, "format", ...) anywhere.
- * Disadvantage is that there is no selection on loglevel and that there
- * is no indication whether it is a warning, error, etc.
- */
-//#define LOG_RAW
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <stdio.h>
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-#ifdef LOG_RAW
-#define LogMsg_P            fputc('\n', stdout);fprintf_P
-#endif
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-/*! \brief The log priority levels
- * The first entry has the highest priority
- */
-#ifdef LOG_RAW
-#define LOG_EMERG stdout
-#define LOG_ALERT stdout
-#define LOG_CRIT stdout
-#define LOG_ERR stdout
-#define LOG_WARNING stdout
-#define LOG_NOTICE stdout
-#define LOG_INFO stdout
-#define LOG_DEBUG stdout
-typedef FILE * TLogLevel;
-#else
-typedef u_char TLogLevel;
-#endif
-
-// bit 0..2 for LEVEL
-#define LOG_EMERG_LEV   0x00
-#define LOG_ALERT_LEV   0x01
-#define LOG_CRIT_LEV    0x02
-#define LOG_ERR_LEV     0x03
-#define LOG_WARNING_LEV 0x04
-#define LOG_NOTICE_LEV  0x05
-#define LOG_INFO_LEV    0x06
-#define LOG_DEBUG_LEV   0x07
-
-// bit 3..7 for MODULE
-#define LOG_AUDIO_MODULE        0x10
-#define LOG_CHANNEL_MODULE      0x20
-#define LOG_COMAND_MODULE       0x30
-#define LOG_DISPLAY_MODULE      0x40
-#define LOG_FAT_MODULE          0x50
-#define LOG_FLASH_MODULE        0x60
-#define LOG_HTTP_MODULE         0x70
-#define LOG_INET_MODULE         0x80
-#define LOG_KEYBOARD_MODULE     0x90
-#define LOG_LED_MODULE          0xA0
-#define LOG_LOG_MODULE          0xB0
-#define LOG_MAIN_MODULE         0xC0
-#define LOG_MENU_MODULE         0xD0
-#define LOG_MMC_MODULE          0xE0
-#define LOG_MMCDRV_MODULE       0xF0
-#define LOG_PARSE_MODULE        0x08
-#define LOG_PLAYER_MODULE       0x18
-#define LOG_REMCON_MODULE       0x28
-#define LOG_RTC_MODULE          0x38
-#define LOG_SELFTEST_MODULE     0x48
-#define LOG_SESSION_MODULE      0x58
-#define LOG_SETTINGS_MODULE     0x68
-#define LOG_SPIDRV_MODULE       0x78
-#define LOG_STREAMER_MODULE     0x88
-#define LOG_UART0DRIVER_MODULE  0x98
-#define LOG_UPDATE_MODULE       0xA8
-#define LOG_UTIL_MODULE         0xB8
-#define LOG_VERSION_MODULE      0xC8
-#define LOG_VS10XX_MODULE       0xD8
-#define LOG_WATCHDOG_MODULE     0xE8
-
-// note that LOG_MODULE must be defined before including this "log.h"
-#define LOG_EMERG       (TLogLevel)(LOG_EMERG_LEV   | LOG_MODULE)
-#define LOG_ALERT       (TLogLevel)(LOG_ALERT_LEV   | LOG_MODULE)
-#define LOG_CRIT        (TLogLevel)(LOG_CRIT_LEV    | LOG_MODULE)
-#define LOG_ERR         (TLogLevel)(LOG_ERR_LEV     | LOG_MODULE)
-#define LOG_WARNING     (TLogLevel)(LOG_WARNING_LEV | LOG_MODULE)
-#define LOG_NOTICE      (TLogLevel)(LOG_NOTICE_LEV  | LOG_MODULE)
-#define LOG_INFO        (TLogLevel)(LOG_INFO_LEV    | LOG_MODULE)
-#define LOG_DEBUG       (TLogLevel)(LOG_DEBUG_LEV   | LOG_MODULE)
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-extern void LogInit(void);
-
-extern void LogOpen(void);
-extern void LogClose(void);
-
-#ifndef LOG_RAW
-extern void LogMsg_P(TLogLevel tLevel, PGM_P szMsg, ...);
-extern void LogChar_P(const char bChar);
-#endif
-
-extern TLogLevel LogSetLevel(TLogLevel tLevel);
-
-extern void HexDump(FILE *stream, CONST unsigned char *cp, size_t length);
-
-#endif /* _Log_H */

ipac-base-27JAN2011/include/mmc.h

@@ -1,41 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR100
- * [MODULE]     MMC driver
- * [TITLE]      Media Card driver include file
- * [FILE]       mmc.h
- * [VSN]        1.0
- * [CREATED]    02 october 2006
- * [LASTCHNGD]  02 october 2006
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    routines and API to support MMC-application
- * ======================================================================== */
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-#define CARD_IS_NOT_PRESENT           0
-#define CARD_IS_PRESENT               1
-#define CARD_NO_CHANGE                2       // no change since last event occured
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-extern void CardInit(void);
-extern int CardInitCard(void);
-extern TError CardOpen(u_char);
-extern void CardClose(void);
-extern TError CardStatus(void);
-extern unsigned int CardGetCurrentSong(void);
-extern char* CardGetCurrentSongName(unsigned int *punLength);
-
-extern u_char CardCheckCard(void);          // check by examining physical PIN
-extern u_char CardCheckPresent(void);       // check by examining administration
-extern TError CardPlayMp3File(char *path);
-extern void CardStopMp3File(void);
-extern void CardUpdateTicks(void);
-extern u_char CardGetNumberOfPlayLists(void);
-
-       //
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-

ipac-base-27JAN2011/include/mmcdrv.h

@@ -1,100 +0,0 @@
-/****************************************************************************
-*  This file is part of the MMC device driver.
-*
-*  Copyright (c) 2002-2004 by Michael Fischer. All rights reserved.
-*
-*  Redistribution and use in source and binary forms, with or without 
-*  modification, are permitted provided that the following conditions 
-*  are met:
-*  
-*  1. Redistributions of source code must retain the above copyright 
-*     notice, this list of conditions and the following disclaimer.
-*  2. Redistributions in binary form must reproduce the above copyright
-*     notice, this list of conditions and the following disclaimer in the 
-*     documentation and/or other materials provided with the distribution.
-*  3. Neither the name of the author nor the names of its contributors may 
-*     be used to endorse or promote products derived from this software 
-*     without specific prior written permission.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
-*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
-*  THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
-*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
-*  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
-*  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
-*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
-*  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
-*  SUCH DAMAGE.
-*
-****************************************************************************
-*  History:
-*
-*  10.10.04  mifi   First Version
-****************************************************************************/
-#ifndef __MMCDRV_H__
-#define __MMCDRV_H__
-
-#include "typedefs.h"
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-//
-// Here we can switch on/off some
-// feature of the software
-//
-#define MMC_SUPPORT_WRITE               1
-
-#define MMC_OK                          0x00
-#define MMC_ERROR                       0x01
-#define MMC_DRIVE_NOT_FOUND             0x02
-#define MMC_PARAM_ERROR                 0x03
-#define MMC_BUSY                        0x04
-#define MMC_NOT_SUPPORTED               0x08
-
-#define MMC_DRIVE_C                     0
-
-//
-// Sector size
-//
-#define MMC_SECTOR_SIZE                 512
-#define MAX_SECTOR_SIZE                 MMC_SECTOR_SIZE
-
-/*-------------------------------------------------------------------------*/
-/* global types                                                            */
-/*-------------------------------------------------------------------------*/
-typedef void MMC_MOUNT_FUNC(int nDevice);
-
-/*-------------------------------------------------------------------------*/
-/* global macros                                                           */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* Prototypes                                                              */
-/*-------------------------------------------------------------------------*/
-int MMCInit(int nMMCMode, MMC_MOUNT_FUNC * pMountFunc, MMC_MOUNT_FUNC * pUnMountFunc);
-
-int MMCMountAllDevices(int nMMCMode, BYTE *pSectorBuffer);
-
-int MMCGetSectorSize(BYTE bDevice);
-
-int MMCIsCDROMDevice(BYTE bDevice);
-
-int MMCIsZIPDevice(BYTE bDevice);
-
-int MMCUnMountDevice(BYTE bDevice);
-
-DWORD MMCGetTotalSectors(BYTE bDevice);
-
-int MMCReadSectors(BYTE bDevice, void *pData, DWORD dwStartSector, WORD wSectorCount);
-
-#if (MMC_SUPPORT_WRITE == 1)
-
-int MMCWriteSectors(BYTE bDevice, void *pData, DWORD dwStartSector, WORD wSectorCount);
-
-#endif
-
-#endif /* !__MMCDRV_H__ */

ipac-base-27JAN2011/include/platform.h

@@ -1,51 +0,0 @@
-#ifndef _Platform_H
-#define _Platform_H
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : Platform
- *  File name  $Workfile: Platform.h  $
- *       Last Save $Date: 2003/08/18 10:09:48  $
- *             $Revision: 0.1  $
- *  Creation Date       : 2003/08/18 10:09:48
- *
- *  Description         : Definitions which are dependent on the compiler and
- *                        or processor.
- */
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-#define LOBYTE(w)           ((u_char) ((w) & 0xFF))
-#define HIBYTE(w)           ((u_char) (((u_short) (w) >> 8) & 0xFF))
-#define LOWORD(l)           ((u_short) ((l) & 0xFFFF))
-#define HIWORD(l)           ((u_short) (((u_long) (l) >> 16) & 0xFFFF))
-
-#define MAKEWORD(bLow, bHigh) \
-    ((u_short) (((u_char) (bLow)) | ((u_short) ((u_char) (bHigh))) << 8))
-#define MAKEULONG(wLow, wHigh) \
-    ((u_long) (((u_short) (wLow)) | ((u_long) ((u_short) (wHigh))) << 16))
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-
-#ifndef prog_int
-#define prog_int        prog_int16_t
-#endif /* #ifndef prog_int */
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-#define PRG_RDW(addr)   pgm_read_word(addr)
-
-#endif /* _Platform_H */

ipac-base-27JAN2011/include/portio.h

@@ -1,142 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     PortIO
- * [TITLE]      Port IO header file
- * [FILE]       portio.h
- * [VSN]        2.0
- * [CREATED]    030414
- * [LASTCHNGD]  072405
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    support for low-level pinning
- * ======================================================================== */
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-
-//      ********* PORT B ************
-
-//     7   6   5   4   3   2   1   0
-//   ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿
-//  ³RES³CEN³CSC³XCS³SO ³ SI³CLK³CWP³
-// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ
-
-#define MMC_ENABLE      5           // active LOW!
-#define VS_ENABLE       6           // note that logic has changed since SIR80 V1
-
-#define MMCVS_OUT_DDR   DDRB        // data-direction of MMC/VS functions
-#define MMCVS_OUT_WRITE PORTB       // write PORTB (B as output)
-
-//      ********* PORT D ************
-
-//     7   6   5   4   3   2   1   0
-//   ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿
-//  ³LD7³LD6³LD5³LD4³KC2³KC3³ EN³ - ³
-// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ
-
-#define LCD_EN          2           // LCD chip Enable (or: chip select)
-
-#define LCD_DATA_4      4
-#define LCD_DATA_5      5
-#define LCD_DATA_6      6
-#define LCD_DATA_7      7
-
-#define LCD_DATA_DDR    DDRD        // data-direction of LCD-data port
-#define LCD_DATA_PORT   PORTD       // port to write LCD-data
-#define LCD_IN_PORT     PIND        // port to read LCD-data
-
-#define LCD_EN_DDR      DDRE        // data-direction of LCD-control port
-#define LCD_EN_PORT     PORTE       // data of LCD-control port
-
-#define KB_OUT_DDR_B    DDRD        // data-direction of KB_OUT (second part)
-#define KB_OUT_WRITE_B  PORTD       // write PORTD (D as output)
-
-//      ********* PORT E ************
-
-//     7   6   5   4   3   2   1   0
-//   ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿
-//  ³CSF³REQ³ETH³IR ³BL ³ - ³TXD³RXD³
-// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ
-
-#define FLASH_ENABLE    7       // active LOW!
-#define LCD_BL_BIT      3       // Backlight LCD
-#define IR_PIN          4       // Infrared receive PIN
-
-#define FLASH_OUT_WRITE PORTE   // write PORTE for Flash CS
-#define LCD_BL_PORT     PORTE
-
-
-
-//      ********* PORT F ************
-
-//     7   6   5   4   3   2   1   0
-//   ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿
-//  ³KR3³KR2³KR1³KR0³LED³LRS³LRW³CRD³        // note TDI ( JTAG-pin) is shared with KR3
-// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ
-
-#define MMC_CDETECT         0       // signal card inserted/removed
-#define LCD_RW              1       // R/W LCD
-#define LCD_RS              2       // Register select LCD
-#define LED_PIN             3       // LED
-
-
-#define LCD_RS_DDR          DDRF    // data-direction of LCD-control port
-#define LCD_RS_PORT         PORTF   // data of LCD-control port
-#define LCD_RW_DDR          DDRF    // data-direction of LCD-control port
-#define LCD_RW_PORT         PORTF   // data of LCD-control port
-
-#define LED_OUT_DDR         DDRF    // data-direction of LED control pin
-#define LED_OUT_WRITE       PORTF   // write PORTF
-
-#define KB_IN_DDR           DDRF    // data-direction of KB_IN
-#define KB_IN_WRITE         PORTF   // write PORTF (F as output)
-#define KB_IN_READ          PINF    // read PINF (F as input)
-
-#define MMC_IN_DDR          DDRF    // data-direction of MMC_CDETECT
-#define MMC_IN_READ         PINF    // read PINF (F as input)
-
-
-//     7   6   5   4   3   2   1   0
-//   ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿
-//  ³ - ³ - ³ - ³KC1³KC0³ - ³ - ³ - ³
-// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ
-
-#define KB_OUT_DDR_A    DDRG        // data-direction of KB_OUT (first part)
-#define KB_OUT_WRITE_A  PORTG       // write PORTG (G as output)
-
-
-#define JTAG_REG            MCUCR
-#define OVERFLOW_SIGNAL     sig_OVERFLOW0
-
-#define init_8_bit_timer()  \
-{                           \
-    TCCR0B |= (1<<CS02);    \
-    TIFR0 |= 1<<TOV0;       \
-    TIMSK0 |= 1<<TOIE0;     \
-}
-
-#define disable_8_bit_timer_ovfl_int()  \
-{                                       \
-    TIMSK0 &= ~(1<<TOIE0);              \
-}
-
-//      ********* PORT G ************
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-
-
-
-
-
-
-
-
-
-
-
-

ipac-base-27JAN2011/include/remcon.h

@@ -1,52 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     Remote Control
- * [TITLE]      remote control header file
- * [FILE]       remcon.h
- * [VSN]        1.0
- * [CREATED]    1 july 2003
- * [LASTCHNGD]  1 july 2003
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    remote control routines for SIR
- * ======================================================================== */
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-#define RC_OK                 0x00
-#define RC_ERROR              0x01
-#define RC_BUSY               0x04
-
-#define RCST_IDLE             0x00
-#define RCST_WAITFORLEADER    0x01
-#define RCST_SCANADDRESS      0x02
-#define RCST_SCANDATA         0x03
-
-#define RC_INT_SENS_MASK      0x03
-#define RC_INT_FALLING_EDGE   0x02
-#define RC_INT_RISING_EDGE    0x03
-
-#define IR_RECEIVE            4
-#define IR_BUFFER_SIZE        1
-
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-void    RcInit(void);
-
-
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-
-
-
-
-
-
-
-
-
-
-
-

ipac-base-27JAN2011/include/rtc.h

@@ -1,158 +0,0 @@
-#ifndef _RTC_H_
-#define	_RTC_H_
-
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     Real Time Clock
- * [TITLE]      High- and low level Routines for INtersil X1205 RTC chip
- * [FILE]       rtc.c
- * [VSN]        1.0
- * [CREATED]    13042007
- * [LASTCHNGD]  131042007
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    contains all interface- and low-level routines to
- *              read/write date/time/status strings from the X1205
- * ======================================================================== */
-#include <time.h>           // for tm-struct
-                            //
-/*! \name Non-Volatile Alarm Registers */
-/*@{*/
-#define X12RTC_SCA0         0x00    /*!< \brief Alarm 0 second. */
-#define X12RTC_SCA1         0x08    /*!< \brief Alarm 1 second. */
-#define X12RTC_SCA_ESC      0x80    /*!< \brief Second alarm enabled. */
-
-#define X12RTC_MNA0         0x01    /*!< \brief Alarm 0 minute. */
-#define X12RTC_MNA1         0x09    /*!< \brief Alarm 1 minute. */
-#define X12RTC_MNA_EMN      0x80    /*!< \brief Minute alarm enabled. */
-
-#define X12RTC_HRA0         0x02    /*!< \brief Alarm 0 hour. */
-#define X12RTC_HRA1         0x0A    /*!< \brief Alarm 1 hour. */
-#define X12RTC_HRA_EHR      0x80    /*!< \brief Hour alarm enabled. */
-
-#define X12RTC_DTA0         0x03    /*!< \brief Alarm 0 day of month. */
-#define X12RTC_DTA1         0x0B    /*!< \brief Alarm 1 day of month. */
-#define X12RTC_DTA_EDT      0x80    /*!< \brief Day of month alarm enabled. */
-
-#define X12RTC_MOA0         0x04    /*!< \brief Alarm 0 month. */
-#define X12RTC_MOA1         0x0C    /*!< \brief Alarm 1 month. */
-#define X12RTC_MOA_EMO      0x80    /*!< \brief Month alarm enabled. */
-
-#define X12RTC_YRA0         0x05    /*!< \brief Currently unused alarm 0 register. */
-#define X12RTC_YRA1         0x0D    /*!< \brief Currently unused alarm 1 register. */
-
-#define X12RTC_DWA0         0x06    /*!< \brief Alarm 0 weekday. */
-#define X12RTC_DWA1         0x0E    /*!< \brief Alarm 1 weekday. */
-#define X12RTC_DWA_EDW      0x80    /*!< \brief Weekday alarm enabled. */
-
-#define X12RTC_Y2K0         0x07    /*!< \brief Alarm 0 . */
-#define X12RTC_Y2K1         0x0F    /*!< \brief Alarm 1 . */
-/*@}*/
-
-/*! \name Non-Volatile Control Registers */
-/*@{*/
-#define X12RTC_BL           0x10    /*!< \brief Block protection and watchdog register. */
-
-#define X12RTC_BL_WD        0x14    /*!< \brief Watchdog configuration. */
-#define X12RTC_BL_WD_1750   0x00    /*!< \brief Timeout after 1.75 seconds. */
-#define X12RTC_BL_WD_750    0x04    /*!< \brief Timeout after 750 milliseconds. */
-#define X12RTC_BL_WD_250    0x10    /*!< \brief Timeout after 250 milliseconds. */
-#define X12RTC_BL_WD_OFF    0x14    /*!< \brief Disabled. */
-
-#define X12RTC_BL_BP        0xE0    /*!< \brief Block protection. */
-#define X12RTC_BL_BP_NONE   0x00    /*!< \brief No protection. */
-#define X12RTC_BL_BP_UQUAD  0x20    /*!< \brief Upper quarter protected. */
-#define X12RTC_BL_BP_UHALF  0x40    /*!< \brief Upper half protected. */
-#define X12RTC_BL_BP_FULL   0x60    /*!< \brief Full array protected. */
-#define X12RTC_BL_BP_FIRST1 0x80    /*!< \brief First page protected. */
-#define X12RTC_BL_BP_FIRST2 0xA0    /*!< \brief First 2 pages protected. */
-#define X12RTC_BL_BP_FIRST3 0xC0    /*!< \brief First 4 pages protected. */
-#define X12RTC_BL_BP_FIRST8 0xE0    /*!< \brief First 8 pages protected. */
-
-#define X12RTC_INT          0x11    /*!< \brief Interrupt control and freq. output register. */
-
-#define X12RTC_INT_FO       0x14    /*!< \brief Programmable frequency output bits. */
-#define X12RTC_INT_FO_IRQ   0x00    /*!< \brief Alarm interrupt. */
-#define X12RTC_INT_FO_32KHZ 0x04    /*!< \brief 32.768kHz. */
-#define X12RTC_INT_FO_100HZ 0x10    /*!< \brief 100Hz. */
-#define X12RTC_INT_FO_1HZ   0x14    /*!< \brief 1Hz. */
-
-#define X12RTC_INT_AL0E     0x20    /*!< \brief Alarm 0 interrupt enable. */
-#define X12RTC_INT_AL1E     0x40    /*!< \brief Alarm 1 interrupt enable. */
-#define X12RTC_INT_IM       0x80    /*!< \brief Repetitive alarm. */
-
-#define X12RTC_ATR          0x12    /*!< \brief Analog trimming register. */
-
-#define X12RTC_DTR          0x13    /*!< \brief Digital trimming register. */
-#define X12RTC_DTR_NONE     0x00    /*!< \brief 0 PPM. */
-#define X12RTC_DTR_PLUS10   0x02    /*!< \brief +10 PPM. */
-#define X12RTC_DTR_PLUS20   0x01    /*!< \brief +20 PPM. */
-#define X12RTC_DTR_PLUS30   0x03    /*!< \brief +30 PPM. */
-#define X12RTC_DTR_MINUS10  0x06    /*!< \brief -10 PPM. */
-#define X12RTC_DTR_MINUS20  0x05    /*!< \brief -20 PPM. */
-#define X12RTC_DTR_MINUS30  0x07    /*!< \brief -30 PPM. */
-/*@}*/
-
-/*! \name Volatile Date and Time Registers */
-/*@{*/
-#define X12RTC_SC           0x30    /*!< Seconds register, 0 - 59. */
-#define X12RTC_MN           0x31    /*!< Minutes register, 0 - 59. */
-#define X12RTC_HR           0x32    /*!< Hours register, 0 - 23. */
-#define X12RTC_HR_MIL       0x80    /*!< Use 24h format. */
-#define X12RTC_DT           0x33    /*!< Day register, 1 - 31. */
-#define X12RTC_MO           0x34    /*!< Month register, 1 - 12. */
-#define X12RTC_YR           0x35    /*!< Year register, 0 - 99. */
-#define X12RTC_DW           0x36    /*!< Day of the weeks register, 0 - 6. */
-#define X128xRTC_SSEC       0x37    /*!< X1286 1/100 second register, 0 - 99 (read only). */
-#define X122xRTC_Y2K        0x37    /*!< X1226 epoch register, 19 or 20. */
-/*@}*/
-
-/*! \name Volatile Status Register */
-/*@{*/
-#define X12RTC_SR           0x3F    /*!< Status register. */
-#define X12RTC_SR_RTCF      0x01    /*!< Power failure. */
-#define X12RTC_SR_WEL       0x02    /*!< Memory write enable. */
-#define X12RTC_SR_RWEL      0x04    /*!< Register write enable. */
-#define X12RTC_SR_AL0       0x20    /*!< Alarm 0 indicator. */
-#define X12RTC_SR_AL1       0x40    /*!< Alarm 1 indicator. */
-#define X12RTC_SR_BAT       0x80    /*!< Operating from battery. */
-/*@}*/
-
-#define RTC_STATUS_PF       0x00000001
-#define RTC_STATUS_AL0      0x00000020
-#define RTC_STATUS_AL1      0x00000040
-
-#define RTC_ALARM_SECOND    0x00000001
-#define RTC_ALARM_MINUTE    0x00000002
-#define RTC_ALARM_HOUR      0x00000004
-#define RTC_ALARM_MDAY      0x00000008
-#define RTC_ALARM_MONTH     0x00000010
-#define RTC_ALARM_WDAY      0x00000080
-
-/*!
- * \brief Convert binary coded decimal to binary value.
- */
-#define BCD2BIN(x) ((((u_char)(x)) >> 4) * 10 + ((x) & 0x0F))
-
-/*!
- * \brief Convert binary to binary coded decimal value.
- */
-#define BIN2BCD(x) (((((u_char)(x)) / 10) << 4) + (x) % 10)
-
-
-/* Prototypes */
-extern int X12Init(void);
-
-extern int X12RtcGetClock(tm *tm);
-extern int X12RtcSetClock(CONST tm *tm);
-extern int X12RtcGetAlarm(int idx, tm *tm, int *aflgs);
-extern int X12RtcSetAlarm(int idx, CONST tm *tm, int aflgs);
-extern int X12RtcGetStatus(u_long *sflgs);
-extern int X12RtcClearStatus(u_long sflgs);
-extern int X12RtcReadRegs(u_char addr, u_char *buff, size_t len);
-extern int X12RtcWrite(int nv, CONST u_char *buff, size_t len);
-
-extern int X12EepromRead(u_int addr, void *buff, size_t len);
-extern int X12EepromWrite(u_int addr, CONST void *buff, size_t len);
-
-/* End of prototypes */
-#endif

ipac-base-27JAN2011/include/spidrv.h

@@ -1,53 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR100
- * [MODULE]     SPI
- * [TITLE]      spi header file
- * [FILE]       spi.h
- * [VSN]        1.0
- * [CREATED]    12052007
- * [LASTCHNGD]  12052007
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    API and global defines for SPI module
- * ======================================================================== */
-
-#ifndef _SPI_H
-#define _SPI_H
-
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-#define SPEED_SLOW         0
-#define SPEED_FAST         1
-#define SPEED_ULTRA_FAST   2
-
-/*-------------------------------------------------------------------------*/
-/* typedefs & structs                                                      */
-/*-------------------------------------------------------------------------*/
-typedef enum
-{
-    SPI_DEV_VS10XX=0,
-    SPI_DEV_FLASH,
-    SPI_DEV_MMC,
-
-    SPI_NROF_DEVICES        // keep last
-}TSPIDevice;
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-extern void SPIselect(TSPIDevice Device);
-extern void SPIdeselect(void);
-extern void SPIputByte(u_char bByte);       // send byte using SPI, ignore result
-extern u_char SPIgetByte(void);             // read byte using SPI, don't use any input
-extern u_char SPItransferByte(u_char);      // send byte using SPI, return result
-extern void SPIinit(void);                  // initialise SPI-registers (speed, mode)
-extern void SPImode(u_char data);
-extern u_char SPIgetmode(void);
-
-#endif /* _SPI_H */
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-

ipac-base-27JAN2011/include/system.h

@@ -1,144 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     global module
- * [TITLE]      system header file
- * [FILE]       system.h
- * [VSN]        1.0
- * [CREATED]    18 august 2003
- * [LASTCHNGD]  18 august 2003
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    global defines and prototypes for Lucas project
- * ======================================================================== */
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include "typedefs.h"
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-#define ON    (1)
-#define OFF   (0)
-
-#define NO_CHANNEL      200     // make sure this is > SETTINGS_NROF_CHANNELS
-#define NO_PLAYLIST     200     // make sure this is > SETTINGS_NROF_PLAYLISTS
-
-
-/*!\brief System status bit definitions */
-#define STATUS_STARTING_UP              0x01        // true during startup and Setup Wizzard
-#define STATUS_IP_MODE                  0x02        // do we use DHCP or Static IP?
-#define STATUS_POWER                    0x04        // if set, we are on
-#define STATUS_SELFTEST                 0x08        // switch to re-direct keys from Menu to Selftest module
-#define STATUS_CONFIGURED               0x10        // if set, we are configured
-#define STATUS_GPB_INVALID              0x20        // if set, we cannot rely on Productcode, Remote Updatemode, etc
-#define STATUS_FALLBACK_ACTIVE          0x40        // if set, we cannot play from the internet and if a card is present, we play from card
-
-#define STATUS_STARTING_UP_MASK         0x01
-#define STATUS_IP_MODE_MASK             0x02
-#define STATUS_POWER_MASK               0x04
-#define STATUS_SELFTEST_MASK            0x08
-#define STATUS_CONFIGURED_MASK          0x10
-#define STATUS_GPB_INVALID_MASK         0x20
-#define STATUS_FALLBACK_ACTIVE_MASK     0x40
-
-#define ONE_SECOND      225             // 225 times 4,44 msecs makes 1 second
-#define ONE_MINUTE      60
-#define ONE_HOUR        60
-
-
-/*!\brief define possible languages */
-#define LANGUAGE_NL     0
-#define LANGUAGE_EN     1
-#define LANGUAGE_DE     2
-
-/*!\brief define possible IP_Modes */
-#define IP_MODE_DHCP    0
-#define IP_MODE_STATIC  1
-
-/*!\brief define possible countrycodes (mainly used for the modem) */
-#define COUNTRY_US      0
-#define COUNTRY_UK      1
-#define COUNTRY_SA      2
-#define COUNTRY_NL_V92  3
-#define COUNTRY_NL_V34  4
-#define COUNTRY_NROF    5
-
-/*!\brief Maximum size to use for threadnames */
-#define THREADNAME_SIZE 9
-
-enum
-{
-        IRQ_INT0,
-        IRQ_INT1,
-        IRQ_INT2,
-        IRQ_INT3,
-        IRQ_INT4,
-        IRQ_INT5,
-        IRQ_INT6,
-        IRQ_INT7,
-        IRQ_TIMER2_COMP,
-        IRQ_TIMER2_OVF,
-        IRQ_TIMER1_CAPT,
-        IRQ_TIMER1_COMPA,
-        IRQ_TIMER1_COMPB,
-        IRQ_TIMER1_OVF,
-        IRQ_TIMER0_COMP,
-        IRQ_TIMER0_OVF,
-        IRQ_SPI_STC,
-        IRQ_UART_RX,
-        IRQ_UART_UDRE,
-        IRQ_UART_TX,
-        IRQ_ADC,
-        IRQ_EE_RDY,
-        IRQ_ANA_COMP,
-        IRQ_TIMER1_COMPC,
-        IRQ_TIMER3_CAP,
-        IRQ_TIMER3_COMPA,
-        IRQ_TIMER3_COMPB,
-        IRQ_TIMER3_COMPC,
-        IRQ_TIMER3_OVF,
-        IRQ_UART1_RX,
-        IRQ_UART1_UDRE,
-        IRQ_UART1_TX,
-        IRQ_I2C,
-        IRQ_SPM_RDY,
-        IRQ_MAX
-};
-
-
-/*-------------------------------------------------------------------------*/
-/* typedefs & structs                                                      */
-/*-------------------------------------------------------------------------*/
-typedef struct
-{
-    u_char KeyLockStatus;               // overall lock, if ACTIVE, keyboard is locked
-    u_char KeyLockEditStatus;           // used when user wants to change the status of the Keylock
-    u_char KeyLockTempStatus;           // after entering a valid PIN, this goes to INACTIVE for 30 secs
-    u_short KeyLockPIN;                 // range = [0]..[5555]
-} TKeyLock;
-
-typedef u_char TIPMode;
-typedef u_char TLanguage;
-
-/*-------------------------------------------------------------------------*/
-/* export global variables                                                 */
-/*-------------------------------------------------------------------------*/
-extern u_char           SystemStatus;
-
-extern TLanguage        SystemLanguage;
-extern TIPMode          SystemIPMode;
-extern TKeyLock         SystemKeyLock;
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-extern void SysInitVars(void);
-extern void SysPowerOn(void);
-extern void SysPowerOff(void);
-extern void SysInitIO(void);
-extern void SystemShowSysInfo(void);
-
-
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-

ipac-base-27JAN2011/include/typedefs.h

@@ -1,183 +0,0 @@
-#ifndef _Typedefs_H
-#define _Typedefs_H
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     global module
- * [TITLE]      system header file
- * [FILE]       typedefs.h
- * [VSN]        1.0
- * [CREATED]    09 november 2003
- * [LASTCHNGD]  09 november 2003
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    global typedefs
- * ======================================================================== */
-
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <fs/typedefs.h>
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-/* RL: this 'table' has now a mirror table in 'Display.c' (LcdErrorStrings) */
-/*     Make sure that any modification made to this table are reflected by  */
-/*     the LcdErrorStirngs table! (an error is bad but showing the wrong    */
-/*     error is too much....) */
-typedef enum _TERRORCODE
-{
-    OK = 0,                             /* All ok */
-
-    /*
-     * Status messages
-     */
-    CHANNEL_CONNECTING,                 /* Channel connecting */
-    CHANNEL_RETRIEVING,                 /* Retrieving channels */
-    STREAMER_CONNECTING,                /* Connecting to stream */
-    STREAMER_BUFFERING,                 /* Buffering audio */
-    STREAMER_PLAYING,                   /* Playing audio from a stream */
-    STREAMER_FALLBACK,                  /* trying card now, inet failed*/
-    UPDATE_CONNECTING,                  /* connecting to update server */
-    CARD_BUFFERING,                     /* Buffering audio */
-    CARD_PLAYING,                       /* Playing audio from a card */
-
-    USER_ABORT,                         /* User abort */
-
-    /*
-     * Warnings. In other words, problems that are
-     * probably recoverable by a retry
-     */
-    PLAYER_WARNINGS = 200,
-    CHANNEL_HOSTNOTFOUND,               /* Could not resolve hostname */
-    CHANNEL_NEW_ISP,                    /* New ISP settings received */
-    CHANNEL_NEW_DB,                     /* New DB URL info received */
-    CHANNEL_NEW_CHANNEL,                /* New channel info received */
-    CHANNEL_NOCONNECT,                  /* Could not connect (will retry) */
-
-    CHANNEL_TOO_MANY_NOCONNECTS,        /* Could not connect */
-    CHANNEL_REDIRECT,                   /* Redirect (will retry) */
-    CHANNEL_TOO_MANY_REDIRECTS,         /* Too many redirects */
-    CHANNEL_BADRESPONSE,                /* Bad server response (will retry) */
-    CHANNEL_TOO_MANY_BADRESPONSES,      /* Bad server response */
-
-    STREAM_HOSTNOTFOUND,                /* Could not resolve hostname */
-    STREAM_NOCONNECT,                   /* Could not connect (will retry) */
-    STREAM_REDIRECT,                    /* Redirect (will retry) */
-    STREAM_BADRESPONSE,                 /* Bad server response (will retry) */
-
-    INET_HOSTNOTFOUND,                  /* Could not resolve hostname (will retry) */
-    INET_NOCONNECT,                     /* Could not connect (will retry) */
-    INET_BADRESPONSE,                   /* Bad server response (will retry) */
-    INET_REDIRECT,                      /* Redirect (will retry) */
-    INET_ACCESS_RESTRICTED,             /* Access needs login info (will retry) */
-
-    STREAM_TIMEOUT,                     /* Network timeout */
-    STREAM_BADAUDIO,                    /* Audio data seems invalid */
-    STREAM_DISCONNECTED,                /* Server closed the connection */
-    STREAM_BUFFEREMPTY,                 /* Audio buffer ran out of data */
-    STREAM_BADCHANNEL,                  /* Bad channel number */
-
-    UPDATE_NEEDED,                      /* Firmware update is needed */
-
-    PLAYER_WAITPLAY,                    /* Player has nothing to do */
-    PLAYER_STARTING,
-
-    CARD_BUFFEREMPTY,                   /* Audio buffer ran out of data */
-    CARD_BADPLAYLIST,                   /* non-existing or invalid playlist requested */
-    CARD_BADAUDIO,                      /* Audio data seems invalid */
-
-    /*
-     * Errors.
-     * User interaction (e.g. select a different channel) can solve these
-     */
-    PLAYER_ERRORS = 400,
-    BADCHANNEL,                         /* Bad channel number                   - no longer used */
-    STREAM_TOO_MANY_NOCONNECTS,         /* Too many no connects */
-    STREAM_TOO_MANY_BADRESPONSES,       /* Too many bad server responses */
-    STREAM_TOO_MANY_REDIRECTS,          /* Too many redirects */
-    UPDATE_FAILED,                      /* not specified, just failed */
-
-    CHANNEL_NODATA,                     /* Didn't receive any data */
-
-    STREAM_BAD_FILETYPE,                /* Bad type of file */
-    STREAM_BAD_NETWORK,                 /* Too many network failures            - no longer used */
-    STREAM_DISCONNECTED_UNUSED,         /* Server closed the connection         - no longer used */
-    STREAM_BUFFEREMPTY_UNUSED,          /* Audio buffer ran out of data         - no longer used */
-
-    INET_HOST_NONEXISTANT,              /* Hostname unknown */
-    INET_TOO_MANY_NOCONNECTS,           /* Too many no connects */
-    INET_TOO_MANY_REDIRECTS,            /* Too many redirects */
-    INET_TOO_MANY_BADRESPONSES,         /* Too many bad server responses */
-    INET_ACCESS_DENIED,                 /* Access to the server was denied */
-
-    CARD_NO_SONG,                       /* no (more) songs found on this card */
-    CARD_PLAYLIST_IN_USE,               /* trying to open a playlist that was open already */
-    CARD_CREATE_STREAM,                 /* Failed to create a stream */
-    CARD_NO_CARD,                       /* card not present to perfom desired action */
-    CARD_NO_HEAP,                       /* unable to allocate RAM */
-    CARD_NOT_REGISTERED,                /* card present but not know in the system */
-    CARD_WRONG_HASH,                    /* hash results in a non-valid flash-address */
-    /*
-     * System Errors.
-     * These include programming errors but also:
-     * errors that may (or may not..) be solved by a reboot (indicated by REBOOT)
-     */
-    PLAYER_SYSTEMERRORS = 500,
-    PLAYER_NOTREADY,                    /* Player was not successfully initialised */
-    SESSION_NODEVICE,                   /* Could not register devices */
-    SESSION_NODHCP_NOEEPROM,            /* No DHCP and no previous IP address. REBOOT */
-    SESSION_MDMNOINIT,                  /* Could not initialise modem. REBOOT */
-    SESSION_MDMNODISCONNECT,            /* Modem is still connected. REBOOT */
-
-    SESSION_PPPINIT,                    /* Could not initialise PPP */
-    SESSION_PPPSTART,                   /* Could not start PPP (username/password incorrect?)
-                                           Note that NutOs ALWAYS requires a REBOOT in this case! */
-    SESSION_NOROUTEADD,                 /* Could not add route to routetable */
-    CHANNEL_NOMEM,                      /* Not enough memory for channel */
-    CHANNEL_CREATE_SOCKET,              /* Failed to create a socket */
-
-    CHANNEL_SOCK_RCVTO,                 /* Could not set socket option RCVTO */
-    CHANNEL_CREATE_STREAM,              /* Failed to create a stream */
-    STREAM_NOTHREAD,                    /* Could not start streamer thread */
-    STREAM_NOMEM,                       /* Not enough memory for streamer */
-    STREAM_CREATE_SOCKET,               /* Failed to create a socket */
-
-    STREAM_CREATE_STREAM,               /* Failed to create a stream */
-    STREAM_SOCK_MSS,                    /* Could not set socket option MSS */
-    STREAM_SOCK_RCVTO,                  /* Could not set socket option RCVTO */
-    STREAM_SOCK_RXBUF,                  /* Could not set socket option RXBUF */
-
-    UPDATE_WRONG_NROF_BYTES,            /* nrof bytes not as specified in 'update.inf' */
-    UPDATE_CODESIZE_OVERFLOW,           /* codesize exceeds 126KB (note: 2KB needed for bootloader) */
-    UPDATE_CRC_ERROR,                   /* CRC of downloaded code in RAM incorrect */
-    UPDATE_NOT_ALLOWED,                 /* either ISP or bootloader prohibits Remote Update functionality */
-
-    INET_NOMEM,                         /* Not enough memory */
-    INET_CREATE_SOCKET,                 /* Failed to create a socket */
-    INET_SOCK_MSS,                      /* Could not set socket option MSS */
-    INET_SOCK_RCVTO,                    /* Could not set socket option RCVTO */
-    INET_SOCK_RXBUF,                    /* Could not set socket option RXBUF */
-    INET_CREATE_STREAM,                 /* Failed to create a stream */
-    INET_SEND_FAIL,                     /* Failed to send data */
-
-    STREAM_TOO_MANY_ERRORS,             /* Seen too many errors */
-
-    PLAYER_NO_THREAD,                   /* Could not start player thread */
-    PLAYER_NO_SOURCE,                   /* No source to play audio from */
-} TError;
-
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-
-#endif /* _Typedefs_H */

ipac-base-27JAN2011/include/uart0driver.h

@@ -1,60 +0,0 @@
-#ifndef _UART0DRIVER_H_
-#define _UART0DRIVER_H_
-/*!
- * Copyright (C) 2003 by Streamit All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this
- *    software must display the following acknowledgement:
- *
-  *    This product includes software developed by Streamit
- *    and its contributors.
- *
- * THIS SOFTWARE IS PROVIDED BY STREAMIT AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CALL DIRECT
- * CELLULAR SOLUTIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * For additional information see http://www.streamit.eu/
- */
-/*!
- *
- * COPYRIGHT STREAMIT BV 2010
- * Created
- *
- *
- */
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <stdio.h>
-
-#define UART_COOKEDMODE_RAW    0L
-#define UART_COOKEDMODE_EOL    1L
-
-extern void  Uart0DriverInit(void);
-extern void  Uart0DriverStart(void);
-extern void  Uart0DriverStop(void);
-extern FILE *Uart0DriverGetStream(void);
-extern int   Uart0DriverGetNumber(PGM_P prompt, int dflt);
-extern int   Uart0DriverKey(void);
-extern void  Uart0DriverSetCookedMode(u_long Mode);
-
-
-#endif

ipac-base-27JAN2011/include/vs10xx.h

@@ -1,164 +0,0 @@
-/*
- * Copyright (C) 2001-2003 by egnite Software GmbH. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the copyright holders nor the names of
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
- * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * For additional information see http://www.ethernut.de/
- *
- * -
- * Portions Copyright (C) 2001 Jesper Hansen <jesperh@telia.com>.
- *
- * This file is part of the yampp system.
- *
- * This program 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
- * of the License, or (at your option) any later version.
- *
- * This program 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 this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
- */
-
-/*
- *
- * Revision 2.0  2004/09/30 19:37:39  johan van der stoel
- * Fully rewritten to support VS1011 / VS1003. For VS1001: use driver from
- * Ethernut distribution
- *
- * Revision 1.2  2003/07/13 19:37:39  haraldkipp
- * Enable application to control decoder interrupts.
- *
- *
- */
-
-#include <sys/nutconfig.h>
-#include <sys/types.h>
-
-/*-------------------------------------------------------------------------*/
-/* global defines                                                          */
-/*-------------------------------------------------------------------------*/
-
-// Instruction opcodes
-#define VS_OPCODE_READ      3
-#define VS_OPCODE_WRITE     2
-
-// Decoder registers VS1011/VS1003
-#define VS_MODE_REG         0
-#define VS_STATUS_REG       1
-#define VS_BASS_REG         2
-#define VS_CLOCKF_REG       3
-#define VS_DECODE_TIME_REG  4
-#define VS_AUDATA_REG       5
-#define VS_WRAM_REG         6
-#define VS_WRAMADDR_REG     7
-#define VS_HDAT0_REG        8
-#define VS_HDAT1_REG        9
-#define VS_AIADDR_REG      10
-#define VS_VOL_REG         11
-#define VS_AICTRL0_REG     12
-#define VS_AICTRL1_REG     13
-#define VS_AICTRL2_REG     14
-#define VS_AICTRL3_REG     15
-
-#define NROF_VS_REGS       (VS_AICTRL3_REG+1)
-
-// SCI Mode register bits VS1011/VS1003
-#define VS_SM_DIFF          0x0001
-#define VS_SM_JUMP          0x0002 /* VS1011 */
-#define VS_SM_SETTOZERO     0x0002 /* VS1003 */
-#define VS_SM_RESET         0x0004
-#define VS_SM_OUTOFWAV      0x0008
-#define VS_SM_PDOWN         0x0010
-#define VS_SM_TESTS         0x0020
-#define VS_SM_STREAM        0x0040
-#define VS_SM_SETTOZERO1    0x0080 /* VS1011 */
-#define VS_SM_PLUSV         0x0080 /* VS1003 */
-#define VS_SM_DACT          0x0100
-#define VS_SM_SDIORD        0x0200 /* VS1011 */
-#define VS_SM_SDISHARE      0x0400 /* VS1011 */
-#define VS_SM_SDINEW        0x0800 /* VS1011 */
-#define VS_SM_SETTOZERO2    0x1000 /* VS1011 */
-#define VS_SM_ADPCM         0x1000 /* VS1003 */
-#define VS_SM_SETTOZERO3    0x2000 /* VS1011 */
-#define VS_SM_ADPCM_HP      0x2000 /* VS1003 */
-#define VS_SM_LINE_IN       0x4000 /* VS1003 */
-
-// SCI Status register bits 6-4 contains the ID number of the chip
-#define VS_VS1001           0   /* not supported by this driver */
-#define VS_VS1011           1
-#define VS_VS1011e          2   /* VS1002 also returns this, but is not supported by this driver */
-#define VS_VS1003           3
-#define VS_VS1053           4
-#define VS_VS1033           5
-
-
-// Status of the decoder
-#define VS_STATUS_STOPPED   0
-#define VS_STATUS_RUNNING   1
-#define VS_STATUS_EOF       2
-#define VS_STATUS_EMPTY     4
-
-/*-------------------------------------------------------------------------*/
-/* typedefs & structs                                                      */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* export global variables                                                 */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* export global routines (interface)                                      */
-/*-------------------------------------------------------------------------*/
-extern int VsPlayerInit(void);
-extern int VsPlayerReset(u_short mode);
-extern int VsPlayerSetMode(u_short mode);
-extern int VsPlayerKick(void);
-extern int VsPlayerStop(void);
-extern u_char VsPlayerInterrupts(u_char enable);
-
-extern u_char VsGetStatus(void);
-extern u_short VsMemoryTest(void);
-extern u_short VsGetType(void);
-extern u_short VsGetTypeHex(void);
-extern int VsSetVolume(u_char left, u_char right);
-extern u_short VsGetVolume(void);
-extern int VsBeep(u_char fsin, u_short ms);
-extern int VsBeepStart(u_char fsin);
-extern int VsBeepStartRaw(u_char Raw);
-extern int VsBeepStop(void);
-extern u_short VsRegInfo(u_char reg);
-extern void VsRegWrite(u_char reg, u_short data);
-extern u_short VsStreamValid(void);
-
-
-/*@}*/

ipac-base-27JAN2011/include/watchdog.h

@@ -1,115 +0,0 @@
-#ifndef _watchdog_H
-#define _watchdog_H
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : watchdog
- *  File name  $Workfile: watchdog.h  $
- *       Last Save $Date: 2007/01/16 11:13:53  $
- *             $Revision: 0.1  $
- *  Creation Date       : 2007/01/16 11:13:53
- *
- *  Description         : Watchdog routines for the ATMega128/256
- *                        Inspired by the arch/xxx/dev/watchdog routines in
- *                        NutOS 4.2.1 and higher.
- *
- */
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*!
- * \brief Start the watch dog timer.
- *
- * This function can be used by applications to prevent hang-ups.
- * The watch dog timer will be automatically enabled on return.
- *
- * \param   ms [in] Watch dog time out in milliseconds.
- *
- * \return  -
- *
- * The following code fragment starts the watch timer with a time out
- * of 550 milliseconds and restarts it every 500 milliseconds.
- *
- * \code
- * #include <sys/timer.h>
- * #include "watchdog.h"
- *
- * WatchDogStart(550);
- * for(;;)
- * {
- *     WatchDogRestart();
- *     NutSleep(500);
- * }
- *
- * \endcode
- */
-extern void WatchDogStart(unsigned long ms);
-
-
-/*!
- * \brief Restart the watch dog timer.
- */
-extern void WatchDogRestart(void);
-
-/*!
- * \brief Disables the watch dog timer.
- *
- * Applications should call this function to temporarily disable the
- * watch dog timer. To re-enable it, call WatchDogEnable().
- *
- * \code
- * #include <dev/watchdog.h>
- *
- * WatchDogStart(100, 0);
- *
- * //Some code here.
- *
- * WatchDogRestart();
- *
- * //Some code here.
- *
- * WatchDogDisable();
- *
- * //Some lengthy code here, like writing to flash memory.
- *
- * WatchDogEnable();
- *
- * \endcode
- */
-extern void WatchDogDisable(void);
-
-/*!
- * \brief Enables the watch dog timer.
- *
- * The function can be safely used within nested subroutines.
- * The watch dog will be enabled only, if this function is called
- * the same number of times as WatchDogDisable(). If enabled,
- * the watch dog timer will also have been re-started and the
- * full time out value is available before another WatchDogRestart()
- * is required.
- *
- * If the watch has not been started by WatchDogStart(), then this
- * function does nothing.
- */
-extern void WatchDogEnable(void);
-
-#endif /* _watchdog_H */

ipac-base-27JAN2011/source/display.c

@@ -1,223 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR100
- * [MODULE]     Display
- * [TITLE]      display source file
- * [FILE]       display.c
- * [VSN]        1.0
- * [CREATED]    26092003
- * [LASTCHNGD]  06102006
- * [COPYRIGHT]  Copyright (C) STREAMIT BV
- * [PURPOSE]    contains all interface- and low-level routines to
- *              control the LCD and write characters or strings (menu-items)
- * ======================================================================== */
-
-#define LOG_MODULE  LOG_DISPLAY_MODULE
-
-#include <stdio.h>
-#include <string.h>
-
-#include <sys/types.h>
-#include <sys/timer.h>
-#include <sys/event.h>
-#include <sys/thread.h>
-#include <sys/heap.h>
-
-#include "system.h"
-#include "portio.h"
-#include "display.h"
-#include "log.h"
-
-/*-------------------------------------------------------------------------*/
-/* local defines                                                           */
-/*-------------------------------------------------------------------------*/
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-
-
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-static void LcdWriteByte(u_char, u_char);
-static void LcdWriteNibble(u_char, u_char);
-static void LcdWaitBusy(void);
-
-/*!
- * \addtogroup Display
- */
-
-/*@{*/
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief control backlight
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-void LcdBackLight(u_char Mode)
-{
-    if (Mode==LCD_BACKLIGHT_ON)
-    {
-        sbi(LCD_BL_PORT, LCD_BL_BIT);   // Turn on backlight
-    }
-
-    if (Mode==LCD_BACKLIGHT_OFF)
-    {
-        cbi(LCD_BL_PORT, LCD_BL_BIT);   // Turn off backlight
-    }
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Write a single character on the LCD
- *
- * Writes a single character on the LCD on the current cursor position
- *
- * \param LcdChar character to write
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-void LcdChar(char MyChar)
-{
-    LcdWriteByte(WRITE_DATA, MyChar);
-}
-
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Low-level initialisation function of the LCD-controller
- *
- * Initialise the controller and send the User-Defined Characters to CG-RAM
- * settings: 4-bit interface, cursor invisible and NOT blinking
- *           1 line dislay, 10 dots high characters
- *
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
- void LcdLowLevelInit()
-{
-    u_char i;
-
-    NutDelay(140);                               // wait for more than 140 ms after Vdd rises to 2.7 V
-
-    for (i=0; i<3; ++i)
-    {
-        LcdWriteNibble(WRITE_COMMAND, 0x33);      // function set: 8-bit mode; necessary to guarantee that
-        NutDelay(4);                              // SIR starts up always in 5x10 dot mode
-    }
-
-    LcdWriteNibble(WRITE_COMMAND, 0x22);        // function set: 4-bit mode; necessary because KS0070 doesn't
-    NutDelay(1);                                // accept combined 4-bit mode & 5x10 dot mode programming
-
-    //LcdWriteByte(WRITE_COMMAND, 0x24);        // function set: 4-bit mode, 5x10 dot mode, 1-line
-    LcdWriteByte(WRITE_COMMAND, 0x28);          // function set: 4-bit mode, 5x7 dot mode, 2-lines
-    NutDelay(5);
-
-    LcdWriteByte(WRITE_COMMAND, 0x0C);          // display ON/OFF: display ON, cursor OFF, blink OFF
-    NutDelay(5);
-
-    LcdWriteByte(WRITE_COMMAND, 0x01);          // display clear
-    NutDelay(5);
-
-    LcdWriteByte(WRITE_COMMAND, 0x06);          // entry mode set: increment mode, entire shift OFF
-
-
-    LcdWriteByte(WRITE_COMMAND, 0x80);          // DD-RAM address counter (cursor pos) to '0'
-}
-
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Low-level routine to write a byte to LCD-controller
- *
- * Writes one byte to the LCD-controller (by  calling LcdWriteNibble twice)
- * CtrlState determines if the byte is written to the instruction register
- * or to the data register.
- *
- * \param CtrlState destination: instruction or data
- * \param LcdByte byte to write
- *
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static void LcdWriteByte(u_char CtrlState, u_char LcdByte)
-{
-    LcdWaitBusy();                      // see if the controller is ready to receive next byte
-    LcdWriteNibble(CtrlState, LcdByte & 0xF0);
-    LcdWriteNibble(CtrlState, LcdByte << 4);
-
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Low-level routine to write a nibble to LCD-controller
- *
- * Writes a nibble to the LCD-controller (interface is a 4-bit databus, so
- * only 4 databits can be send at once).
- * The nibble to write is in the upper 4 bits of LcdNibble
- *
- * \param CtrlState destination: instruction or data
- * \param LcdNibble nibble to write (upper 4 bits in this byte
- *
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static void LcdWriteNibble(u_char CtrlState, u_char LcdNibble)
-{
-    outp((inp(LCD_DATA_DDR) & 0x0F) | 0xF0, LCD_DATA_DDR);  // set data-port to output again
-
-    outp((inp(LCD_DATA_PORT) & 0x0F) | (LcdNibble & 0xF0), LCD_DATA_PORT); // prepare databus with nibble to write
-
-    if (CtrlState == WRITE_COMMAND)
-    {
-        cbi(LCD_RS_PORT, LCD_RS);     // command: RS low
-    }
-    else
-    {
-        sbi(LCD_RS_PORT, LCD_RS);     // data: RS high
-    }
-
-    sbi(LCD_EN_PORT, LCD_EN);
-
-    asm("nop\n\tnop");                    // small delay
-
-    cbi(LCD_EN_PORT, LCD_EN);
-    cbi(LCD_RS_PORT, LCD_RS);
-    outp((inp(LCD_DATA_DDR) & 0x0F), LCD_DATA_DDR);           // set upper 4-bits of data-port to input
-    outp((inp(LCD_DATA_PORT) & 0x0F) | 0xF0, LCD_DATA_PORT);  // enable pull-ups in data-port
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Low-level routine to see if the controller is ready to receive
- *
- * This routine repeatetly reads the databus and checks if the highest bit (bit 7)
- * has become '0'. If a '0' is detected on bit 7 the function returns.
- *
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static void LcdWaitBusy()
-{
-    u_char Busy = 1;
-	u_char LcdStatus = 0;
-
-    cbi (LCD_RS_PORT, LCD_RS);              // select instruction register
-
-    sbi (LCD_RW_PORT, LCD_RW);              // we are going to read
-
-    while (Busy)
-    {
-        sbi (LCD_EN_PORT, LCD_EN);          // set 'enable' to catch 'Ready'
-
-        asm("nop\n\tnop");                  // small delay
-        LcdStatus =  inp(LCD_IN_PORT);      // LcdStatus is used elsewhere in this module as well
-        Busy = LcdStatus & 0x80;            // break out of while-loop cause we are ready (b7='0')
-    }
-
-    cbi (LCD_EN_PORT, LCD_EN);              // all ctrlpins low
-    cbi (LCD_RS_PORT, LCD_RS);
-    cbi (LCD_RW_PORT, LCD_RW);              // we are going to write
-}
-
-/* ---------- end of module ------------------------------------------------ */
-
-/*@}*/

ipac-base-27JAN2011/source/fat.c

@@ -1,2154 +0,0 @@
-/****************************************************************************
-*  This file is part of the AVRIDE device driver.
-*
-*  Copyright (c) 2002-2004 by Michael Fischer. All rights reserved.
-*
-*  Redistribution and use in source and binary forms, with or without 
-*  modification, are permitted provided that the following conditions 
-*  are met:
-*  
-*  1. Redistributions of source code must retain the above copyright 
-*     notice, this list of conditions and the following disclaimer.
-*  2. Redistributions in binary form must reproduce the above copyright
-*     notice, this list of conditions and the following disclaimer in the 
-*     documentation and/or other materials provided with the distribution.
-*  3. Neither the name of the author nor the names of its contributors may 
-*     be used to endorse or promote products derived from this software 
-*     without specific prior written permission.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
-*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
-*  THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
-*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
-*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
-*  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
-*  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
-*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
-*  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
-*  SUCH DAMAGE.
-*
-****************************************************************************
-*  History:
-*
-*  14.12.02  mifi   First Version 
-*  23.12.02  mifi   Add FileOpen, FileClose, FileError, FileSize,
-*                   FileSeek and FileRead. But the FileSeek function.
-*                   does not work in the moment, later...
-*  28.12.02  mifi   Now support FAT16 AND FAT32.
-*  01.01.03  mifi   Support long directory entries, but without to 
-*                   check the checksum of the short entry.
-*                   Change FAT32FileSize return value from int to long.
-*                   The max size of a long filename segment is
-*                   (FAT_LONG_NAME_LEN-1). But the complete filename can
-*                   be longer. 
-*
-*                   segment1/segment2/segment3/index.html
-*
-*                   segmentX max length = (FAT_LONG_NAME_LEN-1)
-*
-*  04.01.03  mifi   Take a look at the return values...
-*  18.01.03  mifi   Change Licence from GPL to BSD.
-*  25.01.03  mifi   Implement a new FindFile function.
-*                   I have some trouble with short file names under
-*                   Win98. Win98 store a short name like "enlogo.gif"
-*                   as a long name, nasty OS. 
-*                   Remove FAT32_MAX_FILES and the array aFileHandle,
-*                   a file handle will now be allocated by NutHeapAlloc, 
-*                   therefore we have no restrictions about the count of 
-*                   the open file handle. (Only by available memory)
-*  27.01.03  mifi   Rename all FAT32xxx function to FATxxx.
-*
-*  28.01.03  mifi   Start porting to Nut/OS 3.X.X
-*  19.06.03  mifi   Change the call of IDEInit, now we use the BaseAddress
-*                   of 0. Because the fat module does not need to know the
-*                   address. It will be handled in ide.c.
-*  29.06.03  mifi   First ATAPI-Version
-*                   Now we can read files from a CD-ROM. But there exist
-*                   some open points:
-*                   - only first session from a multisession CD is supported
-*                   - only iso9660, no Joliet support now, later
-*  24.07.04  mifi   Some changes to support more than one drive (datanut)
-*  25.07.04  mifi   Add support for the PCMCIA_11 hardware.
-*  27.07.04  mifi   Start to add functionality for write function.
-*  03.08.04  mifi   Add format function.
-****************************************************************************/
-#define __FAT_C__
-
-#define LOG_MODULE  LOG_FAT_MODULE
-
-#include <string.h>
-#include <stddef.h>
-#include <ctype.h>
-#include <time.h>
-
-#include <sys/heap.h>
-#include <sys/event.h>
-#include <sys/thread.h>
-
-#include <sys/device.h>
-
-#include "typedefs.h"
-
-#include "fat.h"
-#include "fatdrv.h"
-#include "portio.h"
-#include "log.h"
-
-
-/*==========================================================*/
-/*  DEFINE: All Structures and Common Constants             */
-/*==========================================================*/
-//
-// FAT return codes
-//
-#define FAT_OK                0
-#define FAT_ERROR             -1
-#define FAT_ERROR_EOF         -2
-#define FAT_ERROR_IDE         -3
-
-//
-// Define for correct return values Nut/OS
-//
-#define NUTDEV_OK                       0
-#define NUTDEV_ERROR                    -1
-#define NUTDEV_WRONG_HW                 -2
-
-#define FAT_MAX_DRIVE                   3
-
-//
-// Some defines for the FAT structures
-//
-#define ZIP_DRIVE_BR_SECTOR             32
-
-#define BPB_RsvdSecCnt                  32
-#define BPB_NumFATs                     2
-#define BPB_HiddSec                     63
-
-#define FAT32_MEDIA                     0xf8
-#define FAT32_SECTOR_SIZE               HW_SECTOR_SIZE
-
-#define FAT32_OFFSET_FSINFO             1
-#define FAT32_OFFSET_BACKUP_BOOT        6
-
-#define FAT16_CLUSTER_EOF               0x0000FFFF
-#define FAT16_CLUSTER_ERROR             0x0000FFF7
-#define FAT16_CLUSTER_MASK              0x0000FFFF
-
-#define FAT32_CLUSTER_EOF               0x0FFFFFFF
-#define FAT32_CLUSTER_ERROR             0x0FFFFFF7
-#define FAT32_CLUSTER_MASK              0x0FFFFFFF
-
-#define FAT_SIGNATURE                   0xAA55
-
-#define MBR_SIGNATURE                   FAT_SIGNATURE
-#define MBR_FAT32                       0x0B
-
-#define FSINFO_FIRSTSIGNATURE           0x41615252
-#define FSINFO_FSINFOSIGNATURE          0x61417272
-#define FSINFO_SIGNATURE                FAT_SIGNATURE
-
-#define DIRECTORY_ATTRIBUTE_READ_ONLY   0x01
-#define DIRECTORY_ATTRIBUTE_HIDDEN      0x02
-#define DIRECTORY_ATTRIBUTE_SYSTEM_FILE 0x04
-#define DIRECTORY_ATTRIBUTE_VOLUME_ID   0x08
-#define DIRECTORY_ATTRIBUTE_DIRECTORY   0x10
-#define DIRECTORY_ATTRIBUTE_ARCHIVE     0x20
-
-//
-// DIRECTORY_ATTRIBUTE_READ_ONLY   |
-// DIRECTORY_ATTRIBUTE_HIDDEN      |
-// DIRECTORY_ATTRIBUTE_SYSTEM_FILE |
-// DIRECTORY_ATTRIBUTE_VOLUME_ID
-//
-#define DIRECTORY_ATTRIBUTE_LONG_NAME   0x0F
-
-//
-// DIRECTORY_ATTRIBUTE_READ_ONLY   |
-// DIRECTORY_ATTRIBUTE_HIDDEN      |
-// DIRECTORY_ATTRIBUTE_SYSTEM_FILE |
-// DIRECTORY_ATTRIBUTE_VOLUME_ID   |
-// DIRECTORY_ATTRIBUTE_DIRECTORY   |
-// DIRECTORY_ATTRIBUTE_ARCHIVE
-// 
-#define DIRECTORY_ATTRIBUTE_LONG_NAME_MASK  0x3F
-
-#define FAT_NAME_LEN                    8
-#define FAT_EXT_LEN                     3
-
-//
-// FAT_SHORT_NAME_LEN name len = 
-// name + ext + 1 for the point
-//
-#define FAT_SHORT_NAME_LEN              (FAT_NAME_LEN+FAT_EXT_LEN+1)
-#define FAT_LONG_NAME_LEN               64
-
-
-//
-// Some stuff for HD and CD, DRIVE_INFO Flags
-// 
-//
-#define FLAG_FAT_IS_CDROM               0x0001
-#define FLAG_FAT_IS_ZIP                 0x0002
-
-//
-//  DiskSize to SectorPerCluster table
-//
-typedef struct
-{
-    DWORD DiskSize;
-    BYTE  SecPerClusVal;
-} DSKSZTOSECPERCLUS;
-
-typedef struct _FAT32FileDataTime
-{
-    unsigned Seconds:5;
-    unsigned Minute:6;
-    unsigned Hour:5;
-    unsigned Day:5;
-    unsigned Month:4;
-    unsigned Year:7;
-} FAT32_FILEDATETIME, *PFAT32_FILEDATETIME;
-
-typedef struct _FAT32DirectoryEntry
-{
-    BYTE               Name[FAT_NAME_LEN];
-    BYTE               Extension[FAT_EXT_LEN];
-    BYTE               Attribute;
-    BYTE               Reserved[8];
-    WORD               HighCluster;
-    FAT32_FILEDATETIME Date;
-    WORD               LowCluster;
-    DWORD              FileSize;
-} FAT32_DIRECTORY_ENTRY;
-
-typedef struct _FAT32DirectoryEntryLong
-{
-    BYTE Order;
-    WORD Name1[5];
-    BYTE Attribute;
-    BYTE Type;
-    BYTE Chksum;
-    WORD Name2[6];
-    WORD LowCluster;
-    WORD Name3[2];
-} FAT32_DIRECTORY_ENTRY_LONG;
-
-typedef struct _FAT32FileSystemInformation
-{
-    DWORD FirstSignature;
-    BYTE  Reserved1[480];
-    DWORD FSInfoSignature;
-    DWORD NumberOfFreeClusters;
-    DWORD MostRecentlyAllocatedCluster;
-    BYTE  Reserved2[12];
-    BYTE  Reserved3[2];
-    WORD  Signature;
-} FAT32_FSINFO;
-
-typedef struct _FAT32PartitionEntry
-{
-    BYTE  BootInd;
-    BYTE  FirstHead;
-    BYTE  FirstSector;
-    BYTE  FirstTrack;
-    BYTE  FileSystem;
-    BYTE  LastHead;
-    BYTE  LastSector;
-    BYTE  LastTrack;
-    DWORD StartSectors;
-    DWORD NumSectors;
-} FAT32_PARTITION_ENTRY;
-
-typedef struct _FAT32PartionTable
-{
-    BYTE                  LoadInstruction[446];
-    FAT32_PARTITION_ENTRY Partition[4];
-    WORD                  Signature;               /* AA55 */
-} FAT32_PARTITION_TABLE;
-
-typedef struct _bpbfat16
-{
-    BYTE  DrvNum;
-    BYTE  Reserved1;
-    BYTE  BootSig;
-    DWORD VollID;
-    BYTE  VolLab[11];
-    BYTE  FilSysType[8];
-    BYTE  Reserved2[28];
-} BPBFAT16;
-
-typedef struct _bpbfat32
-{
-    DWORD FATSz32;          // xxx
-    WORD  ExtFlags;         // 0
-    WORD  FSVer;            // must 0
-    DWORD RootClus;         // 
-    WORD  FSInfo;           // typically 1
-    WORD  BkBootSec;        // typically 6
-    BYTE  Reserved[12];     // set all to zero
-    BYTE  DrvNum;           // must 0x80
-    BYTE  Reserved1;        // set all to zero
-    BYTE  BootSig;          // must 0x29 
-    DWORD VollID;           // xxx
-    BYTE  VolLab[11];       // "abcdefghijk"
-    BYTE  FilSysType[8];    // "FAT32   "
-} BPBFAT32;
-
-typedef union _bpboffset36
-{
-    BPBFAT16 FAT16;
-    BPBFAT32 FAT32;
-} BPBOFFSET36;
-
-typedef struct _FAT32BootRecord
-{
-    BYTE        JumpBoot[3];    // 0xeb, 0x58, 0x90
-    BYTE        OEMName[8];     // "MSWIN4.1"
-    WORD        BytsPerSec;     // must 512
-    BYTE        SecPerClus;     // 8 for 4K cluster
-    WORD        RsvdSecCnt;     // typically 32 for FAT32
-    BYTE        NumFATs;        // always 2
-    WORD        RootEntCnt;     // must 0 for FAT32
-    WORD        TotSec16;       // must 0 for FAT32
-    BYTE        Media;          // must 0xf8
-
-    WORD        FATSz16;        // 0   for FAT32
-    WORD        SecPerTrk;      // 63  for FAT32
-    WORD        NumHeads;       // 255 for FAT32
-    DWORD       HiddSec;        // 63  for FAT32
-
-    DWORD       TotSec32;       // xxx
-
-    BPBOFFSET36 Off36;
-
-    BYTE        Reserved[420];
-    WORD        Signature;      // must 0xAA55
-} FAT32_BOOT_RECORD, *PFAT32_BOOT_RECORD;
-
-typedef struct _fat_entry_table16
-{
-    WORD aEntry[256];
-} FAT_ENTRY_TABLE16;
-
-typedef struct _fat_entry_table32
-{
-    DWORD aEntry[128];
-} FAT_ENTRY_TABLE32;
-
-typedef union _fat_dir_table
-{
-    FAT32_DIRECTORY_ENTRY      aShort[16];
-    FAT32_DIRECTORY_ENTRY_LONG aLong[16];
-} FAT_DIR_TABLE;
-
-typedef struct _drive_info
-{
-    BYTE  bIsFAT32;
-    BYTE  bDevice;
-    BYTE  bSectorsPerCluster;
-    BYTE  bFlags;
-
-    WORD  wSectorSize;
-
-    DWORD dwRootDirSectors;
-    DWORD dwFirstRootDirSector;
-
-    DWORD dwRootCluster;
-    DWORD dwFAT1StartSector;
-    DWORD dwFAT2StartSector;
-    DWORD dwCluster2StartSector;
-
-    DWORD dwClusterSize;
-} DRIVE_INFO;
-
-typedef struct _fhandle
-{
-    DWORD      dwFileSize;
-    DWORD      dwStartCluster;
-    DWORD      dwReadCluster;
-    DWORD      dwFilePointer;          /* total file pointer   */
-    DWORD      dwClusterPointer;       /* cluster read pointer */
-
-    int         nLastError;
-    int         nEOF;
-
-    DRIVE_INFO *pDrive;
-} FHANDLE;
-
-static int QuickFormat(NUTDEVICE *dev, DRIVE_INFO *pDrive);
-
-/*==========================================================*/
-/*  DEFINE: Definition of all local Data                    */
-/*==========================================================*/
-static int        nIsInit = FALSE;
-
-static BYTE      *pSectorBuffer = NULL;
-static char      *pLongName1 = NULL;
-static char      *pLongName2 = NULL;
-static DRIVE_INFO sDriveInfo[FAT_MAX_DRIVE];
-
-static HANDLE hFATSemaphore;
-
-static DSKSZTOSECPERCLUS DskTableFAT32[] = {
-    {      66600,  0}, /* disks up to 32.5MB, the 0 value for SecPerClusVal trips an error */
-    {     532480,  1}, /* disks up to 260 MB, 0.5k cluster */
-    {   16777216,  8}, /* disks up to   8 GB,   4k cluster */
-    {   33554432, 16}, /* disks up to  16 GB,   8k cluster */
-    {   67108864, 32}, /* disks up to  32 GB,  16k cluster */
-    { 0xFFFFFFFF, 64}  /* disks greather than 32GB, 32k cluster */
-};
-
-#define DSK_TABLE_FAT32_ENTRY_COUNT (sizeof(DskTableFAT32) / sizeof(DSKSZTOSECPERCLUS))
-/*==========================================================*/
-/*  DEFINE: Definition of all local Procedures              */
-/*==========================================================*/
-
-void FATRelease()
-{
-    nIsInit=FALSE;
-}
-/************************************************************/
-/*  FATLock                                                 */
-/************************************************************/
-void FATLock(void)
-{
-    NutEventWait(&hFATSemaphore, 0);
-}
-
-/************************************************************/
-/*  FATFree                                                 */
-/************************************************************/
-void FATFree(void)
-{
-    NutEventPost(&hFATSemaphore);
-}
-
-/************************************************************/
-/*  FATSemaInit                                             */
-/************************************************************/
-void FATSemaInit(void)
-{
-    NutEventPost(&hFATSemaphore);
-}
-
-/************************************************************/
-/*  GetFirstSectorOfCluster                                 */
-/************************************************************/
-static DWORD GetFirstSectorOfCluster(DRIVE_INFO *pDrive, DWORD dwCluster)
-{
-    DWORD dwSector;
-
-    if (pDrive->bFlags & FLAG_FAT_IS_CDROM)
-    {
-        dwSector  = dwCluster;
-    }
-    else
-    {
-        dwSector  = (dwCluster - 2) * pDrive->bSectorsPerCluster;
-        dwSector += pDrive->dwCluster2StartSector;
-    }
-
-    return(dwSector);
-}
-
-/************************************************************/
-/*  GetNextCluster                                          */
-/************************************************************/
-static DWORD GetNextCluster(DRIVE_INFO *pDrive, DWORD dwCluster)
-{
-    DWORD             dwNextCluster;
-    DWORD             dwSector;
-    DWORD             dwIndex;
-    FAT_ENTRY_TABLE16 *pFatTable16;
-    FAT_ENTRY_TABLE32 *pFatTable32;
-
-    if (pDrive->bFlags & FLAG_FAT_IS_CDROM)
-    {
-        dwNextCluster = dwCluster + 1;
-    }
-    else
-    {
-        if (pDrive->bIsFAT32 == TRUE)
-        {
-            //
-            //  (HW_SECTOR_SIZE / sizeof(long)) == 128
-            // 
-            dwSector = (dwCluster / 128) + pDrive->dwFAT1StartSector;
-            dwIndex  = dwCluster % 128;
-
-            HWReadSectors(pDrive->bDevice, pSectorBuffer, dwSector, 1);
-            pFatTable32 = (FAT_ENTRY_TABLE32 *) pSectorBuffer;
-
-            dwNextCluster = (pFatTable32->aEntry[dwIndex] & FAT32_CLUSTER_MASK);
-            if ((dwNextCluster == FAT32_CLUSTER_EOF) || (dwNextCluster == FAT32_CLUSTER_ERROR))
-            {
-                dwNextCluster = 0;
-            }
-
-        }
-        else
-        {  /* FAT16 */
-            //
-            //  (HW_SECTOR_SIZE / sizeof(word)) == 256
-            // 
-            dwSector = (dwCluster / 256) + pDrive->dwFAT1StartSector;
-            dwIndex  = dwCluster % 256;
-
-            HWReadSectors(pDrive->bDevice, pSectorBuffer, dwSector, 1);
-            pFatTable16 = (FAT_ENTRY_TABLE16 *) pSectorBuffer;
-
-            dwNextCluster = (pFatTable16->aEntry[dwIndex] & FAT16_CLUSTER_MASK);
-            if ((dwNextCluster == FAT16_CLUSTER_EOF) || (dwNextCluster == FAT16_CLUSTER_ERROR))
-            {
-                dwNextCluster = 0;
-            }
-
-        } /* endif pDrive->bIsFAT32 */
-    }
-
-    return(dwNextCluster);
-}
-
-/************************************************************/
-/*  GetLongChar                                             */
-/************************************************************/
-static char GetLongChar(WORD wValue)
-{
-    BYTE Value;
-
-    Value = (BYTE)(wValue & 0x00FF);
-    if (Value == 0xFF)
-    {
-        Value = 0;
-    }
-
-    if (Value != 0)
-    {
-        Value = toupper(Value);
-    }
-
-    return((char)Value);
-}
-
-/************************************************************/
-/*  FindFile                                                */
-/*                                                          */
-/*  Find a file by a given name pLongName.                  */
-/*                                                          */
-/*  It is possible that a SHORT name like "enlogo.gif"      */
-/*  is stored as a LONG name. I have seen this              */
-/*  nasty behaviour by Win98. Therefore I will check        */
-/*  the long name too, even if nIsLongName is FALSE.        */
-/************************************************************/
-static DWORD FindFile(DRIVE_INFO            *pDrive,
-                      FAT32_DIRECTORY_ENTRY *pSearchEntry, 
-                      char                  *pLongName,
-                      DWORD                 dwDirCluster, 
-                      DWORD                 *pFileSize, 
-                      int                    nIsLongName)
-{
-    int                       i, x;
-    BYTE                      bError;
-    int                       nNameLen;
-    int                       nMaxLen;
-    BYTE                      bFound;
-    BYTE                      bEndLoop;
-    BYTE                      bOrder;
-    BYTE                      bMaxOrder;
-    int                       nDirMaxSector;
-    DWORD                     dwSector;
-    DWORD                     dwNewCluster;
-    FAT32_DIRECTORY_ENTRY      *pDirEntryShort;
-    FAT32_DIRECTORY_ENTRY_LONG *pDirEntryLong;
-    char                       *pDirName = 0;
-    FAT_DIR_TABLE              *pDirTable;
-
-    bError       = FALSE;
-    *pFileSize   = 0;
-    dwNewCluster = 0;
-
-    nNameLen  = strlen(pLongName);
-
-    bMaxOrder = (BYTE) ((nNameLen + 12) / 13);
-    nMaxLen   = (int) (bMaxOrder * 13);
-    if (nMaxLen >= (FAT_LONG_NAME_LEN - 1))
-    {
-        bError = TRUE;
-    }
-
-    bOrder = (BYTE) (0x40 | bMaxOrder);
-    if (bOrder == 0xE5)
-    {
-        //
-        // I do not know what should I do if the bOrder is 0xe5.
-        // This is a sign for a "empty" entry. 
-        //
-        bError = TRUE;
-    }
-
-    if (bError == FALSE)
-    {
-        bFound   = FALSE;
-        bEndLoop = FALSE;
-        while ((bEndLoop == FALSE) && (dwDirCluster != 0))
-        {
-            dwSector = GetFirstSectorOfCluster(pDrive, dwDirCluster);
-            nDirMaxSector = (int) pDrive->bSectorsPerCluster;
-
-            //
-            // Test for special case dwDirCluster and FAT16.
-            //
-            if ((dwDirCluster == 1) && (pDrive->bIsFAT32 == FALSE))
-            {
-                dwSector = pDrive->dwFirstRootDirSector;
-                nDirMaxSector = (int) pDrive->dwRootDirSectors;
-            }
-            //
-            // One cluster has SecPerCluster sectors.
-            //
-            for (i = 0; i < nDirMaxSector; i++)
-            {
-                HWReadSectors(pDrive->bDevice, pSectorBuffer, dwSector + i, 1);
-                pDirTable = (FAT_DIR_TABLE *) pSectorBuffer;
-
-                //
-                // And one sector has 16 entries.
-                //
-                // HW_SECTOR_SIZE / sizeof(FAT32_DIRECTORY_ENTRY) = 16
-                //
-                for (x = 0; x < 16; x++)
-                {
-                    if (bFound == TRUE)
-                    {
-                        pDirEntryShort = (FAT32_DIRECTORY_ENTRY *) & pDirTable->aShort[x];
-                        dwNewCluster   = pDirEntryShort->HighCluster;
-                        dwNewCluster   = (dwNewCluster << 16) | (DWORD) pDirEntryShort->LowCluster;
-                        *pFileSize     = pDirEntryShort->FileSize;
-                        bEndLoop       = TRUE;
-                        break;
-                    }
-                    //
-                    // Check for valid entry.
-                    //
-                    pDirEntryShort = (FAT32_DIRECTORY_ENTRY *) & pDirTable->aShort[x];
-                    pDirEntryLong = (FAT32_DIRECTORY_ENTRY_LONG *) & pDirTable->aLong[x];
-
-                    if (nIsLongName == FALSE)
-                    {
-                        //
-                        // Check if it could be a short name. If Win2000 tell us it
-                        // is a short name, it is true. But with Win98 we must
-                        // test both, short and long...
-                        //
-                        if ((pDirEntryShort->Name[0] != 0xE5) && (pDirEntryShort->Name[0] != 0x00))
-                        {
-                            if (memcmp(pDirEntryShort, pSearchEntry, 11) == 0)
-                            {
-                                //
-                                // Check for the correct attribute, this is done with
-                                // the '&' and not with the memcmp.
-                                // With the '&' it is possible to find a hidden archive too :-)
-                                //
-                                if ((pDirEntryShort->Attribute & pSearchEntry->Attribute) ==
-                                    pSearchEntry->Attribute)
-                                {
-
-                                    dwNewCluster = pDirEntryShort->HighCluster;
-                                    dwNewCluster = (dwNewCluster << 16) | (DWORD) pDirEntryShort->LowCluster;
-                                    *pFileSize   = pDirEntryShort->FileSize;
-
-                                    bEndLoop = TRUE;
-                                    break;
-
-                                } /* endif Attribute */
-                            } /* endif test Name+Ext */
-                        } /* endif Name[0] != 0xe5, 0x00 */
-                    }
-                    /*
-                     * endif nIsLongName == FALSE 
-                     */
-                    if ((pDirEntryLong->Attribute == DIRECTORY_ATTRIBUTE_LONG_NAME)
-                        && (pDirEntryLong->Order == bOrder))
-                    {
-                        //
-                        // Next bOrder is bOrder--
-                        //  
-                        if (bOrder & 0x40)
-                        {
-                            bOrder &= ~0x40;
-
-                            //
-                            // Get the space for the name.
-                            //
-                            pDirName = pLongName2;
-
-                            //
-                            // Set the end of string.
-                            //
-                            pDirName[nMaxLen--] = 0;
-                        }
-
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name3[1]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name3[0]);
-
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[5]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[4]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[3]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[2]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[1]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name2[0]);
-
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[4]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[3]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[2]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[1]);
-                        pDirName[nMaxLen--] = GetLongChar(pDirEntryLong->Name1[0]);
-
-                        bOrder--;
-                        if (bOrder == 0)
-                        {
-                            //
-                            // Now compare the name.
-                            //
-                            bOrder = (BYTE) (0x40 | bMaxOrder);
-                            nMaxLen = (int) (bMaxOrder * 13);
-                            if (memcmp(pLongName, pDirName, strlen(pLongName)) == 0)
-                            {
-                                //
-                                // The next entry will be the correct entry.
-                                //
-                                bFound = TRUE;
-                            }
-                        }
-                    }
-                    /*
-                     * pDirEntryLong->Order == bOrder 
-                     */
-                } /* endfor x<16 */
-
-                if (bEndLoop == TRUE)
-                {
-                    break;
-                }
-            }
-
-            if (bEndLoop == FALSE)
-            {
-                //
-                // No file found in this cluster, get the next one.
-                //
-                dwDirCluster = GetNextCluster(pDrive, dwDirCluster);
-            }
-        } /* endwhile */
-
-    }
-    /*
-     * endif bError == FALSE 
-     */
-    return(dwNewCluster);
-}
-
-/************************************************************/
-/*  MountHW                                                 */
-/************************************************************/
-static int MountHW(int nDrive)
-{
-    int                    nError;
-    int                    i;
-    DWORD                 dwSector;
-    DWORD                 dwFATSz;
-    DWORD                 dwRootDirSectors;
-    FAT32_PARTITION_TABLE *pPartitionTable;
-    FAT32_BOOT_RECORD     *pBootRecord;
-    DRIVE_INFO            *pDrive;
-
-    nError   = HW_OK;
-    i        = nDrive;
-    pDrive   = &sDriveInfo[nDrive];
-    dwSector = 0;
-
-    if (pDrive->bFlags & FLAG_FAT_IS_ZIP)
-    {
-        dwSector = ZIP_DRIVE_BR_SECTOR;
-    }
-    else
-    {
-        //
-        // Try to find a PartitionTable.
-        // 
-        nError = HWReadSectors(nDrive, pSectorBuffer, 0, 1);
-        if (nError == HW_OK)
-        {
-            pPartitionTable = (FAT32_PARTITION_TABLE *) pSectorBuffer;
-
-            if (pPartitionTable->Signature == FAT_SIGNATURE)
-            {
-                if (pPartitionTable->Partition[0].NumSectors)
-                {
-                    //
-                    // We found a PartitionTable, read BootRecord.
-                    // 
-                    dwSector = pPartitionTable->Partition[0].StartSectors;
-                }
-            }
-        }
-    }
-
-    if (dwSector != 0)
-    {
-        HWReadSectors(i, pSectorBuffer, dwSector, 1);
-        pBootRecord = (FAT32_BOOT_RECORD *) pSectorBuffer;
-
-        //
-        // Test valid BootRecord.
-        //
-        if (pBootRecord->Signature == FAT_SIGNATURE)
-        {
-            pDrive->bSectorsPerCluster = pBootRecord->SecPerClus;
-
-            if (pBootRecord->FATSz16 != 0)
-            {
-                dwFATSz = pBootRecord->FATSz16;
-                pDrive->bIsFAT32 = FALSE;
-                pDrive->dwRootCluster = 1;  /* special value, see */
-                                            /* FindFile           */
-            }
-            else
-            {
-                dwFATSz               = pBootRecord->Off36.FAT32.FATSz32;
-                pDrive->bIsFAT32      = TRUE;
-                pDrive->dwRootCluster = pBootRecord->Off36.FAT32.RootClus;
-            }
-
-            dwRootDirSectors =
-            ((pBootRecord->RootEntCnt * 32) +
-             (pBootRecord->BytsPerSec - 1)) / pBootRecord->BytsPerSec;
-
-            pDrive->dwFAT1StartSector = pBootRecord->HiddSec + pBootRecord->RsvdSecCnt;
-            pDrive->dwFAT2StartSector = pDrive->dwFAT1StartSector + dwFATSz;
-
-            pDrive->dwCluster2StartSector =
-            pBootRecord->HiddSec + pBootRecord->RsvdSecCnt +
-            (pBootRecord->NumFATs * dwFATSz) + dwRootDirSectors;
-
-            pDrive->dwClusterSize = pBootRecord->SecPerClus * pDrive->wSectorSize;
-
-            pDrive->dwRootDirSectors = dwRootDirSectors;
-            pDrive->dwFirstRootDirSector = pDrive->dwFAT2StartSector + dwFATSz;
-
-        } /* endif pBootRecord->Signature */
-    }
-    /*
-     * endif dwSector != 0 
-     */
-    return(nError);
-}
-
-/************************************************************/
-/*  MountAllDrives                                          */
-/************************************************************/
-static int MountDrive(BYTE bDrive)
-{
-    int nError;
-
-    nError = HW_OK;
-
-    FATLock();
-
-    if (pLongName1 == NULL)
-    {
-        pLongName1 = (char *)NutHeapAlloc(FAT_LONG_NAME_LEN);
-    }
-    if (pLongName2 == NULL)
-    {
-        pLongName2 = (char *)NutHeapAlloc(FAT_LONG_NAME_LEN);
-    }
-    if (pSectorBuffer == NULL)
-    {
-        pSectorBuffer = (BYTE *)NutHeapAlloc(MAX_SECTOR_SIZE);
-    }
-
-    if ((pSectorBuffer != NULL) && (pLongName1 != NULL) && (pLongName2 != NULL))
-    {
-        memset((BYTE *) & sDriveInfo[bDrive], 0x00, sizeof(DRIVE_INFO));
-
-        sDriveInfo[bDrive].bDevice     = bDrive;
-        sDriveInfo[bDrive].wSectorSize = HWGetSectorSize(bDrive);
-
-        if (HWIsCDROMDevice(bDrive) == TRUE)
-        {
-            sDriveInfo[bDrive].bFlags |= FLAG_FAT_IS_CDROM;
-        }
-
-        if (HWIsZIPDevice(bDrive) == TRUE)
-        {
-            sDriveInfo[bDrive].bFlags |= FLAG_FAT_IS_ZIP;
-        }
-
-        switch (sDriveInfo[bDrive].wSectorSize)
-        {
-            case HW_SECTOR_SIZE:{
-                    nError = MountHW(bDrive);
-                    break;
-                }
-            default:{
-                    nError = HW_ERROR;
-                    break;
-                }
-        }
-    }
-    /*
-     * endif pSectorBuffer != NULL 
-     */
-    FATFree();
-
-    return(nError);
-}
-
-/************************************************************/
-/*  MountAllDrives                                          */
-/************************************************************/
-static int MountAllDrives(void)
-{
-    BYTE  i;
-    int  nError = HW_OK;
-
-    for (i = 0; i < FAT_MAX_DRIVE; i++)
-    {
-        MountDrive(i);
-    }
-
-    return(nError);
-}
-
-/*==========================================================*/
-/*  DEFINE: All code exported by the NUTDEVICE              */
-/*==========================================================*/
-/************************************************************/
-/*  FATUnMountDrive                                         */
-/************************************************************/
-static int FATUnMountDrive(int nDrive)
-{
-    int         nError;
-    DRIVE_INFO *pDrive;
-
-    FATLock();
-
-    nError = FAT_OK;
-
-    if ((nDrive >= HW_DRIVE_C) && (nDrive <= HW_DRIVE_D))
-    {
-        pDrive = &sDriveInfo[nDrive];
-        pDrive->bSectorsPerCluster = 0;
-    }
-    else
-    {
-        nError = FAT_ERROR;
-    }
-
-    FATFree();
-
-    return(nError);
-}
-
-/************************************************************/
-/*  CFMount                                                 */
-/************************************************************/
-static void CFMount(int nDrive)
-{
-    BYTE *pSectorBuffer;
-
-    pSectorBuffer = (BYTE *) NutHeapAlloc(MAX_SECTOR_SIZE);
-    if (pSectorBuffer != NULL)
-    {
-        MountDrive(nDrive);
-        NutHeapFree(pSectorBuffer);
-    }
-}
-
-/************************************************************/
-/*  CFUnMount                                               */
-/************************************************************/
-static void CFUnMount(int nDrive)
-{
-    FATUnMountDrive(nDrive);
-}
-
-/************************************************************/
-/*  FATInit                                                 */
-/************************************************************/
-static int FATInit(NUTDEVICE * pDevice)
-{
-    int   nError;
-    int   nHWMode;  
-    BYTE *pSectorBuffer;
-
-    nError        = NUTDEV_ERROR;
-    nHWMode       = 0;
-    pSectorBuffer = NULL;
-
-    if ((nIsInit              == FALSE) && 
-        (pDevice->dev_name[0] == 'F')   &&
-        (pDevice->dev_name[1] == 'A')   &&
-        (pDevice->dev_name[2] == 'T'))
-    {
-        nError = NUTDEV_OK;      
-
-        //
-        // Get the mode.
-        //    
-        switch (pDevice->dev_base)
-        {
-
-#if (FAT_USE_MMC_INTERFACE >= 1)
-            case FAT_MODE_MMC:
-                nHWMode = 0;   
-                break; 
-#endif        
-            default:
-                nError = NUTDEV_ERROR;
-                break;
-        }
-
-        if (nError == NUTDEV_OK)
-        {
-            //
-            // Init my semaphore.
-            //
-            FATSemaInit();
-
-            pSectorBuffer = (BYTE *) NutHeapAlloc(MAX_SECTOR_SIZE);
-            if (pSectorBuffer != NULL)
-            {
-                /*
-                 * HW init
-                 */
-                nError = HWInit(nHWMode, CFMount, CFUnMount);
-                if (nError == HW_OK)
-                {
-                    HWMountAllDevices(nHWMode, pSectorBuffer);
-
-                    /*
-                     * FAT init
-                     */
-                    MountAllDrives();
-
-                    nError  = NUTDEV_OK;
-                    nIsInit = TRUE;    
-                }
-                else
-                {
-                    nError  = NUTDEV_WRONG_HW;
-                }  
-
-                NutHeapFree(pSectorBuffer);
-            } /* endif pSectorBuffer != NULL */
-        } /* endif nError == NUTDEV_OK */
-    }
-    else
-    {
-        if (nIsInit == TRUE)
-        {
-#if (FAT_USE_MMC_INTERFACE >= 1)
-            if ((pDevice->dev_name[0] == 'F')   &&
-                (pDevice->dev_name[1] == 'M')   &&
-                (pDevice->dev_name[2] == '0'))
-            {
-                /*
-                 * Always OK, because the MMC card
-                 * can be inserted later.
-                 */
-                nError = NUTDEV_OK;  
-            }
-#endif /* (FAT_USE_MMC_INTERFACE >= 0) */      
-
-        } /* endif (nIsInit == TRUE) */
-    } /* endif nIsInit == FALSE */
-
-    return(nError);
-}
-
-/************************************************************/
-/*  GetDriveByDevice                                        */
-/************************************************************/
-static DRIVE_INFO* GetDriveByDevice (NUTDEVICE *pDevice)
-{
-    DRIVE_INFO* pDrive = NULL;
-
-    if (pDevice != NULL)
-    {
-        switch (pDevice->dev_name[2])
-        {
-            case 'F':{
-                    pDrive = &sDriveInfo[HW_DRIVE_C];
-                    break;
-                }
-            case '0':{
-                    pDrive = &sDriveInfo[HW_DRIVE_D];
-                    break;
-                }
-            case '1':{
-                    pDrive = &sDriveInfo[HW_DRIVE_E];
-                    break;        
-                }      
-        }
-    }
-
-    return(pDrive);
-}  
-
-/************************************************************/
-/*  FATFileOpen                                             */
-/*                                                          */
-/*  Opens an existing file for reading.                     */
-/*                                                          */
-/*  Parameters: pName points to a string that specifies the */
-/*              name of the file to open. The name must     */
-/*              exactly match the full pathname of the file.*/
-/*                                                          */
-/*  Returns:    A pointer to a FILE structure that can be   */
-/*              used to read the file and retrieve          */
-/*              information about the file.                 */
-/*                                                          */
-/*              A return value of -1 indicates an error.    */
-/************************************************************/
-static NUTFILE *FATFileOpen(NUTDEVICE *pDevice, CONST char *pName, int nMode,
-                            int nAccess)
-{
-    int                    i, x;
-    int                    nError;
-    int                    nEndWhile;
-    DWORD                 dwFileSize;
-    DWORD                 dwCluster;
-    FHANDLE               *hFile;
-    DRIVE_INFO            *pDrive;
-    FAT32_DIRECTORY_ENTRY  sDirEntry;
-    NUTFILE               *hNUTFile;
-    int                    nLongName;
-    char                  *pLongName;
-    char                  *pShortName;
-    char                  *pExtension;
-
-    //
-    // If the user has forgotten to call NUTDeviceOpen,
-    // we must call FATInit.
-    //
-    if (nIsInit == FALSE)
-    {
-        FATInit(pDevice);
-    }
-
-    FATLock();
-
-    pDrive    = NULL;
-    nError    = TRUE;
-    nLongName = FALSE;
-    pLongName = (char *)pLongName1;
-
-    //
-    // hFile is our FAT-Handle.
-    //
-    hFile = NULL;
-
-    //
-    // hNUTFile is the.... correct, NUT handle.
-    //   
-    hNUTFile = (NUTFILE *) NUTDEV_ERROR;
-
-    pDrive = GetDriveByDevice(pDevice);
-
-    if ((pDrive != NULL) && (pDrive->bSectorsPerCluster != 0) && (pName[0] != 0))
-    {
-
-        //
-        // Create a new file handle.
-        //    
-        hFile = (FHANDLE *) NutHeapAlloc(sizeof(FHANDLE));
-
-        if ((pDrive->dwFAT1StartSector) && (hFile != NULL) && (*pName != '.'))
-        {
-
-            memset(hFile, 0x00, sizeof(FHANDLE));
-
-            //
-            // Start by the ROOT dir...
-            //
-            dwCluster = pDrive->dwRootCluster;
-
-            //
-            // If the first char a "/", jump over, e.g. "/index.html"
-            // 
-            //
-            if (*pName == '/')
-            {
-                pName++;
-            }
-
-            nEndWhile = FALSE;
-            while (nEndWhile == FALSE)
-            {  /* master loop */
-
-                nLongName = FALSE;
-
-                //
-                // Get Name
-                //
-                i = 0;
-                while ((*pName != '/') && (*pName != '\\') && (*pName != 0))
-                {
-
-                    if (i >= (FAT_LONG_NAME_LEN - 1))
-                    {
-                        nEndWhile = TRUE;
-                        break;
-                    }
-
-                    pLongName[i] = toupper(*pName);
-
-                    i++;
-                    pName++;
-                } /* endwhile Name */
-
-                if (nEndWhile == FALSE)
-                {
-                    pLongName[i] = 0;
-
-                    //
-                    // Check if it is a Long Directory Entry.
-                    // Yes, I know that 'i' is the length of the string.
-                    // But the code is easier to read with the next strlen.
-                    //
-                    if (strlen(pLongName) <= FAT_SHORT_NAME_LEN)
-                    {
-                        //
-                        // It could be a ShortName, but "abc.defg" is possible
-                        // and this is a long name too. Therfore we need some tests.
-                        //
-                        pExtension = strchr(pLongName, '.');
-                        if (pExtension == NULL)
-                        {
-                            if (strlen(pLongName) > FAT_NAME_LEN)
-                            {
-                                nLongName = TRUE;
-                            }
-                            else
-                            {
-                                nLongName = FALSE;
-                            }
-                        }
-                        else
-                        {
-                            //
-                            // Check the length of the extensions.
-                            //
-                            pExtension++; /* jump over the '.' */
-                            if (strlen(pExtension) > 3)
-                            {
-                                nLongName = TRUE;
-                            }
-                        }
-                    }
-                    else
-                    {  /* Len > FAT_SHORT_NAME_LEN */
-                        //
-                        // Now we have a LongName, sure.
-                        // See the "nasty Win98" in FindFile :-)
-                        //
-                        nLongName = TRUE;
-                    }
-
-                    //
-                    // Here we knows, if we have a LongName or ShortName.
-                    //
-                    if (nLongName == FALSE)
-                    {
-                        //
-                        // ShortName
-                        //
-                        pShortName = pLongName;
-                        memset(&sDirEntry, 0x00, sizeof(FAT32_DIRECTORY_ENTRY));
-                        memset(sDirEntry.Name, 0x20, FAT_NAME_LEN);
-                        memset(sDirEntry.Extension, 0x20, FAT_EXT_LEN);
-
-                        //
-                        // Get the name
-                        //
-                        i = 0;
-                        while ((pShortName[i] != '.') && (pShortName[i] != 0))
-                        {
-                            sDirEntry.Name[i] = pShortName[i];
-                            i++;
-                        }
-                        //
-                        // And the extension
-                        //
-                        if (pShortName[i] == '.')
-                        {
-                            i++;  /* jump over the '.' */
-                            x = 0;
-                            while (pShortName[i] != 0)
-                            {
-                                sDirEntry.Extension[x] = pShortName[i];
-                                i++;
-                                x++;
-                            }
-                        }
-                    }
-                    //
-                    // The file could be a long or short one.
-                    // I have seen that Win98 store the short filename
-                    // in a long one :-(
-                    //
-                    switch (*pName)
-                    {
-                        //
-                        // The file is an ARCHIVE
-                        //
-                        case 0:{
-                                nEndWhile = TRUE;
-                                sDirEntry.Attribute = DIRECTORY_ATTRIBUTE_ARCHIVE;
-
-                                if (pDrive->bFlags & FLAG_FAT_IS_CDROM)
-                                {
-                                    dwCluster = 0;
-                                }
-                                else
-                                {
-                                    dwCluster =
-                                    FindFile(pDrive, &sDirEntry, pLongName, dwCluster, &dwFileSize,
-                                             nLongName);
-                                }
-                                if (dwCluster != 0)
-                                {
-                                    hFile->dwFileSize       = dwFileSize;
-                                    hFile->dwStartCluster   = dwCluster;
-                                    hFile->dwReadCluster    = dwCluster;
-                                    hFile->dwFilePointer    = 0;
-                                    hFile->dwClusterPointer = 0;
-                                    hFile->pDrive           = pDrive;
-                                    hFile->nLastError       = FAT_OK;
-                                    hFile->nEOF             = FALSE;
-
-                                    nError                  = FALSE;
-                                }
-                                break;
-                            } /* endcase 0 */
-
-                            //
-                            // The file is a DIRECTORY
-                            //
-                        case '/':
-                        case '\\':{
-                                pName++;  /* jump over the char */
-
-                                sDirEntry.Attribute = DIRECTORY_ATTRIBUTE_DIRECTORY;
-
-                                if (pDrive->bFlags & FLAG_FAT_IS_CDROM)
-                                {
-                                    dwCluster = 0;
-                                }
-                                else
-                                {
-                                    dwCluster =
-                                    FindFile(pDrive, &sDirEntry, pLongName, dwCluster, &dwFileSize,
-                                             nLongName);
-                                }
-                                if (dwCluster != 0)
-                                {
-
-                                    //
-                                    // The new Cluster is the Cluster of the directory
-                                    //
-
-                                }
-                                else
-                                {
-                                    nEndWhile = TRUE;
-                                }
-                                break;
-                            } /* endcase / \ */
-
-                        default:{
-                                nEndWhile = TRUE;
-                                break;
-                            }
-                    } /* end switch */
-
-                }
-                /*
-                 * endif nEndWhile == FALSE 
-                 */
-            } /* end while */
-
-        }
-        /*
-         * endif pDrive->dwFAT1StartSector 
-         */
-        if (nError == TRUE)
-        {
-            //
-            // We found no file, therefore we can delete our FAT-Handle
-            //
-            if (hFile != NULL)
-            {
-                NutHeapFree(hFile);
-            }
-        }
-        else
-        {
-            //
-            // We have found a FILE and can create a NUT-Handle.
-            //
-            hNUTFile = NutHeapAlloc(sizeof(NUTFILE));
-            if (hNUTFile != NULL)
-            {
-                hNUTFile->nf_next = 0;
-                hNUTFile->nf_dev  = pDevice;
-                hNUTFile->nf_fcb  = hFile;
-            }
-            else
-            {
-                //
-                // Error, no mem for the NUT-Handle, therefore we 
-                // can delete our FAT-Handle too.
-                //
-                NutHeapFree(hFile);
-            }
-        }
-
-    }
-    /*
-     * endif pName[0] != 0 
-     */
-    FATFree();
-
-    return(hNUTFile);
-}
-
-/************************************************************/
-/*  FATFileClose                                            */
-/*                                                          */
-/*  Close a previously opened file.                         */
-/*                                                          */
-/*  Parameters: hNUTFile Identifies the file to close.      */
-/*              This pointer must have been created by      */
-/*              calling FAT32FileOpen().                    */
-/*                                                          */
-/*  Returns:    0 if the function is successfully closed,   */
-/*              -1 otherwise.                               */
-/************************************************************/
-static int FATFileClose(NUTFILE * hNUTFile)
-{
-    int      nError;
-    FHANDLE *hFile;
-
-    nError = NUTDEV_ERROR;
-
-    FATLock();
-
-    if (hNUTFile != NULL)
-    {
-        hFile = (FHANDLE *) hNUTFile->nf_fcb;
-        if (hFile != NULL)
-        {
-            //
-            // Clear our FAT-Handle
-            //
-            NutHeapFree(hFile);
-        }
-        //
-        // Clear the NUT-Handle
-        //
-        NutHeapFree(hNUTFile);
-
-        nError = NUTDEV_OK;
-    }
-
-    FATFree();
-
-    return(nError);
-}
-
-/************************************************************/
-/*  FATFileSize                                             */
-/*                                                          */
-/*  Retrieve the size of a file.                            */
-/*                                                          */
-/*  Parameters: pFile Identifies the file to query.         */
-/*              This pointer must have been created by      */
-/*              calling FAT32FileOpen().                    */
-/*                                                          */
-/*  Returns:    The number of bytes in this file or         */
-/*              -1 if an error occured                      */
-/************************************************************/
-long FATFileSize(NUTFILE * hNUTFile)
-{
-    long     lSize;
-    FHANDLE *hFile;
-
-    FATLock();
-
-    lSize = NUTDEV_ERROR;
-
-    if (hNUTFile != NULL)
-    {
-        hFile = (FHANDLE *) hNUTFile->nf_fcb;
-        if (hFile != NULL)
-        {
-            lSize = hFile->dwFileSize;
-        }
-    }
-
-    FATFree();
-
-    return(lSize);
-}
-
-#if 0
-/************************************************************/
-/*  FATFileSeek                                             */
-/*                                                          */
-/*  Move the file pointer to a new position.                */
-/*  It points to the next byte to be read from a file.      */
-/*  The file pointer is automatically incremented for       */
-/*  each byte read. When the file is opened, it is at       */
-/*  position 0, the beginning of the file.                  */
-/*                                                          */
-/*  Parameters: pFile Identifies the file to seek.          */
-/*              This pointer must have been created by      */
-/*              calling FAT32FileOpen().                    */
-/*                                                          */
-/*              lPos Specifies the new absolute position    */
-/*              of the file pointer.                        */
-/*                                                          */
-/*  Returns:    0 if the function is successful,            */
-/*              -1 otherwise.                               */
-/************************************************************/
-int FATFileSeek(FILE * pFile, long lPos)
-{
-    int      nError = NUTDEV_ERROR;
-    FHANDLE *hFile;
-
-    FATLock();
-
-    hFile = (FHANDLE *) pFile;
-
-    //
-    // We must do some work here...
-    //
-    nError = FAT32_ERROR;
-
-    FATFree();
-
-    return(nError);
-}
-#endif
-
-/************************************************************/
-/*  FATFileRead                                             */
-/*                                                          */
-/*  Read data from a file.                                  */
-/*                                                          */
-/*  Parameters: pFile Identifies the file to read from.     */
-/*              This pointer must have been created by      */
-/*              calling FAT32FileOpen().                    */
-/*                                                          */
-/*              pData Points to the buffer that receives    */
-/*              the data.                                   */
-/*                                                          */
-/*              nSize Specifies the number of bytes to      */
-/*              read from the file.                         */
-/*                                                          */
-/*  Returns:    The number of bytes read from the file or   */
-/*               -1 if an error occured.                    */
-/************************************************************/
-int FATFileRead(NUTFILE * hNUTFile, void *pData, int nSize)
-{
-    int         nError;
-    int         nBytesRead;
-    int         nBytesToRead;
-    FHANDLE    *hFile;
-    DRIVE_INFO *pDrive;
-    BYTE       *pByte;
-    DWORD      dwReadSector;
-    DWORD      dwSector;
-    int         nSectorCount;
-    int         nSectorOffset;
-    WORD        wSectorSize;
-
-    nBytesRead = 0;
-
-    FATLock();
-
-    hFile  = NULL;
-    nError = NUTDEV_ERROR;
-
-    if (hNUTFile != NULL)
-    {
-        hFile = (FHANDLE *) hNUTFile->nf_fcb;
-    }
-
-    if ((hFile != NULL) && (nSize != 0))
-    {
-        if (hFile->dwFilePointer < hFile->dwFileSize)
-        {
-
-            if ((hFile->dwFilePointer + nSize) > hFile->dwFileSize)
-            {
-                nSize = (int) (hFile->dwFileSize - hFile->dwFilePointer);
-            }
-
-            pDrive = (DRIVE_INFO *) hFile->pDrive;
-            pByte  = (BYTE *) pData;
-
-            nBytesRead  = nSize;
-            wSectorSize = pDrive->wSectorSize;
-
-            while (nSize)
-            {
-                dwSector = GetFirstSectorOfCluster(pDrive, hFile->dwReadCluster);
-                nSectorCount = hFile->dwClusterPointer / wSectorSize;
-                nSectorOffset = hFile->dwClusterPointer % wSectorSize;
-
-                //
-                // (Sector + SectorCount) is the sector to read
-                // SectorOffset is the start position in the sector itself
-                //
-                dwReadSector = dwSector + nSectorCount;
-
-                nError = HWReadSectors(pDrive->bDevice, pSectorBuffer, dwReadSector, 1);
-                if (nError == HW_OK)
-                {
-                    //
-                    // Find the size we can read from ONE sector
-                    //
-                    if (nSize > (int) wSectorSize)
-                    {
-                        nBytesToRead = wSectorSize;
-                    }
-                    else
-                    {
-                        nBytesToRead = nSize;
-                    }
-
-                    //
-                    // Test inside a sector
-                    //
-                    if ((nSectorOffset + nBytesToRead) > (int) wSectorSize)
-                    {
-                        nBytesToRead = wSectorSize - nSectorOffset;
-                    }
-
-                    memcpy(pByte, &pSectorBuffer[nSectorOffset], nBytesToRead);
-                    pByte += nBytesToRead;
-
-                    hFile->dwFilePointer    += nBytesToRead;
-                    hFile->dwClusterPointer += nBytesToRead;
-
-                    //
-                    // Check for EOF
-                    if (hFile->dwFilePointer >= hFile->dwFileSize)
-                    {
-                        hFile->nEOF = TRUE;
-                    }
-
-                    if (hFile->dwClusterPointer >= pDrive->dwClusterSize)
-                    {
-                        //
-                        // We must switch to the next cluster
-                        //
-                        hFile->dwReadCluster = GetNextCluster(pDrive, hFile->dwReadCluster);
-                        hFile->dwClusterPointer = 0;
-                    }
-
-                    nSize -= nBytesToRead;
-
-                }
-                else
-                {  /* HWReadSectors Error */
-
-                    nBytesRead = 0;
-                    hFile->nLastError = FAT_ERROR_IDE;
-                    break;
-                } /* endif nError == HW_OK */
-
-            } /* endwhile */
-
-        }
-        else
-        {  /* reached the EOF */
-            hFile->nLastError = FAT_ERROR_EOF;
-        } /* endif hFile->dwFilePointer < hFile->dwFileSize */
-
-    }
-    /*
-     * endif (hFile != NULL) && (nSize != 0) 
-     */
-    FATFree();
-
-    return(nBytesRead);
-}
-
-/************************************************************/
-/*  FATFileWrite                                            */
-/*                                                          */
-/*  Write data to a file.                                   */
-/*                                                          */
-/*  Parameters: pFile Identifies the file to write to.      */
-/*              This pointer must have been created by      */
-/*              calling FAT32FileOpen().                    */
-/*                                                          */
-/*              pData Points to the buffer that holds       */
-/*              the data.                                   */
-/*                                                          */
-/*              nSize Specifies the number of bytes to      */
-/*              write to the file.                          */
-/*                                                          */
-/*  Returns:    The number of bytes written to the file or  */
-/*               -1 if an error occured.                    */
-/************************************************************/
-static int FATFileWrite(NUTFILE * hNUTFile, CONST void *pData, int nSize)
-{
-    int nError;
-
-    nError = NUTDEV_ERROR;
-
-    return(nError);
-}
-
-#ifdef __HARVARD_ARCH__
-static int FATFileWriteP(NUTFILE * hNUTFile, PGM_P pData, int nSize)
-{
-    int nError;
-
-    nError = NUTDEV_ERROR;
-
-    return(nError);
-}
-#endif
-
-/************************************************************/
-/*  FATIOCtl                                                */
-/*                                                          */
-/*  Perform IOCTL control functions.                        */
-/*                                                          */
-/*  reg May be set to one of the following constants:       */
-/*                                                          */
-/*  Parameters: dev  Identifies the device to use.          */
-/*              reg  Requested control function.            */
-/*              conf Points to a buffer that contains any   */
-/*                   data required for the given control    */
-/*                   function or receives data from that    */
-/*                   function.                              */
-/*  Returns:    0 on success, or -1 if an error occured.    */
-/************************************************************/
-int FATIOCtl(NUTDEVICE *dev, int req, void *conf)
-{
-    int         nError = NUTDEV_ERROR;
-    DRIVE_INFO *pDrive = GetDriveByDevice(dev);
-
-    if (pDrive != NULL)
-    {
-        switch (req)
-        {
-
-#if (FAT_SUPPORT_FORMAT >= 1)    
-            case FAT_IOCTL_QUICK_FORMAT: {
-                    nError = QuickFormat(dev, pDrive);
-                    break;
-                }
-#endif
-
-            default: {
-                    nError = NUTDEV_ERROR;
-                    break; 
-                }
-
-        }  
-    }
-
-    return(nError);
-}
-
-//
-// FAT Device information structure.
-// Is mapped to the FAT-Device.
-// The user MUST first register the FAT hardware.
-//
-NUTDEVICE devFAT = {
-    0,              /* Pointer to next device. */
-
-    /*
-     * Unique device name.     
-     */
-    {'F', 'A', 'T', 0, 0, 0, 0, 0, 0},
-
-    IFTYP_STREAM,   /* Type of device.                   */
-    2,              /* Base address.                     */
-    0,              /* First interrupt number.           */
-    0,              /* Interface control block.          */
-    0,              /* Driver control block.             */
-    FATInit,        /* Driver initialization routine.    */
-    0,              /* Driver specific control function. */
-    0,              /* Driver specific read function.    */
-    0,              /* Driver specific write function.   */
-
-#ifdef __HARVARD_ARCH__
-    0,              /* Driver specific write_p function. */
-#endif
-
-    0,              /* Driver specific open function.    */
-    0,              /* Driver specific close function.   */
-    0
-};
-
-#if (FAT_USE_MMC_INTERFACE >= 1)
-//
-// FATUSB Device information structure.
-// Is mapped to the first USB drive
-//
-NUTDEVICE devFATMMC0 = {
-    0,              /* Pointer to next device. */
-
-    /*
-     * Unique device name.     
-     */
-    {'F', 'M', '0', 0, 0, 0, 0, 0, 0},
-
-    IFTYP_STREAM,   /* Type of device.                   */
-    2,              /* Base address.                     */
-    0,              /* First interrupt number.           */
-    0,              /* Interface control block.          */
-    0,              /* Driver control block.             */
-    FATInit,        /* Driver initialization routine.    */
-    FATIOCtl,       /* Driver specific control function. */
-    FATFileRead,    /* Driver specific read function.    */
-    FATFileWrite,   /* Driver specific write function.   */
-
-#ifdef __HARVARD_ARCH__
-    FATFileWriteP,  /* Driver specific write_p function. */
-#endif
-
-    FATFileOpen,    /* Driver specific open function.    */
-    FATFileClose,   /* Driver specific close function.   */
-    FATFileSize
-};
-#endif /* (FAT_USE_MMC_INTERFACE >= 1) */
-
-
-#if (FAT_SUPPORT_FORMAT >= 1)
-/************************************************************/
-/*  GetClusterSize                                          */
-/************************************************************/
-static BYTE GetClusterSize (DWORD dTotalSectors)
-{
-    BYTE bIndex;
-    BYTE bSecPerClus = 0;
-
-    for (bIndex=0; bIndex<DSK_TABLE_FAT32_ENTRY_COUNT; bIndex++)
-    {
-        if (dTotalSectors <= DskTableFAT32[bIndex].DiskSize)
-        {
-            bSecPerClus = DskTableFAT32[bIndex].SecPerClusVal;
-            break;      
-        }
-    }
-
-    return(bSecPerClus);
-}
-
-/************************************************************/
-/*  QuickFormat                                             */
-/************************************************************/
-static int QuickFormat(NUTDEVICE *dev, DRIVE_INFO *pDrive)
-{
-    DWORD                   i;
-    int                    nError = NUTDEV_ERROR;
-    BYTE                  *pBuffer;
-    BYTE                   bDevice;
-    BYTE                   bSecPerClus;  
-    DWORD                  dSector;
-    DWORD                  dFirstDataSector;
-    DWORD                  dLastDataSector;
-    DWORD                  dMaxClusterCount;
-    DWORD                  dFAT1StartSector=0;
-    DWORD                  dFAT2StartSector=0;
-    DWORD                  dCluster2StartSector;
-    DWORD                  dClearCount;
-    DWORD                  dTotalSectors;
-    DWORD                  dPossibleClusterCount;
-    DWORD                  dFATSz32;
-    FAT32_PARTITION_TABLE *pPartitionTable;  
-    FAT32_BOOT_RECORD     *pBootRecord;
-    FAT32_FSINFO          *pFSInfo;
-    FAT32_DIRECTORY_ENTRY *pDirEntry;
-    LONG                  *pLong;
-    DWORD                  dVollID;
-
-    FATLock();
-
-    /*
-     * Get the sector buffer
-     */  
-    pBuffer = (u_char *)NutHeapAlloc(pDrive->wSectorSize);
-    if (pBuffer != NULL)
-    {
-
-        bDevice        = pDrive->bDevice;    
-        dTotalSectors  = HWGetTotalSectors(bDevice);
-        dTotalSectors -= BPB_RsvdSecCnt;
-
-        bSecPerClus = GetClusterSize(dTotalSectors);     
-        if (bSecPerClus == 0)
-        {
-            /*
-             * Sorry, to small for FAT32,
-             * the lib will support FAT16 later....
-             */
-            NutHeapFree(pBuffer);  
-            return(NUTDEV_ERROR);    
-        }
-
-        dPossibleClusterCount = (dTotalSectors / (LONG)bSecPerClus);
-
-        dFATSz32              = (dPossibleClusterCount * sizeof(long) + 
-                                 (FAT32_SECTOR_SIZE -1) ) / FAT32_SECTOR_SIZE; 
-
-        /*
-         * First we will clear the sectors which we will use
-         * for the MBR, BPB and the FA's.
-         */
-        dClearCount  = BPB_HiddSec + BPB_RsvdSecCnt;
-        dClearCount += (BPB_NumFATs * dFATSz32) + bSecPerClus;
-
-        memset(pBuffer, 0x00, pDrive->wSectorSize);        
-        for (i=0; i<dClearCount; i++)
-        {
-            nError = HWWriteSectors(bDevice, pBuffer, i, 1);    
-            if (nError != HW_OK)
-            {
-                break;
-            }
-        }
-
-        /*
-         * Create the Volume serial number,
-         * we have no random value, therefore
-         * use the dTotalSectors and time.
-         */
-        dVollID = (DWORD)time(NULL) * dTotalSectors;
-
-        /*
-         * Create MBR (MasterBootRecord)
-         */
-        memset(pBuffer, 0x00, pDrive->wSectorSize);
-        pPartitionTable = (FAT32_PARTITION_TABLE *)pBuffer;
-
-        pPartitionTable->Partition[0].BootInd      = 0x00;
-        pPartitionTable->Partition[0].FirstHead    = 1;
-        pPartitionTable->Partition[0].FirstSector  = 1;
-        pPartitionTable->Partition[0].FirstTrack   = 0;
-        pPartitionTable->Partition[0].FileSystem   = MBR_FAT32;
-        pPartitionTable->Partition[0].LastHead     = 0;
-        pPartitionTable->Partition[0].LastSector   = 0;
-        pPartitionTable->Partition[0].StartSectors = BPB_HiddSec;
-        pPartitionTable->Partition[0].NumSectors   = dTotalSectors;
-        pPartitionTable->Signature                 = MBR_SIGNATURE;
-
-        /*
-         * Write the MBR to the drive
-         */
-        nError = HWWriteSectors(bDevice, pBuffer, 0, 1);    
-        if (nError == HW_OK)
-        {
-            /*
-             * Create the BPB
-             */
-            memset(pBuffer, 0x00, pDrive->wSectorSize);
-            pBootRecord = (FAT32_BOOT_RECORD *)pBuffer;
-
-            pBootRecord->JumpBoot[0] = 0xEB;
-            pBootRecord->JumpBoot[1] = 0x58;
-            pBootRecord->JumpBoot[2] = 0x90;
-
-            pBootRecord->OEMName[0]  = 'M';
-            pBootRecord->OEMName[1]  = 'S';
-            pBootRecord->OEMName[2]  = 'D';
-            pBootRecord->OEMName[3]  = 'O';
-            pBootRecord->OEMName[4]  = 'S';
-            pBootRecord->OEMName[5]  = '5';
-            pBootRecord->OEMName[6]  = '.';
-            pBootRecord->OEMName[7]  = '0';
-
-            pBootRecord->BytsPerSec  = FAT32_SECTOR_SIZE;
-            pBootRecord->SecPerClus  = bSecPerClus;
-            pBootRecord->RsvdSecCnt  = BPB_RsvdSecCnt;
-            pBootRecord->NumFATs     = BPB_NumFATs;
-            pBootRecord->RootEntCnt  = 0;
-            pBootRecord->TotSec16    = 0;
-            pBootRecord->Media       = FAT32_MEDIA;      
-
-            pBootRecord->FATSz16     = 0;
-            pBootRecord->SecPerTrk   = 63;
-            pBootRecord->NumHeads    = 255;
-
-            pBootRecord->HiddSec     = BPB_HiddSec;
-            pBootRecord->TotSec32    = dTotalSectors;
-
-            pBootRecord->Off36.FAT32.FATSz32       = dFATSz32;
-            pBootRecord->Off36.FAT32.ExtFlags      = 0;
-            pBootRecord->Off36.FAT32.FSVer         = 0;
-            pBootRecord->Off36.FAT32.RootClus      = 2;
-            pBootRecord->Off36.FAT32.FSInfo        = FAT32_OFFSET_FSINFO;
-            pBootRecord->Off36.FAT32.BkBootSec     = FAT32_OFFSET_BACKUP_BOOT;
-
-            pBootRecord->Off36.FAT32.DrvNum        = 0x00; 
-            pBootRecord->Off36.FAT32.BootSig       = 0x29;
-            pBootRecord->Off36.FAT32.VollID        = dVollID;
-            pBootRecord->Off36.FAT32.VolLab[0]     = 'N';
-            pBootRecord->Off36.FAT32.VolLab[1]     = 'O';
-            pBootRecord->Off36.FAT32.VolLab[2]     = ' ';
-            pBootRecord->Off36.FAT32.VolLab[3]     = 'N';
-            pBootRecord->Off36.FAT32.VolLab[4]     = 'A'; 
-            pBootRecord->Off36.FAT32.VolLab[5]     = 'M'; 
-            pBootRecord->Off36.FAT32.VolLab[6]     = 'E'; 
-            pBootRecord->Off36.FAT32.VolLab[7]     = ' '; 
-            pBootRecord->Off36.FAT32.VolLab[8]     = ' '; 
-            pBootRecord->Off36.FAT32.VolLab[9]     = ' '; 
-            pBootRecord->Off36.FAT32.VolLab[10]    = ' '; 
-
-            pBootRecord->Off36.FAT32.FilSysType[0] = 'F';
-            pBootRecord->Off36.FAT32.FilSysType[1] = 'A';
-            pBootRecord->Off36.FAT32.FilSysType[2] = 'T';
-            pBootRecord->Off36.FAT32.FilSysType[3] = '3';
-            pBootRecord->Off36.FAT32.FilSysType[4] = '2';
-            pBootRecord->Off36.FAT32.FilSysType[5] = ' ';
-            pBootRecord->Off36.FAT32.FilSysType[6] = ' ';
-            pBootRecord->Off36.FAT32.FilSysType[7] = ' ';
-
-            pBootRecord->Signature                 = FAT_SIGNATURE;
-
-            /*
-             * Write the BPB to the drive
-             */
-            dSector = BPB_HiddSec;
-            nError  = HWWriteSectors(bDevice, pBuffer, dSector, 1);    
-            if (nError == HW_OK)
-            {
-                dSector += FAT32_OFFSET_BACKUP_BOOT;
-                nError   = HWWriteSectors(bDevice, pBuffer, dSector, 1);            
-            }
-        }
-
-        /*
-         * Create the FSINFO
-         */
-        if (nError == HW_OK)
-        {
-            memset(pBuffer, 0x00, pDrive->wSectorSize);
-            pFSInfo = (FAT32_FSINFO *)pBuffer;
-
-            dFirstDataSector = BPB_HiddSec + BPB_RsvdSecCnt;
-            dLastDataSector  = dTotalSectors;
-            dMaxClusterCount = dLastDataSector - dFirstDataSector;
-            dMaxClusterCount = dMaxClusterCount / (LONG)bSecPerClus;
-
-            pFSInfo->FirstSignature               = FSINFO_FIRSTSIGNATURE;
-            pFSInfo->FSInfoSignature              = FSINFO_FSINFOSIGNATURE;
-            pFSInfo->NumberOfFreeClusters         = dMaxClusterCount;
-            pFSInfo->MostRecentlyAllocatedCluster = 2;
-            pFSInfo->Signature                    = FSINFO_SIGNATURE;
-
-            /*
-             * Write the FSINFO to the drive
-             */      
-            dSector = BPB_HiddSec + FAT32_OFFSET_FSINFO;
-            nError  = HWWriteSectors(bDevice, pBuffer, dSector, 1);        
-        }
-
-        /*
-         * Write first FAT entry after format.
-         */
-        if (nError == HW_OK)
-        {
-            dFAT1StartSector = BPB_HiddSec + BPB_RsvdSecCnt;    
-            dFAT2StartSector = dFAT1StartSector + dFATSz32; 
-
-            memset(pBuffer, 0x00, pDrive->wSectorSize);
-            pLong = (LONG *)pBuffer;
-
-            /*
-             * Set the two reserved cluster after the format,
-             * take a look in the MS Hardware White Paper
-             * Version 1.03, December 6, 2000 for more information.
-             */
-            *pLong++ = 0x0FFFFFF8;
-            *pLong++ = FAT32_CLUSTER_EOF;
-            *pLong++ = FAT32_CLUSTER_EOF;
-
-            nError = HWWriteSectors(bDevice, pBuffer, dFAT1StartSector, 1);        
-            if (nError == HW_OK)
-            {
-                nError = HWWriteSectors(bDevice, pBuffer, dFAT2StartSector, 1);              
-            }
-        }
-
-        /*
-         * Create RootDir
-         */
-        if (nError == HW_OK)
-        {
-            memset(pBuffer, 0x00, pDrive->wSectorSize);
-            pDirEntry = (FAT32_DIRECTORY_ENTRY *)pBuffer;
-
-            pDirEntry->Name[0]      = 'E'; 
-            pDirEntry->Name[1]      = 'T';
-            pDirEntry->Name[2]      = 'H';
-            pDirEntry->Name[3]      = 'E';
-            pDirEntry->Name[4]      = 'R';
-            pDirEntry->Name[5]      = 'N';
-            pDirEntry->Name[6]      = 'U';
-            pDirEntry->Name[7]      = 'T';
-
-            pDirEntry->Extension[0] = ' ';
-            pDirEntry->Extension[1] = ' ';
-            pDirEntry->Extension[2] = ' ';
-
-            pDirEntry->Attribute    = DIRECTORY_ATTRIBUTE_VOLUME_ID;
-            pDirEntry->HighCluster  = 0;
-            pDirEntry->LowCluster   = 0;
-            pDirEntry->FileSize     = 0;
-
-            dCluster2StartSector = dFAT2StartSector + dFATSz32;
-            nError = HWWriteSectors(bDevice, pBuffer, dCluster2StartSector, 1);                    
-        }
-
-        NutHeapFree(pBuffer);  
-
-        FATFree();
-
-
-        /*
-         * Don't forget to mount the drive
-         */   
-        if (nError == HW_OK)
-        {
-            nError = MountDrive(bDevice);
-        }
-
-        if (nError == HW_OK)
-        {
-            nError = NUTDEV_OK;        
-        }
-        else
-        {
-            nError = NUTDEV_ERROR;    
-        }    
-    }
-
-    return(nError);
-}
-#endif /* (FAT_SUPPORT_FORMAT >= 1) */
-

ipac-base-27JAN2011/source/flash.c

@@ -1,399 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     Flash
- * [TITLE]      Routines for Atmel AT45 serial dataflash memory chips.
- * [FILE]       flash.c
- * [VSN]        1.0
- * [CREATED]    11042007
- * [LASTCHNGD]  11042007
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    contains all interface- and low-level routines to
- *              read/write/delete blocks in the serial DataFlash (AT45DBXX)
- * ======================================================================== */
-
-#define LOG_MODULE  LOG_FLASH_MODULE
-
-//#include <stdio.h>
-#include <cfg/os.h>
-#include <cfg/memory.h>
-
-#include <sys/timer.h>
-
-#include <string.h>
-#include <stdlib.h>
-
-#include "typedefs.h"
-#include "flash.h"
-#include "portio.h"
-#include "log.h"
-#include "spidrv.h"
-
-
-/*-------------------------------------------------------------------------*/
-/* local defines                                                           */
-/*-------------------------------------------------------------------------*/
-#ifndef MAX_AT45_CMDLEN
-#define MAX_AT45_CMDLEN         8
-#endif
-
-#ifndef AT45_ERASE_WAIT
-#define AT45_ERASE_WAIT         3000
-#endif
-
-#ifndef AT45_CHIP_ERASE_WAIT
-#define AT45_CHIP_ERASE_WAIT    50000
-#endif
-
-#ifndef AT45_WRITE_POLLS
-#define AT45_WRITE_POLLS        1000
-#endif
-
-#define DFCMD_READ_PAGE         0xD2    /* Read main memory page. */
-#define DFCMD_READ_STATUS       0xD7    /* Read status register. */
-#define DFCMD_CONT_READ         0xE8    /* Continuos read. */
-#define DFCMD_PAGE_ERASE        0x81    /* Page erase. */
-#define DFCMD_BUF1_WRITE        0x84    /* Buffer 1 write. */
-#define DFCMD_BUF1_FLASH        0x83    /* Buffer 1 flash with page erase. */
-
-/*
- *  \brief last page of flash (264 bytes) can be dedicated for parameter storage
- *   Special routines are provided for that goal but can be disabled here to save
- *   codespace (about 360 bytes of code for GCC)
- */
-
-//#define USE_FLASH_PARAM_PAGE
-
-/*-------------------------------------------------------------------------*/
-/* typedefs & structs                                                      */
-/*-------------------------------------------------------------------------*/
-/*!
- * \brief Known device type entry.
- */
-typedef struct _AT45_DEVTAB
-{
-    u_long devt_pages;
-    u_int devt_pagsiz;
-    u_int devt_offs;
-    u_char devt_srmsk;
-    u_char devt_srval;
-} AT45_DEVTAB;
-
-/*!
- * \brief Active device entry.
- */
-typedef struct _AT45DB_DCB
-{
-    AT45_DEVTAB *dcb_devt;
-    u_char dcb_cmdbuf[MAX_AT45_CMDLEN];
-} AT45DB_DCB;
-
-/*!
- * \brief Table of known Dataflash types.
- */
-AT45_DEVTAB at45_devt[] = {
-    {512,  264,  9,  0x3C, 0x0C},   // AT45DB011B - 128kB
-    {1025, 264,  9,  0x3C, 0x14},   // AT45DB021B - 256kB
-    {2048, 264,  9,  0x3C, 0x1C},   // AT45DB041B - 512kB
-    {4096, 264,  9,  0x3C, 0x24},   // AT45DB081B - 1MB
-    {4096, 528,  10, 0x3C, 0x2C},   // AT45DB0161B - 2MB
-    {8192, 528,  10, 0x3C, 0x34},   // AT45DB0321B - 4MB
-    {8192, 1056, 11, 0x38, 0x38},   // AT45DB0642 - 8MB
-    {0,    0,    0,  0,    0}       // End of table
-};
-
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-/*!
- * \brief Table of active devices.
- */
-static AT45DB_DCB dcbtab;
-
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-static int At45dbTransfer(CONST void *txbuf, void *rxbuf, int xlen, CONST void *txnbuf, void *rxnbuf, int xnlen);
-
-/*!
- * \addtogroup SerialFlash
- */
-
-/*@{*/
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-
-/*!
- * \brief mid-level SPI-interface routine
- *
- *  This routine handles sending a command an reading back the reply in one routine
- *  It will perform 'xlen' + 'xnlen' SPI-byte cycles. During the 'xlen' cycles, data in 'txbuf'
- *  is sent using the SPI, and each resulting byte is stored in 'rxbuf'. Then it starts with
- *  the 'xnlen' cycles whereby the contents of the 'txnbuf' are sent using the SPI.
- *  Each resulting byte then is stored in 'rxnbuf'
- */
-//                                        cb,          cb,        len,             tdata,         rdata,      datalen
-static int At45dbTransfer(CONST void *txbuf, void *rxbuf, int xlen, CONST void *txnbuf, void *rxnbuf, int xnlen)
-{   int i;
-    u_char *ptTxbuf, *ptRxbuf;
-
-    SPIselect(SPI_DEV_FLASH);
-
-    ptTxbuf=(u_char*)txbuf;
-    ptRxbuf=(u_char*)rxbuf;
-    /*
-     *  send command, store the bytes that were read the same time
-     */
-    for (i=0; i<xlen; ++i)
-    {
-        *ptRxbuf++=SPItransferByte(*ptTxbuf++);
-    }
-
-    ptTxbuf=(u_char*)txnbuf;
-    ptRxbuf=(u_char*)rxnbuf;
-    /*
-     *  send dummy data, store the bytes that were read the same time
-     */
-    for (i=0; i<xnlen; ++i)
-    {
-        *ptRxbuf++=SPItransferByte(*ptTxbuf++);
-    }
-
-    SPIdeselect();
-
-    return(0);  // always...
-
-}
-
-/*!
- * \brief send a command to the AT45dbXX
- *
- */
-int At45dbSendCmd(u_char op, u_long parm, int len, CONST void *tdata, void *rdata, int datalen)
-{
-    u_char *cb = dcbtab.dcb_cmdbuf;
-
-    if (len > MAX_AT45_CMDLEN)
-    {
-        return (-1);
-    }
-    memset(cb, 0, len);
-    cb[0] = op;
-    if (parm)
-    {
-        cb[1] = (u_char) (parm >> 16);
-        cb[2] = (u_char) (parm >> 8);
-        cb[3] = (u_char) parm;
-    }
-    return (At45dbTransfer(cb, cb, len, tdata, rdata, datalen));
-}
-
-/*!
- * \brief read status
- *
- */
-u_char At45dbGetStatus()
-{
-    u_char buf[2] = { DFCMD_READ_STATUS, 0xFF};
-
-    if (At45dbTransfer(buf, buf, 2, NULL, NULL, 0))
-    {
-        return(u_char) - 1;
-    }
-    return (buf[1]);
-}
-
-/*!
- * \brief Wait until flash memory cycle finished.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int At45dbWaitReady(u_long tmo, int poll)
-{
-    u_char sr;
-
-    while (((sr = At45dbGetStatus()) & 0x80) == 0)
-    {
-        if (!poll)
-        {
-            NutSleep(1);
-        }
-        if (tmo-- == 0)
-        {
-            return (-1);
-        }
-    }
-    return (0);
-}
-
-/*!
- * \brief runtime detection of serial flash device
- */
-int At45dbInit()
-{
-    u_char sr;
-    u_char i;
-
-    At45dbGetStatus();
-    sr = At45dbGetStatus();
-
-    for (i=0; at45_devt[i].devt_pages; i++)
-    {
-        if ((sr & at45_devt[i].devt_srmsk) == at45_devt[i].devt_srval)
-        {
-            dcbtab.dcb_devt = &at45_devt[i];
-            break;
-        }
-    }
-    return (i);
-}
-
-/*!
- * \brief Erase sector at the specified offset.
- */
-int At45dbPageErase(u_int pgn)
-{
-    return (At45dbSendCmd(DFCMD_PAGE_ERASE, pgn, 4, NULL, NULL, 0));
-}
-
-/*!
- * \brief Erase entire flash memory chip.
- */
-int At45dbChipErase(void)
-{
-    return (-1);
-}
-
-/*!
- * \brief Read data from flash memory.
- *
- * \param pgn  Page number to read, starting at 0.
- * \param data Points to a buffer that receives the data.
- * \param len  Number of bytes to read.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int At45dbPageRead(u_long pgn, void *data, u_int len)
-{
-    pgn <<= dcbtab.dcb_devt->devt_offs;
-    return (At45dbSendCmd(DFCMD_CONT_READ, pgn, 8, data, data, len));
-}
-
-/*!
- * \brief Write data into flash memory.
- *
- * The related sector must have been erased before calling this function.
- *
- * \param pgn  Start location within the chip, starting at 0.
- * \param data Points to a buffer that contains the bytes to be written.
- * \param len  Number of bytes to write.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int At45dbPageWrite(u_long pgn, CONST void *data, u_int len)
-{
-    int rc = -1;
-    void *rp;
-
-    if ((rp = malloc(len)) != NULL)
-    {
-        /* Copy data to dataflash RAM buffer. */
-        if (At45dbSendCmd(DFCMD_BUF1_WRITE, 0, 4, data, rp, len) == 0)
-        {
-            /* Flash RAM buffer. */
-            pgn <<= dcbtab.dcb_devt->devt_offs;
-            if (At45dbSendCmd(DFCMD_BUF1_FLASH, pgn, 4, NULL, NULL, 0) == 0)
-            {
-                rc = At45dbWaitReady(AT45_WRITE_POLLS, 1);
-            }
-        }
-        free(rp);
-    }
-    return (rc);
-}
-
-#ifdef USE_FLASH_PARAM_PAGE
-
-u_long At45dbParamPage(void)
-{
-#ifdef AT45_CONF_PAGE
-    return (AT45_CONF_PAGE);
-#else
-    return (dcbtab.dcb_devt->devt_pages - 1);
-#endif
-}
-
-int At45dbParamSize(void)
-{
-    int rc;
-
-#ifdef AT45_CONF_SIZE
-    rc = AT45_CONF_SIZE;
-#else
-    rc = dcbtab.dcb_devt->devt_pagsiz;
-#endif
-    return (rc);
-}
-
-/*!
- * \brief Load configuration parameters from flash memory.
- *
- * \param pos  Start location within configuration sector.
- * \param data Points to a buffer that receives the contents.
- * \param len  Number of bytes to read.
- *
- * \return Always 0.
- */
-int At45dbParamRead(u_int pos, void *data, u_int len)
-{
-    int rc = -1;
-    u_char *buff;
-    int csize = At45dbParamSize();
-    u_long cpage = At45dbParamPage();
-
-    /* Load the complete configuration area. */
-    if (csize > len && (buff = malloc(csize)) != NULL)
-    {
-        rc = At45dbPageRead(cpage, buff, csize);
-        /* Copy requested contents to caller's buffer. */
-        memcpy(data, buff + pos, len);
-        free(buff);
-    }
-    return (rc);
-}
-
-/*!
- * \brief Store configuration parameters in flash memory.
- *
- * \param pos   Start location within configuration sector.
- * \param data  Points to a buffer that contains the bytes to store.
- * \param len   Number of bytes to store.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int At45dbParamWrite(u_int pos, CONST void *data, u_int len)
-{
-    int rc = -1;
-    u_char *buff;
-    int csize = At45dbParamSize();
-    u_long cpage = At45dbParamPage();
-
-    /* Load the complete configuration area. */
-    if (csize > len && (buff = malloc(csize)) != NULL)
-    {
-        rc = At45dbPageRead(cpage, buff, csize);
-        /* Compare old with new contents. */
-        if (memcmp(buff + pos, data, len))
-        {
-            /* New contents differs. Copy it into the sector buffer. */
-            memcpy(buff + pos, data, len);
-            /* Erase sector and write new data. */
-            rc = At45dbPageWrite(cpage, buff, csize);
-        }
-        free(buff);
-    }
-    return (rc);
-}
-
-#endif // USE_FLASH_PARAM_PAGE

ipac-base-27JAN2011/source/http.c

@@ -1,303 +0,0 @@
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : Http
- *  File name  $Workfile: Http.c  $
- *       Last Save $Date: 2003/08/23 18:39:38  $
- *             $Revision: 0.1  $
- *  Creation Date       : 2003/08/23 18:39:38
- *
- *  Description         : Http client routines
- *
- */
-
-#define LOG_MODULE  LOG_HTTP_MODULE
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include <sys/confos.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-
-//#pragma text:appcode
-
-#include "system.h"
-#include "log.h"
-#include "settings.h"
-#include "util.h"
-
-#include "http.h"
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local variables                                                         */
-/*--------------------------------------------------------------------------*/
-static CONST char EncTable[] =
-{
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
-    'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
-    'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
-    'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
-    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-    'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    '4', '5', '6', '7', '8', '9', '+', '/'
-};
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local functions                                                         */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*!
- * \brief Calculate the space needed to store data in Base64
- *
- * \param NrOfBytes     number of bytes to encode
- *
- * \return Number of bytes needed
- */
-int Base64EncodedSize(size_t tNrOfBytes)
-{
-    return ((tNrOfBytes + 2) / 3 * 4) + 1;
-}
-
-/*!
- * \brief Encode (binary) data into a Base64 encoded string.
- *
- * \param szDest        pointer to destination
- * \param pSrc          pointer to (binary) data to encode.
- * \param tSize         nrof bytes to read from pSrc
- *
- * \return Number of bytes copied to szDest
- *         0 if errors or nothing to encode
- */
-size_t Base64Encode(char *szDest, CONST u_char *pSrc, size_t tSize)
-{
-    size_t DestLen = 0;                 /* nrof bytes in szDest */
-    u_char Index = 0;
-    unsigned char Tmp[3];               /* source data */
-
-    /* Encode all input data */
-    while (tSize > 0)
-    {
-        /* Get a piece of data to encode */
-        memset(Tmp, 0, sizeof(Tmp));
-        for (Index = 0; Index < sizeof(Tmp) && tSize > 0; Index++, tSize--)
-        {
-            Tmp[Index] = *pSrc++;
-        }
-
-        /* Encode 3 chars into 4 */
-        *szDest++ =                     EncTable[                          ((Tmp[0] >> 2) & 0x3F) ];
-        *szDest++ =                     EncTable[ ((Tmp[0] << 4) & 0x3F) | ((Tmp[1] >> 4) & 0x0F) ];
-        *szDest++ = (Index < 1) ? '=' : EncTable[ ((Tmp[1] << 2) & 0x3C) | ((Tmp[2] >> 6) & 0x03) ];
-        *szDest++ = (Index < 2) ? '=' : EncTable[ ( Tmp[2]       & 0x3F) ];
-        DestLen += 4;
-    }
-
-    *szDest = '\0';
-    return (DestLen);
-}
-
-/*!
- * \brief Get ip address of a host
- *
- * \param szHostName Name or string of the IP address
- *                   of the host
- * \return The IP address of the host.
- *         0 if not an IP address, or we could not resolve the name
- */
-u_long GetHostByName(CONST char *szHostName)
-{
-    u_long dwAddress;
-
-    if ((dwAddress = inet_addr(szHostName)) == (u_long)-1)
-    {
-        dwAddress = NutDnsGetHostByName((u_char*)szHostName);
-    }
-    return (dwAddress);
-}
-
-/*!
- * \brief Break a Url down in parts
- *
- * The hostname, port and URI pointers are
- * set to the appropriate locations or an empty string
- * if not present.
- *
- * \note szUrl is modified
- *
- * \param szUrl Url to parse
- */
-void HttpParseUrl(char *szUrl, TUrlParts *tUrlParts)
-{
-    char *szStart;      /* Points to the first character of the part */
-    char *szEnd;        /* Points to the last character of the part */
-
-    /*
-     * In case we don't find a Host, port or URI, point
-     * to empty string
-     */
-    tUrlParts->pszHost = tUrlParts->pszPort = tUrlParts->pszPath = (char *)(szUrl + strlen(szUrl));
-
-    /*
-     * skip the prefix
-     */
-    szStart = strstr_P(szUrl, PSTR("://"));
-    if (szStart != NULL)
-    {
-        szStart += 3;
-    }
-    else
-    {
-        /*
-         * Apparently there is no prefix
-         */
-        szStart  = (char *)szUrl;
-    }
-
-    /*
-     * We have found the hostname
-     */
-    tUrlParts->pszHost = szStart;
-
-    /*
-     * Find the end of the hostname
-     * End of it is indicated by ':' or '/'
-     * If neither are found, assume we have a URL in
-     * the form 'http://demeterkast.net'
-     */
-    szEnd = strchr(szStart, ':');
-    if (szEnd != NULL)
-    {
-        /*
-         * There is a port specification, get it now
-         */
-        *szEnd = '\0';          /* Terminate the previous part */
-        szStart = szEnd + 1;        /* point to the portnumber */
-        tUrlParts->pszPort = szStart;
-    }
-
-    szEnd = strchr(szStart, '/');
-    if (szEnd != NULL)
-    {
-        /*
-         * There is a URI specification, get it now
-         */
-        *szEnd = '\0';          /* Terminate the previous part */
-        tUrlParts->pszPath = szEnd + 1;   /* point to the URI */
-    }
-}
-
-/*!
- * \brief Send a request to a server.
- *
- * The connection to the server should already be
- * present and associated with a stream.
- *
- * \param   ptStream [in] Opened stream to send the request to
- * \param   pszHeaders [in] The headers to send
- * \param   wMode [in] Bitmask for the request to send
- *              - HTTP_AUTH to send a Basic authentication consisting of our hostname and an empty password
- * \return  The number of characters written or a negative value to
- *          indicate an error.
- */
-int HttpSendRequest(FILE *ptStream, CONST char *pszHeaders, u_short wMode)
-{
-    int nResult = 0;    /* Bytes sent during last call (or -1) */
-    int nSent = 0;      /* Total bytes sent */
-
-    if ((pszHeaders == NULL) || (ptStream == NULL))
-    {
-        nResult = -1;
-    }
-
-    /*
-     * Send the headers
-     */
-    if (nResult >= 0)
-    {
-        nSent += nResult;
-        nResult = fprintf_P(ptStream, PSTR("%s"), pszHeaders);
-    }
-
-    /*
-     * Add authentication info (if requested)
-     */
-    if (nResult >= 0)
-    {
-        nSent += nResult;
-        nResult = 0;
-
-        if (wMode & HTTP_AUTH)
-        {
-            char *szEncoded;
-            char szToken[sizeof(confos.hostname)+1];
-
-            /*
-             * Compose the username:password
-             * (We use our hostname and an empty password)
-             */
-            strncpy(szToken, confos.hostname, sizeof(szToken)-1);
-            szToken[sizeof(szToken)-1] = '\0';
-            strcat_P(szToken, PSTR(":"));
-
-            szEncoded = MyMalloc(Base64EncodedSize(strlen(szToken)));
-            if (szEncoded == NULL)
-            {
-                nResult = -1;
-            }
-            else
-            {
-                (void)Base64Encode(szEncoded, (u_char*)szToken, strlen(szToken));
-
-                nResult = fprintf_P(ptStream, PSTR("Authorization: Basic %s\r\n"), szEncoded);
-
-                MyFree(szEncoded);
-            }
-        }
-    }
-
-    /*
-     * Print the end of header
-     */
-    if (nResult >= 0)
-    {
-        nSent += nResult;
-        nResult = fprintf_P(ptStream, PSTR("\r\n"));
-    }
-
-    fflush(ptStream);
-
-    if (nResult >= 0)
-    {
-        nSent += nResult;
-    }
-    else
-    {
-        nSent = -1;
-    }
-
-    return (nSent);
-}
-

ipac-base-27JAN2011/source/inet.c

@@ -1,1538 +0,0 @@
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : Inet
- *  File name  $Workfile: Inet.c  $
- *       Last Save $Date: 2006/02/24 13:46:16  $
- *             $Revision: 0.1  $
- *  Creation Date       : 2006/02/24 13:46:16
- *
- *  Description         :
- *
- */
-
-#define LOG_MODULE  LOG_INET_MODULE
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-
-#include <sys/timer.h>
-#include <sys/socket.h>
-#include <sys/heap.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <errno.h>
-
-//#pragma text:appcode
-
-#include "system.h"
-#include "version.h"
-#include "log.h"
-#include "settings.h"
-#include "util.h"
-
-#include "inet.h"
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-/*!\brief Allow some problems before giving up */
-//#define MAX_NODNS               5
-#define MAX_NODNS               2
-#define MAX_NOCONNECT           2
-#define MAX_BADRESPONSE         5
-#define MAX_REDIRECT            5   /* see RFC2616 */
-
-/*!\brief Default Receive timeout */
-#define TCP_RECVTO_DEFAULT      5000
-
-/*!\brief HTTP line buffer size. Allocates in chunks of this size. */
-#define HTTP_HEADER_LINE_SIZE   512
-
-#ifdef DEBUG
-//#define INET_DEBUG
-#endif /* #ifdef DEBUG */
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local variables                                                         */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local functions                                                         */
-/*--------------------------------------------------------------------------*/
-static TError Connect(HINET hInet);
-static void GetHeaders(HINET hInet);
-static int CreateRequest(HINET hInet, CONST char *pszMethod, CONST char *pszPath, CONST char *pszAccept);
-static void CloseDescriptors(HINET hInet);
-
-#ifdef INET_DEBUG
-static void ShowDebug(void)
-{
-    LogMsg_P(LOG_DEBUG, PSTR("free %d"), NutHeapAvailable());
-}
-#else
-#define ShowDebug()
-#endif
-
-/*!
- * \brief Opens an Internet session.
- *
- * \param   hInet [in] Handle returned by a previous call to InternetOpen.
- *
- * \return  0 if the connection is successful
- *          TError otherwise.
- */
-static TError Connect(HINET hInet)
-{
-    TError tError = OK;
-    unsigned char byDone = 0;
-    char ModeString[5];
-
-    /*
-     * Connect to the server. Retry in case of problems
-     */
-    while (byDone == 0)
-    {
-        if (hInet->tState == INET_STATE_CLOSING)
-        {
-            tError = USER_ABORT;
-        }
-
-        if (tError == OK)
-        {
-            hInet->tState = INET_STATE_BUSY;
-        }
-
-        /*
-         * Translate to an IP number and port
-         */
-        if (tError == OK)
-        {
-            if ((hInet->wPort = atoi(hInet->tUrlParts.pszPort)) == 0)
-            {
-                // Use defaults if not specified
-                hInet->wPort = 80;
-            }
-            LogMsg_P(LOG_DEBUG, PSTR("Looking up [%s]"), hInet->tUrlParts.pszHost);
-
-            if ((hInet->ulIpAddress = GetHostByName(hInet->tUrlParts.pszHost)) == 0)
-            {
-                tError = INET_HOSTNOTFOUND;
-
-                /*
-                 * Check if we can retry
-                 */
-                if (++hInet->tRetries.byNoDnsCount >= MAX_NODNS)
-                {
-                    /* Too many failures, stop */
-                    tError = INET_HOST_NONEXISTANT;
-                }
-            }
-        }
-
-        /*
-         * We could have been asleep; Check if we have received a close request
-         */
-        if (hInet->tState == INET_STATE_CLOSING)
-        {
-            tError = USER_ABORT;
-        }
-
-        /*
-         * Create a socket.
-         */
-        ShowDebug();
-        if (tError == OK)
-        {
-            if ((hInet->ptSocket = NutTcpCreateSocket()) == 0)
-            {
-                tError = INET_CREATE_SOCKET;
-            }
-        }
-#ifdef INET_DEBUG
-        LogMsg_P(LOG_DEBUG, PSTR("ptSocket @%X"), hInet->ptSocket);
-#endif /* #ifdef INET_DEBUG */
-        ShowDebug();
-
-        /*
-         * Set socket options
-         */
-        if (tError == OK)
-        {
-            /* We use our own default if not specified */
-            if (hInet->ulRecvTimeout == 0)
-            {
-                hInet->ulRecvTimeout = TCP_RECVTO_DEFAULT;
-            }
-            /* Nut/OS defaults to infinite receive timeout. So always set our default timeout */
-            if (NutTcpSetSockOpt(hInet->ptSocket, SO_RCVTIMEO, &hInet->ulRecvTimeout, sizeof(hInet->ulRecvTimeout)))
-            {
-                tError = INET_SOCK_RCVTO;
-            }
-        }
-        if (tError == OK)
-        {
-            /* Use NutOS's default if not specified */
-            if ((hInet->unMss != 0) &&
-                (NutTcpSetSockOpt(hInet->ptSocket, TCP_MAXSEG, &hInet->unMss, sizeof(hInet->unMss))))
-            {
-                tError = INET_SOCK_MSS;
-            }
-        }
-        if (tError == OK)
-        {
-            /* Use NutOS's default if not specified */
-            if ((hInet->unTcpRecvBufSize != 0) &&
-                (NutTcpSetSockOpt(hInet->ptSocket, SO_RCVBUF, &hInet->unTcpRecvBufSize, sizeof(hInet->unTcpRecvBufSize))))
-            {
-                tError = INET_SOCK_RXBUF;
-            }
-        }
-
-        /*
-         * Connect to destination
-         */
-        if (tError == OK)
-        {
-            LogMsg_P(LOG_DEBUG, PSTR("Connecting to %s:%d"), inet_ntoa(hInet->ulIpAddress), hInet->wPort);
-            if (NutTcpConnect(hInet->ptSocket, hInet->ulIpAddress, hInet->wPort) != 0)
-            {
-                tError = INET_NOCONNECT;
-
-                LogMsg_P(LOG_ERR, PSTR("No connect"));
-
-                if (++hInet->tRetries.byNoConnectCount >= MAX_NOCONNECT)
-                {
-                    tError = INET_TOO_MANY_NOCONNECTS;
-                }
-            }
-            else
-            {
-                /* Connected, stop */
-                byDone = 1;
-
-                LogMsg_P(LOG_DEBUG, PSTR("TCP Connected"));
-                /* Let the TCP/IP stack settle down first */
-                NutSleep(500);
-            }
-        }
-
-        /*
-         * We could have been asleep; Check if we have receive a close request
-         */
-        if (hInet->tState == INET_STATE_CLOSING)
-        {
-            tError = USER_ABORT;
-        }
-
-        /*
-         * Create a stream from the socket.
-         */
-        if (tError == OK)
-        {
-            strcpy_P(ModeString, PSTR("r+b"));
-            if ((hInet->ptStream = _fdopen((int)hInet->ptSocket, ModeString)) == 0)
-            {
-                LogMsg_P(LOG_ERR, PSTR("No stream %d"), errno);
-                tError = INET_CREATE_STREAM;
-            }
-        }
-
-#ifdef INET_DEBUG
-        LogMsg_P(LOG_DEBUG, PSTR("ptStream @%X"), hInet->ptStream);
-#endif /* #ifdef INET_DEBUG */
-
-
-        if (tError != OK)
-        {
-            LogMsg_P(LOG_ERR, PSTR("Error [%d]"), tError);
-
-            /*
-             * Check if we need to try again
-             */
-            if ((tError > PLAYER_WARNINGS) && (tError < PLAYER_ERRORS))
-            {
-                LogMsg_P(LOG_INFO, PSTR("Retry"));
-
-                CloseDescriptors(hInet);
-
-                /*
-                 * Try again
-                 */
-                tError = OK;
-
-                /*
-                 * Give other threads some time before
-                 * we try again
-                 */
-                NutSleep(300);
-            }
-            else
-            {
-                /* Errors, stop */
-                byDone = 1;
-            }
-        }
-    } /* end while */
-
-    ShowDebug();
-
-    hInet->tState = INET_STATE_IDLE;
-    return (tError);
-}
-
-/*!
- * \brief Create a new request to be sent to an Internet server.
- *
- * hInet->hRequest should already have allocated memory behind it, as this
- * routine does not allocate (or free) memory.
- *
- * \param   hInet [in] Handle returned by a previous call to InternetOpen.
- * \param   pszMethod [in] A pointer to a null-terminated string that contains
- *          the method to use in the request. If this parameter is NULL, the
- *          function uses GET.
- * \param   pszPath [in] A pointer to a null-terminated string that contains
- *          the path to act upon.
- * \param   pszAccept[in] A pointer to a null-terminated string that indicates
- *          the media types accepted by the client. If this parameter is NULL,
- *          a string that indicates that all types are accepted is sent to the
- *          server.
- *
- * \return  0 when the request was successfully created
- *          -1 on errors
- */
-static int CreateRequest(HINET hInet, CONST char *pszMethod, CONST char *pszPath, CONST char *pszAccept)
-{
-    static prog_char cszAction_P[]      = "%s /%s%s HTTP/1.0\r\n";
-    static prog_char cszUserAgent_P[]   = "User-Agent: %s/%s s/n:%s\r\n";
-
-    // create buffers for RAM-strings...
-    static char szEmptyString[1];
-    static char szGet[4];
-    static char szSerialNum[9];
-    static char szAcceptDefault[20];
-
-    int nResult = 0;
-    char *pszSerialNr;
-
-    // apply defaults for RAM-strings....
-    szEmptyString[0] = '\0';
-    szSerialNum[0] = '\0';
-    strcpy_P(szGet, PSTR("GET"));
-    strcpy_P(szAcceptDefault, PSTR("Accept: */*\r\n"));
-
-    pszSerialNr = szEmptyString;
-
-#ifdef INET_DEBUG
-    LogMsg_P(LOG_DEBUG, PSTR("Create request"));
-#endif /* #ifdef INET_DEBUG */
-
-    if ((hInet == NULL) || (hInet->hRequest == NULL))
-    {
-        /* Bad argument */
-        nResult = -1;
-    }
-
-    if (nResult >= 0)
-    {
-        /*
-         * Erase any previous requests
-         */
-        hInet->hRequest->unRequestInUse = 0;
-        hInet->hRequest->pszRequest[0] = '\0';
-
-        /*
-         * Use defaults for the method and Uri if not further specified
-         */
-        if (pszMethod == NULL)
-        {
-            pszMethod = szGet;
-        }
-        if (pszPath == NULL)
-        {
-            pszPath = hInet->tUrlParts.pszPath;
-        }
-
-        //sprintf_P(szSerialNum, PSTR("%5.5lX"), SettingsGetSerialnumber());
-    }
-
-    /*
-     * Check if we need to add our serial number to the end of the URL
-     */
-    if (nResult >= 0)
-    {
-        if ((hInet->hRequest->wOptions & INET_FLAG_ADD_SERIAL) == INET_FLAG_ADD_SERIAL)
-        {
-            if (strlen(pszPath) > 0)
-            {
-                if (pszPath[strlen(pszPath)-1] == '=')
-                {
-                    pszSerialNr = szSerialNum;
-                }
-            }
-        }
-    }
-
-    /*
-     * Create the request
-     */
-    if (nResult >= 0)
-    {
-        nResult = sprintf_P(&hInet->hRequest->pszRequest[hInet->hRequest->unRequestInUse],
-                            cszAction_P,
-                            pszMethod,
-                            pszPath,
-                            pszSerialNr);
-        if (nResult >= 0)
-        {
-#ifdef INET_DEBUG
-            /* We already print out the request at the end of this routine */
-#else /* #ifdef INET_DEBUG */
-//            LogMsg_P(LOG_DEBUG, PSTR("Request [%s]"), &hInet->hRequest->pszRequest[hInet->hRequest->unRequestInUse]);
-#endif /* #ifdef INET_DEBUG */
-            hInet->hRequest->unRequestInUse += nResult;
-            if (hInet->hRequest->unRequestInUse > hInet->hRequest->unRequestBufSize)
-            {
-                nResult = -1;
-            }
-        }
-    }
-
-    /*
-     * Add the User-Agent
-     */
-    if (nResult >= 0)
-    {
-        //nResult = sprintf_P(&hInet->hRequest->pszRequest[hInet->hRequest->unRequestInUse],
-        //                    cszUserAgent_P,
-                            //VersionGetAppProductName(),
-                            //VersionGetAppString(),
-        //                    szSerialNum);
-        if (nResult >= 0)
-        {
-            hInet->hRequest->unRequestInUse += nResult;
-            if (hInet->hRequest->unRequestInUse > hInet->hRequest->unRequestBufSize)
-            {
-                nResult = -1;
-            }
-        }
-    }
-
-    /*
-     * Add the host header if needed
-     */
-    if (nResult >= 0)
-    {
-        if ((hInet->tUrlParts.pszHost != NULL) && (strlen(hInet->tUrlParts.pszHost) > 0))
-        {
-            if ((hInet->tUrlParts.pszPort != NULL) && (strlen(hInet->tUrlParts.pszPort) > 0))
-            {
-                nResult = sprintf_P(&hInet->hRequest->pszRequest[hInet->hRequest->unRequestInUse],
-                                    PSTR("Host: %s:%s\r\n"),
-                                    hInet->tUrlParts.pszHost,
-                                    hInet->tUrlParts.pszPort);
-            }
-            else
-            {
-                nResult = sprintf_P(&hInet->hRequest->pszRequest[hInet->hRequest->unRequestInUse],
-                                    PSTR("Host: %s\r\n"),
-                                    hInet->tUrlParts.pszHost);
-            }
-            if (nResult >= 0)
-            {
-                hInet->hRequest->unRequestInUse += nResult;
-                if (hInet->hRequest->unRequestInUse > hInet->hRequest->unRequestBufSize)
-                {
-                    nResult = -1;
-                }
-            }
-        }
-    }
-
-    /*
-     * Add the accept header
-     */
-    if (nResult >= 0)
-    {
-        if (pszAccept == NULL)
-        {
-            pszAccept = szAcceptDefault;
-        }
-        nResult = sprintf(&hInet->hRequest->pszRequest[hInet->hRequest->unRequestInUse],
-                          szAcceptDefault,
-                          pszAccept);
-
-        if (nResult >= 0)
-        {
-            hInet->hRequest->unRequestInUse += nResult;
-            if (hInet->hRequest->unRequestInUse > hInet->hRequest->unRequestBufSize)
-            {
-                nResult = -1;
-            }
-        }
-    }
-
-    /*
-     * Check if we need to do a request for ICY meta data
-     */
-    if (nResult >= 0)
-    {
-        if ((hInet->hRequest->wOptions & INET_FLAG_ICY_META_REQ) == INET_FLAG_ICY_META_REQ)
-        {
-            nResult = sprintf_P(&hInet->hRequest->pszRequest[hInet->hRequest->unRequestInUse],
-                                PSTR("Icy-MetaData:1\r\n"));
-            if (nResult >= 0)
-            {
-                hInet->hRequest->unRequestInUse += nResult;
-                if (hInet->hRequest->unRequestInUse > hInet->hRequest->unRequestBufSize)
-                {
-                    nResult = -1;
-                }
-            }
-        }
-    }
-
-    /*
-     * Check if we need to close the connection
-     */
-    if (nResult >= 0)
-    {
-        if ((hInet->hRequest->wOptions & INET_FLAG_CLOSE) == INET_FLAG_CLOSE)
-        {
-            nResult = sprintf_P(&hInet->hRequest->pszRequest[hInet->hRequest->unRequestInUse],
-                                PSTR("Connection: close\r\n"));
-            if (nResult >= 0)
-            {
-                hInet->hRequest->unRequestInUse += nResult;
-                if (hInet->hRequest->unRequestInUse > hInet->hRequest->unRequestBufSize)
-                {
-                    nResult = -1;
-                }
-            }
-        }
-    }
-
-    /* Correct lenght in use for last \0 */
-    if (hInet->hRequest->unRequestInUse > 0)
-    {
-        hInet->hRequest->unRequestInUse += 1;
-    }
-
-    /*
-     * Log the request
-     */
-    if (nResult >= 0)
-    {
-//#ifdef INET_DEBUG
-        LogMsg_P(LOG_DEBUG, PSTR("Request %u [%s]"), hInet->hRequest->unRequestInUse, hInet->hRequest->pszRequest);
-//#endif /* #ifdef INET_DEBUG */
-    }
-
-    return (nResult);
-}
-
-
-/*!
- * \brief Get the HTTP response headers.
- *
- * This function returns after all response headers have been
- * received.
- *
- * \param   hInet [in] Handle returned by a previous call to InternetOpen.
- *
- * \return  -
- */
-static void GetHeaders(HINET hInet)
-{
-    unsigned char byDone = 0;
-
-    /*
-     * Create room for buffers
-     */
-    char *pszRespLine = MyMalloc(HTTP_HEADER_LINE_SIZE);
-    if (pszRespLine == NULL)
-    {
-        /* No memory */
-        byDone = 1;
-    }
-
-    ShowDebug();
-
-    if (hInet->hRequest == NULL)
-    {
-        /* Bad argument */
-        byDone = 1;
-    }
-    else
-    {
-        /* Reset received counter */
-        hInet->hRequest->unResponseInUse = 0;
-    }
-
-    /*
-     * Process all header lines
-     */
-    while ((byDone == 0) &&
-           (fgets(pszRespLine, HTTP_HEADER_LINE_SIZE, hInet->ptStream) != NULL))
-    {
-        /*
-         * We could have been asleep; Check if we have received a close request
-         */
-        if (hInet->tState == INET_STATE_CLOSING)
-        {
-            byDone = 1;
-        }
-        else if ((pszRespLine[0] == '\r') && (pszRespLine[1] == '\n'))
-        {
-            /*
-             * An empty line indicates the end of the headers
-             */
-            byDone = 1;
-        }
-        else
-        {
-            /*
-             * Log the line (without the end of line stuff)
-             */
-            unsigned int unLength = 0;
-            char *pszLogEol = strchr(pszRespLine, '\r');
-            if (pszLogEol != NULL)
-            {
-                unLength = pszLogEol - pszRespLine;
-            }
-            LogMsg_P(LOG_DEBUG, PSTR("Read [%.*s]"), unLength, pszRespLine);
-
-            if (BufferAddString(&hInet->hRequest->pszResponse,
-                                &hInet->hRequest->unResponseBufSize,
-                                &hInet->hRequest->unResponseInUse,
-                                pszRespLine) != 0)
-            {
-                byDone = 1;
-            }
-        }
-    }
-
-    ShowDebug();
-#ifdef INET_DEBUG
-    LogMsg_P(LOG_DEBUG, PSTR("%d Read"), hInet->hRequest->unResponseInUse);
-#endif /* #ifdef INET_DEBUG */
-
-    /*
-     * Cleanup
-     */
-    MyFree(pszRespLine);
-}
-
-/*!
- * \brief Close the socket and file descriptors of an INET handle.
- *
- * \param   hInet [in] Handle returned by a previous call to InternetOpen.
- *
- * \return  -
- */
-static void CloseDescriptors(HINET hInet)
-{
-    if (hInet != NULL)
-    {
-        /*
-         * Close the stream and the connection
-         */
-        if (hInet->ptStream != NULL)
-        {
-            (void)fclose(hInet->ptStream);
-            hInet->ptStream = NULL;
-        }
-        if (hInet->ptSocket != NULL)
-        {
-            (void)NutTcpCloseSocket(hInet->ptSocket);
-            hInet->ptSocket = NULL;
-        }
-    }
-}
-
-
-
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-
-
-HINET InetOpen(void)
-{
-    HINET hInet = NULL;
-
-    ShowDebug();
-
-    hInet = (HINET)MyMalloc(sizeof(INET));
-    if (hInet != NULL)
-    {
-//        LogMsg_P(LOG_DEBUG, PSTR("Open %X"), hInet);
-
-        memset(hInet, 0, sizeof(INET));
-        hInet->tState = INET_STATE_IDLE;
-    }
-
-    return (hInet);
-}
-
-TError InetConnect(HINET hInet, CONST char *pszUrl, unsigned long ulRecvTimeout, unsigned int unMss, unsigned int unTcpRecvBufSize)
-{
-    TError tError = OK;
-
-    ShowDebug();
-
-    /*
-     * Parse the Url
-     */
-    if (tError == OK)
-    {
-        hInet->pszUrl = strdup(pszUrl);
-        if (hInet->pszUrl != NULL)
-        {
-            HttpParseUrl(hInet->pszUrl, &hInet->tUrlParts);
-        }
-        else
-        {
-            tError = INET_NOMEM;
-        }
-    }
-
-    if (tError == OK)
-    {
-        /* Store the connect parameters */
-        hInet->ulRecvTimeout = ulRecvTimeout;
-        hInet->unMss = unMss;
-        hInet->unTcpRecvBufSize = unTcpRecvBufSize;
-
-        /* Reset the problem counters */
-        memset(&hInet->tRetries, 0, sizeof(hInet->tRetries));
-
-        tError = Connect(hInet);
-    }
-
-    return (tError);
-}
-
-TError InetHttpOpenRequest(HINET hInet, CONST char *pszMethod, CONST char *pszPath, CONST char *pszAccept, unsigned short wOptions)
-{
-    const unsigned int cunReqBufSize = 256;
-    TError tError = OK;
-
-    ShowDebug();
-
-    if (hInet == NULL)
-    {
-        /* Bad argument */
-        tError = INET_NOMEM;
-    }
-
-    /*
-     * Create the request
-     */
-    if (tError == OK)
-    {
-        if (hInet->hRequest == NULL)
-        {
-            hInet->hRequest = (HINETREQ)MyMalloc(sizeof(INETREQ));
-            if (hInet->hRequest == NULL)
-            {
-                /* No memory */
-                tError = INET_NOMEM;
-            }
-            else
-            {
-                memset(hInet->hRequest, 0, sizeof(INETREQ));
-            }
-        }
-    }
-
-    /*
-     * Create the request buffer
-     */
-    if (tError == OK)
-    {
-        if (hInet->hRequest->pszRequest == NULL)
-        {
-            /* Allocate the request buffer */
-            hInet->hRequest->pszRequest = MyMalloc(cunReqBufSize);
-            if (hInet->hRequest->pszRequest == NULL)
-            {
-                /* No memory */
-                tError = INET_NOMEM;
-            }
-            else
-            {
-                hInet->hRequest->unRequestBufSize = cunReqBufSize;
-            }
-        }
-    }
-
-#ifdef INET_DEBUG
-    LogMsg_P(LOG_DEBUG, PSTR("hInet @%X"), hInet);
-    LogMsg_P(LOG_DEBUG, PSTR("hRequest @%X"), hInet->hRequest);
-#endif /* #ifdef INET_DEBUG */
-
-    /*
-     * Create the actual request
-     */
-    if (tError == OK)
-    {
-        int nResult = 0;
-
-        /* Store the requested options */
-        hInet->hRequest->wOptions = wOptions;
-
-        /* Create the request */
-        nResult = CreateRequest(hInet, pszMethod, pszPath, pszAccept);
-        if (nResult < 0)
-        {
-            tError = INET_NOMEM;
-        }
-    }
-
-    ShowDebug();
-
-    return (tError);
-}
-
-int InetHttpAddRequestHeaders(HINET hInet, CONST char *pszNewHeaders)
-{
-    int nResult = 0;
-
-    ShowDebug();
-
-    if ((hInet == NULL) || (hInet->hRequest == NULL))
-    {
-        /* Bad argument */
-        nResult = -1;
-    }
-
-    if (nResult >= 0)
-    {
-        nResult = BufferAddString(&hInet->hRequest->pszRequest,
-                                  &hInet->hRequest->unRequestBufSize,
-                                  &hInet->hRequest->unRequestInUse,
-                                  pszNewHeaders);
-    }
-
-#ifdef INET_DEBUG
-    LogMsg_P(LOG_DEBUG, PSTR("Request %u [%s]"), hInet->hRequest->unRequestInUse, hInet->hRequest->pszRequest);
-#endif /* #ifdef INET_DEBUG */
-    ShowDebug();
-
-    return (nResult);
-}
-
-TError InetHttpSendRequest(HINET hInet)
-{
-    TError tError = OK;
-    unsigned char byDone = 0;
-    unsigned char byRedirectCount = 0;
-    int nHeaderNumber;
-    long lResponseCode;
-    void *plResponseCode;
-    unsigned int unInfoSize;
-
-    /*
-     * Talk to the server and parse its reponse
-     */
-    while (byDone == 0)
-    {
-        int nResult = +1;
-        int nResponse = -1;
-
-        ShowDebug();
-
-        if (hInet->tState == INET_STATE_CLOSING)
-        {
-            tError = USER_ABORT;
-        }
-
-        if (tError == OK)
-        {
-            hInet->tState = INET_STATE_BUSY;
-        }
-
-        /*
-         * Send the request
-         */
-        if (tError == OK)
-        {
-            nResult = HttpSendRequest(hInet->ptStream, hInet->hRequest->pszRequest, hInet->hRequest->wHttpMode);
-            if (nResult < 0)
-            {
-                tError = INET_SEND_FAIL;
-            }
-            LogMsg_P(LOG_DEBUG, PSTR("Sent %d"), nResult);
-        }
-
-        /*
-         * We could have been asleep; Check if we still need to play
-         */
-        if (hInet->tState == INET_STATE_CLOSING)
-        {
-            tError = USER_ABORT;
-        }
-
-        /*
-         * Get the response
-         */
-        if (tError == OK)
-        {
-            ShowDebug();
-
-            GetHeaders(hInet);
-
-            nHeaderNumber = 0;
-            lResponseCode = 0;
-            plResponseCode = &lResponseCode;
-            unInfoSize = sizeof(lResponseCode);
-
-            nResult = InetHttpQueryInfo(hInet,
-                                        INET_HTTP_QUERY_STATUS_CODE | INET_HTTP_QUERY_MOD_NUMERIC,
-                                        &plResponseCode,
-                                        &unInfoSize,
-                                        &nHeaderNumber);
-            if (nResult > 0)
-            {
-                nResponse = lResponseCode;
-            }
-            else
-            {
-                /* Unable to process the response */
-                nResponse = -1;
-            }
-            ShowDebug();
-
-            /*
-             * We could have been asleep; Check if we still need to play
-             */
-            if (hInet->tState == INET_STATE_CLOSING)
-            {
-                tError = USER_ABORT;
-            }
-        }
-
-        if (tError == OK)
-        {
-            /*
-             * Check the response code
-             */
-            if (nResponse >= 100 && nResponse < 300)
-            {
-                /* Connected: we're done */
-                LogMsg_P(LOG_INFO, PSTR("Connect [%d]"), nResponse);
-                byDone = 1;
-            }
-            else if (nResponse >= 300 && nResponse < 400)
-            {
-                /* Redirect */
-                LogMsg_P(LOG_INFO, PSTR("Redirect [%d]"), nResponse);
-
-                tError = INET_REDIRECT;
-                /*
-                 * Check if we can retry
-                 */
-                if (++byRedirectCount >= MAX_REDIRECT)
-                {
-                    /* Too many redirects, stop */
-                    tError = INET_TOO_MANY_REDIRECTS;
-                }
-                else
-                {
-                    int nHeaderNumber = 0;
-                    char *pszLocation = NULL;
-                    void *ppszLocation = &pszLocation;
-                    unsigned int unSize = 0;
-
-                    /* Get size of the new location string */
-                    nResult = InetHttpQueryInfo(hInet,
-                                                INET_HTTP_QUERY_LOCATION,
-                                                ppszLocation,
-                                                &unSize,
-                                                &nHeaderNumber);
-                    /*
-                     * (Re)parse the newly received URL
-                     */
-                    if (nResult > 0)
-                    {
-                        MyFree(hInet->pszUrl);
-                        hInet->pszUrl = pszLocation;
-                        LogMsg_P(LOG_INFO, PSTR("To [%s]"), hInet->pszUrl);
-                        HttpParseUrl(hInet->pszUrl, &hInet->tUrlParts);
-
-                        nResult = CreateRequest(hInet, NULL, NULL, NULL);
-                    }
-
-                    if (nResult >= 0)
-                    {
-                        /*
-                         * Allow each server a maximum of problems :-)
-                         */
-                        memset(&hInet->tRetries, 0, sizeof(hInet->tRetries));
-                    }
-                    else
-                    {
-                        tError = INET_NOMEM;
-                    }
-                }
-            }
-            else if (nResponse == 401)
-            {
-                /*
-                 * If we did not try authentication, try again with authentication.
-                 * If we already tried using authentication or shouldn't use it, give up
-                 */
-                if (((hInet->hRequest->wHttpMode & HTTP_AUTH) != HTTP_AUTH) &&
-                    ((hInet->hRequest->wOptions & INET_FLAG_NO_AUTH) != INET_FLAG_NO_AUTH))
-                {
-                    hInet->hRequest->wHttpMode |= HTTP_AUTH;
-                    tError = INET_ACCESS_RESTRICTED;
-                }
-                else
-                {
-                    tError = INET_ACCESS_DENIED;
-                    LogMsg_P(LOG_CRIT, PSTR("Access denied"));
-                }
-            }
-            else
-            {
-                /* Bad response or timeout */
-                LogMsg_P(LOG_ERR, PSTR("Bad response [%d]"), nResponse);
-
-                tError = INET_BADRESPONSE;
-
-                if (++hInet->tRetries.byBadResponseCount >= MAX_BADRESPONSE)
-                {
-                    /* Too many badresponses, stop */
-                    tError = INET_TOO_MANY_BADRESPONSES;
-                }
-            }
-        }
-
-        if (tError != OK)
-        {
-            LogMsg_P(LOG_ERR, PSTR("Error [%d]"), tError);
-
-            /*
-             * Check if we need to try again
-             */
-            if ((tError > PLAYER_WARNINGS) && (tError < PLAYER_ERRORS))
-            {
-                LogMsg_P(LOG_INFO, PSTR("Retry"));
-
-                CloseDescriptors(hInet);
-
-                /*
-                 * Try again
-                 */
-                tError = Connect(hInet);
-
-                /*
-                 * Give other threads some time before
-                 * we try again
-                 */
-                NutSleep(300);
-            }
-            else
-            {
-                /* Errors, stop */
-                byDone = 1;
-            }
-        }
-    } /* end while */
-
-    ShowDebug();
-
-    hInet->tState = INET_STATE_IDLE;
-    return (tError);
-}
-
-
-int InetHttpQueryInfo(HINET hInet, unsigned short wInfoLevel, void **pInfo, unsigned int *punInfoSize, int *pnIndex)
-{
-    /* Status prefixes: */
-    static prog_char cszHttpVer_P[]         = "HTTP/";
-    static prog_char cszIcy_P[]             = "ICY";
-    /* HTTP headers: */
-    static prog_char cszLocation_P[]        = "Location:";
-    static prog_char cszContentLength_P[]   = "Content-Length:";
-    static prog_char cszContentType_P[]     = "Content-Type:";
-    /* ICY headers: */
-    static prog_char cszIcyMetaData_P[]     = "icy-metaint:";
-
-    int nResult = 0;
-    char *pszRespLine = hInet->hRequest->pszResponse;
-    char *pszStart = pszRespLine;
-    char *pszEnd = pszRespLine;
-    unsigned int unResultSize = 0;
-
-    if ((pInfo == NULL) || (punInfoSize == NULL) || (pszRespLine == NULL))
-    {
-        /* Bad argument */
-        nResult = -1;
-    }
-
-    while ((nResult == 0) && (pszEnd != NULL))
-    {
-        /* Skip empty lines and whitepace */
-        while (isspace(*pszRespLine))
-        {
-            pszRespLine++;
-        }
-
-        pszEnd = strchr(pszRespLine, '\r');
-        if (pszEnd != NULL)
-        {
-            if ((wInfoLevel & INET_HTTP_QUERY_STATUS_CODE) == INET_HTTP_QUERY_STATUS_CODE)
-            {
-                int iProcessed = 0;
-
-                /*
-                 * Check the response code in the first line
-                 */
-                if (strncasecmp_P(pszRespLine, cszHttpVer_P, sizeof(cszHttpVer_P)-1) == 0)
-                {
-                    hInet->hRequest->byProto = INET_PROTO_HTTP;
-                    iProcessed = sizeof(cszHttpVer_P)-1;
-                }
-                else if (strncasecmp_P(pszRespLine, cszIcy_P, sizeof(cszIcy_P)-1) == 0)
-                {
-                    hInet->hRequest->byProto = INET_PROTO_ICY;
-                    iProcessed = sizeof(cszIcy_P)-1;
-                }
-
-                if (iProcessed)
-                {
-                    nResult = 1;
-
-                    /* Skip version number */
-                    for (pszStart = pszRespLine + iProcessed; *pszStart != '\r' && *pszStart != ' '; pszStart++)
-                    {
-                        ;
-                    }
-                    if (*pszStart == '\r')
-                    {
-                        /* Could not find whitespace after the version number */
-                        nResult = -1;
-                    }
-                    else
-                    {
-                        /* Skip leading whitespace */
-                        for (; *pszStart == ' '; pszStart++)
-                        {
-                            ;
-                        }
-                        /* Strip trailing whitespace */
-                        for (; ((pszEnd > pszStart) && (*(pszEnd-1) == ' ')); pszEnd--)
-                        {
-                            ;
-                        }
-                    }
-                }
-            }
-            else if ((wInfoLevel & INET_HTTP_QUERY_LOCATION) == INET_HTTP_QUERY_LOCATION)
-            {
-                /*
-                 * Get the new location (redirect URL)
-                 */
-                if (strncasecmp_P(pszRespLine, cszLocation_P, sizeof(cszLocation_P)-1) == 0)
-                {
-                    nResult = 1;
-
-                    /* Skip leading whitespace */
-                    for (pszStart = pszRespLine + sizeof(cszLocation_P)-1; (*pszStart == ' '); pszStart++)
-                    {
-                        ;
-                    }
-
-                    /* Strip trailing whitespace */
-                    for (; ((pszEnd > pszStart) && (*(pszEnd-1) == ' ')); pszEnd--)
-                    {
-                        ;
-                    }
-                }
-            }
-            else if ((wInfoLevel & INET_HTTP_QUERY_CONTENT_LENGTH) == INET_HTTP_QUERY_CONTENT_LENGTH)
-            {
-                /*
-                 * Get the content-length
-                 */
-                if (strncasecmp_P(pszRespLine, cszContentLength_P, sizeof(cszContentLength_P)-1) == 0)
-                {
-                    nResult = 1;
-
-                    /* Skip leading whitespace */
-                    for (pszStart = pszRespLine + sizeof(cszContentLength_P)-1; (*pszStart == ' '); pszStart++)
-                    {
-                        ;
-                    }
-                }
-            }
-            else if ((wInfoLevel & INET_HTTP_QUERY_CONTENT_TYPE) == INET_HTTP_QUERY_CONTENT_TYPE)
-            {
-                /*
-                 * Get the content-type
-                 */
-                if (strncasecmp_P(pszRespLine, cszContentType_P, sizeof(cszContentType_P)-1) == 0)
-                {
-                    nResult = 1;
-
-                    /* Skip leading whitespace */
-                    for (pszStart = pszRespLine + sizeof(cszContentType_P)-1; (*pszStart == ' '); pszStart++)
-                    {
-                        ;
-                    }
-                }
-            }
-            else if ((wInfoLevel & INET_HTTP_QUERY_ICY_METADATA) == INET_HTTP_QUERY_ICY_METADATA)
-            {
-                /*
-                 * Get the content-type
-                 */
-                if (strncasecmp_P(pszRespLine, cszIcyMetaData_P, sizeof(cszIcyMetaData_P)-1) == 0)
-                {
-                    nResult = 1;
-
-                    /* Skip leading whitespace */
-                    for (pszStart = pszRespLine + sizeof(cszIcyMetaData_P)-1; (*pszStart == ' '); pszStart++)
-                    {
-                        ;
-                    }
-                }
-            }
-        }
-        /* Find next line */
-        pszRespLine = pszEnd;
-    } /* end while */
-
-    /*
-     * If we found what we are looking for, pass and optionally convert the resulting value to the caller
-     */
-    if (nResult > 0)
-    {
-        long lNumericValue = -1;
-
-        if ((wInfoLevel & INET_HTTP_QUERY_MOD_NUMERIC) == INET_HTTP_QUERY_MOD_NUMERIC)
-        {
-            unResultSize = sizeof(lNumericValue);
-        }
-        else
-        {
-            unResultSize = pszEnd - pszStart;
-            if (unResultSize > 0)
-            {
-                /* Correction so we can store the \0 */
-                unResultSize += 1;
-            }
-        }
-
-        /* Allocate a buffer if the caller did not */
-        if (*punInfoSize == 0)
-        {
-            *pInfo = MyMalloc(unResultSize);
-            *punInfoSize = unResultSize;
-        }
-
-        /* Copy if there is room */
-        if ((*punInfoSize >= unResultSize) &&
-            (*pInfo != NULL))
-        {
-            if ((wInfoLevel & INET_HTTP_QUERY_MOD_NUMERIC) == INET_HTTP_QUERY_MOD_NUMERIC)
-            {
-                long *plDest = *pInfo;
-                lNumericValue = strtol(pszStart, (char **) NULL, 0);
-                *plDest = lNumericValue;
-            }
-            else
-            {
-                if (unResultSize > 0)
-                {
-                    char *pszDest = *pInfo;
-                    memcpy(pszDest, pszStart, unResultSize-1);
-                    pszDest[unResultSize-1] = '\0';
-                }
-            }
-        }
-        else
-        {
-            /* No room to store the result */
-            nResult = -1;
-        }
-        *punInfoSize = unResultSize;
-    }
-    return (nResult);
-}
-
-/*\brief Mime types */
-static prog_char cszTypeAudio_P[]   = "audio/";
-static prog_char cszTypeText_P[]    = "text/";
-
-/*\brief Audio subtypes */
-static prog_char cszTypeM3u_P[]     = "x-mpegurl";
-static prog_char cszTypePls_P[]     = "x-scpls";
-//static prog_char cszSubtypeWma[]  = "x-ms-wma";
-//static prog_char cszSubtypeMp3[]  = "mpeg";
-//static prog_char cszSubtypeAac[]  = "aacp";
-
-/*\brief File extensions */
-static prog_char cszPlsExtension_P[]    = "pls";
-static prog_char cszM3uExtension_P[]    = "m3u";
-
-int InetGetMimeType(HINET hInet)
-{
-    int nResult = +1;
-    int nType = MIME_TYPE_UNKNOWN;
-    char *pszContentType = NULL;
-
-    /*
-     * Try to determine the filetype based on the content type header
-     */
-    int nHeaderNumber = 0;
-    void *ppszContentType = &pszContentType;
-    unsigned int unInfoSize = 0;
-
-    nResult = InetHttpQueryInfo(hInet,
-                                INET_HTTP_QUERY_CONTENT_TYPE,
-                                ppszContentType,
-                                &unInfoSize,
-                                &nHeaderNumber);
-    if (nResult > 0)
-    {
-        if (strncasecmp_P(pszContentType, cszTypeAudio_P, sizeof(cszTypeAudio_P)-1) == 0)
-        {
-            nType = MIME_TYPE_MP3;
-
-            char *pszSubType = pszContentType + sizeof(cszTypeAudio_P)-1;
-            if (strncasecmp_P(pszSubType, cszTypePls_P, sizeof(cszTypePls_P)-1) == 0)
-            {
-                 nType = MIME_TYPE_PLS;
-            }
-            else if (strncasecmp_P(pszSubType, cszTypeM3u_P, sizeof(cszTypeM3u_P)-1) == 0)
-            {
-                nType = MIME_TYPE_M3U;
-            }
-        }
-        else if (strncasecmp_P(pszContentType, cszTypeText_P, sizeof(cszTypeText_P)-1) == 0)
-        {
-            /* Assume the generic text type */
-            nType = MIME_TYPE_TEXT;
-        }
-    }
-    else
-    {
-        nType = MIME_TYPE_MP3;
-    }
-
-    /*
-     * Icecast servers serve only audio
-     */
-    if ((nType == MIME_TYPE_UNKNOWN) && (hInet->hRequest->byProto == INET_PROTO_ICY))
-    {
-        nType = MIME_TYPE_MP3;
-    }
-
-    /*
-     * If all else fails, use the extension of the path
-     */
-    if ((nType == MIME_TYPE_UNKNOWN) || (nType == MIME_TYPE_TEXT))
-    {
-        /* Assume the extension starts at the last '.' we can find */
-        char *szExtension = strrchr(hInet->tUrlParts.pszPath, '.');
-        if (szExtension != NULL)
-        {
-            szExtension++; /* Skip the . */
-            if (strncasecmp_P(szExtension, cszPlsExtension_P, sizeof(cszPlsExtension_P)-1) == 0)
-            {
-                nType = MIME_TYPE_PLS;
-            }
-            else if (strncasecmp_P(szExtension, cszM3uExtension_P, sizeof(cszM3uExtension_P)-1) == 0)
-            {
-                nType = MIME_TYPE_M3U;
-            }
-        }
-    }
-
-    LogMsg_P(LOG_INFO, PSTR("File type %d"), nType);
-
-    MyFree(pszContentType);
-
-    return (nType);
-}
-
-int InetRead(HINET hInet, char *pcBuf, unsigned int unBufSize)
-{
-    int nResult = -1;
-
-    if (hInet != NULL)
-    {
-        if (hInet->tState != INET_STATE_CLOSING)
-        {
-            hInet->tState = INET_STATE_BUSY;
-
-            //nResult = _read((int)hInet->ptSocket, pcBuf, unBufSize);
-            nResult = NutTcpReceive(hInet->ptSocket, pcBuf, unBufSize);
-            if (nResult < 0)
-            {
-                /*
-                 * Either an error occurred or the other side closed the connection (= EOF).
-                 */
-                LogMsg_P(LOG_INFO, PSTR("EOF %d"), NutTcpError(hInet->ptSocket));
-            }
-            else if (nResult == 0)
-            {
-                LogMsg_P(LOG_INFO, PSTR("Read Timeout"));
-            }
-        }
-
-        hInet->tState = INET_STATE_IDLE;
-    }
-    return (nResult);
-}
-
-int InetReadExact(HINET hInet, unsigned char *pbyBuf, unsigned int unBufSize)
-{
-    int nResult = +1;
-    unsigned int unBufInUse = 0;
-
-    /* Sanity check */
-    if ((hInet == NULL) || (pbyBuf == NULL))
-    {
-        return (-1);
-    }
-
-    /* Keep reading until we are done */
-    while ((nResult > 0) && (unBufSize-unBufInUse) > 0)
-    {
-        nResult = InetRead(hInet, (char*)&pbyBuf[unBufInUse], unBufSize-unBufInUse);
-        //LogMsg_P(LOG_DEBUG, PSTR("r %d,max %u"), nResult, unBufSize-unBufInUse);
-
-        if (nResult > 0)
-        {
-            unBufInUse += nResult;
-        }
-    }
-    return (unBufInUse);
-}
-
-int InetReadFile(HINET hInet, char **ppcBuf, unsigned int *punBufSize)
-{
-    int nResult = +1;
-    unsigned int unBufInUse = 0;
-    unsigned char byDoResize = 0;
-
-    /* Sanity check */
-    if ((ppcBuf == NULL) || (punBufSize == NULL))
-    {
-        nResult = -1;
-    }
-
-    /* If you did not provide a buffer, one will be provided for you */
-    if (nResult > 0)
-    {
-        if (*ppcBuf == NULL)
-        {
-            byDoResize = 1;
-            *punBufSize = 0;
-        }
-    }
-
-    /* Keep reading until we are done */
-    while (nResult > 0)
-    {
-        if (byDoResize)
-        {
-            nResult = BufferMakeRoom((char**)ppcBuf, punBufSize, unBufInUse, 100);
-            //LogMsg_P(LOG_DEBUG, PSTR("r %d,size %u, %x"), nResult, *punBufSize, &(*ppcBuf)[unBufInUse]);
-        }
-
-        if (nResult >= 0)
-        {
-            nResult = InetRead(hInet, (char*)&(*ppcBuf)[unBufInUse], *punBufSize-unBufInUse);
-            //LogMsg_P(LOG_DEBUG, PSTR("r %d,max %u"), nResult, *punBufSize-unBufInUse);
-        }
-
-        if (nResult > 0)
-        {
-            unBufInUse += nResult;
-        }
-        else
-        {
-            /*
-             * We have a eof/disconnect (-1), or a read timeout (0)
-             */
-        }
-    }
-
-    if (unBufInUse == 0)
-    {
-        LogMsg_P(LOG_WARNING, PSTR("No data"));
-    }
-    return (unBufInUse);
-}
-
-HINET InetClose(HINET hInet)
-{
-//    LogMsg_P(LOG_DEBUG, PSTR("Close %X %d"), hInet, hInet->tState);
-
-    if (hInet != NULL)
-    {
-        if (hInet->tState != INET_STATE_IDLE)
-        {
-            hInet->tState = INET_STATE_CLOSING;
-
-            /*
-             * Wait for the close to be handled
-             */
-            while (hInet->tState != INET_STATE_IDLE)
-            {
-                unsigned int nCount = 0;
-
-                NutSleep(100);
-
-                /* After 10 seconds */
-                if (++nCount == 100)
-                {
-                    LogMsg_P(LOG_EMERG, PSTR("Close failed"));
-                    break;
-                }
-            }
-        }
-
-        CloseDescriptors(hInet);
-        MyFree(hInet->pszUrl);
-        ShowDebug();
-
-        /*
-         * Deallocate the request struct
-         */
-        if (hInet->hRequest != NULL)
-        {
-            MyFree(hInet->hRequest->pszRequest);
-            ShowDebug();
-            MyFree(hInet->hRequest->pszResponse);
-            ShowDebug();
-            MyFree(hInet->hRequest);
-            ShowDebug();
-        }
-        MyFree(hInet);
-    }
-    ShowDebug();
-    return (hInet);
-}
-

ipac-base-27JAN2011/source/keyboard.c

@@ -1,326 +0,0 @@
-/*! \file
- * keyboard.c contains the low-level keyboard scan and the
- * interfacing with NutOS (signalling)
- *  Copyright STREAMIT, 2010.
- *  \version 1.0
- *  \date 26 september 2003
- */
-
-
-#define LOG_MODULE  LOG_KEYBOARD_MODULE
-
-#include <sys/atom.h>
-#include <sys/event.h>
-
-//#pragma text:appcode
-
-#include "keyboard.h"
-#include "portio.h"
-#include "system.h"
-
-/*-------------------------------------------------------------------------*/
-/* local defines                                                          */
-/*-------------------------------------------------------------------------*/
-/*
- *  definition of raw keys as found in keyboardscan
- *  Note that these 16-bit values are remapped before
- *  the application uses them
- */
-#define RAW_KEY_01         0xFFFB
-#define RAW_KEY_02         0xFFFD
-#define RAW_KEY_03         0xFF7F
-#define RAW_KEY_04         0xFFF7
-#define RAW_KEY_05         0xFFFE
-#define RAW_KEY_ALT        0xFFBF
-
-#define RAW_KEY_ESC        0xFFEF
-#define RAW_KEY_UP         0xF7FF
-#define RAW_KEY_OK         0xFFDF
-#define RAW_KEY_LEFT       0xFEFF
-#define RAW_KEY_DOWN       0xFBFF
-#define RAW_KEY_RIGHT      0xFDFF
-
-#define RAW_KEY_POWER      0xEFFF
-
-#define RAW_KEY_SETUP      0xFFCF       // combine 'ESCAPE' (0xFFEF') with 'OK' (0xFFDF)
-
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-static HANDLE  hKBEvent;
-static u_short KeyFound;        // use short for 4 nibbles (4 colums)
-static u_char KeyBuffer[KB_BUFFER_SIZE];
-static u_short HoldCounter;
-static u_char KbState;
-static u_char KeyRepeatArray[KEY_NROF_KEYS];
-
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-static void KbClearEvent(HANDLE*);
-static u_char KbRemapKey(u_short LongKey);
-
-
-/*!
- * \addtogroup Keyboard
- */
-
-/*@{*/
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-
-
-
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Clear the eventbuffer of this module
- *
- * This routine is called during module initialization.
- *
- * \param *pEvent pointer to the event queue
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static void KbClearEvent(HANDLE *pEvent)
-{
-    NutEnterCritical();
-
-    *pEvent = 0;
-
-    NutExitCritical();
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Low-level keyboard scan
- *
- * KbScan is called each 4.44 msec from MainBeat interrupt
- * Remember: pressed key gives a '0' on KB_IN_READ
- *
- * After each keyboard-scan, check for a valid MMCard
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-void KbScan()
-{
-    u_char KeyNibble0, KeyNibble1, KeyNibble2, KeyNibble3;
-
-    /*
-     *  we must scan 4 colums, 2 in PORTG and 2 in PORTD
-     */
-
-#ifndef USE_JTAG
-    // scan keys in COL 0
-    cbi (KB_OUT_WRITE_A, KB_COL_0);
-    asm("nop\n\tnop");                    // small delay
-    KeyNibble0 = inp(KB_IN_READ) & KB_ROW_MASK;
-    sbi (KB_OUT_WRITE_A, KB_COL_0);
-
-    // scan keys in COL 1
-    cbi (KB_OUT_WRITE_A, KB_COL_1);
-    asm("nop\n\tnop");                    // small delay
-    KeyNibble1 = inp(KB_IN_READ) & KB_ROW_MASK;
-    sbi (KB_OUT_WRITE_A, KB_COL_1);
-
-    // scan keys in COL 2
-    cbi (KB_OUT_WRITE_B, KB_COL_2);
-    asm("nop\n\tnop");                    // small delay
-    KeyNibble2 = inp(KB_IN_READ) & KB_ROW_MASK;
-    sbi (KB_OUT_WRITE_B, KB_COL_2);
-
-    // scan keys in COL 3
-    cbi (KB_OUT_WRITE_B, KB_COL_3);
-    asm("nop\n\tnop");                    // small delay
-    KeyNibble3 = inp(KB_IN_READ) & KB_ROW_MASK;
-    sbi (KB_OUT_WRITE_B, KB_COL_3);
-
-
-    /*
-     *  we want to detect exactly 1 key in exactly 1 colom
-     *  exception is the combination of VOLMIN & POWER (-> SETUP)
-     *  meaning: Keynibble0==[0000 1011] (KEY_VOLMIN) & KeyNibble1==[0111 0000] (KEY_POWER)
-     */
-
-    /*
-     *  put all 4 seperate nibbles in place in 'KeyFound'
-     *
-     *  KeyNibble0 on b3...b0  (col 0)
-     *  KeyNibble1 on b7...b4  (col 1)
-     *  KeyNibble2 on b11..b8  (col 2)
-     *  KeyNibble3 on b15..b12 (col 3)
-     */
-
-    KeyFound =  ((KeyNibble0>>4) & 0x000F);     // b7..b4 in 'KeyNibble0' to b3...b0  in 'KeyFound' >> shift 4 right
-    KeyFound |= (KeyNibble1 & 0x00F0);          // b7..b4 in 'KeyNibble1' to b7...b4  in 'KeyFound' -- do nothing
-    KeyFound |= ((KeyNibble2<<4) & 0x0F00);     // b7..b4 in 'KeyNibble2' to b11..b8  in 'KeyFound' << shift 4 left
-    KeyFound |= ((KeyNibble3<<8) & 0xF000);     // b7..b4 in 'KeyNibble3' to b15..b12 in 'KeyFound' << shift 8 left
-
-
-#endif  // USE_JTAG
-
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Remap the 16-bit value for the active key to an 8-bit value
- *
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static u_char KbRemapKey(u_short LongKey)
-{
-    switch (LongKey)
-    {
-        case RAW_KEY_01:        return(KEY_01);
-        case RAW_KEY_02:        return(KEY_02);
-        case RAW_KEY_03:        return(KEY_03);
-        case RAW_KEY_04:        return(KEY_04);
-        case RAW_KEY_05:        return(KEY_05);
-        case RAW_KEY_ALT:       return(KEY_ALT);
-
-        case RAW_KEY_ESC:       return(KEY_ESC);
-        case RAW_KEY_UP:        return(KEY_UP);
-        case RAW_KEY_OK:        return(KEY_OK);
-        case RAW_KEY_LEFT:      return(KEY_LEFT);
-        case RAW_KEY_DOWN:      return(KEY_DOWN);
-        case RAW_KEY_RIGHT:     return(KEY_RIGHT);
-
-        case RAW_KEY_POWER:     return(KEY_POWER);
-        case RAW_KEY_SETUP:     return(KEY_SETUP);      // combined key
-
-        default:                return(KEY_UNDEFINED);
-    }
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Return the repeating property for this key
- *
- * \return 'TRUE' in case the key was repeating, 'FALSE' if not
- *
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static u_char KbKeyIsRepeating(u_short Key)
-{
-    return(KeyRepeatArray[KbRemapKey(Key)]==KEY_REPEAT);
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief set the property of this key to repeating or not-repeating
- *
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-void KbSetKeyRepeating(u_char Key, u_char Property)
-{
-    // check arguments
-    if (((Property==KEY_REPEAT) || (Property==KEY_NO_REPEAT)) && (Key < KEY_NROF_KEYS))
-    {
-        KeyRepeatArray[Key]=Property;
-    }
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Wait until an event was pushed on the eventqueue for this module
- *
- * This routine provides the event interface for other Luks-modules
- *
- * \param dwTimeout time in milisecs that this routine should wait before
- * it will return with KB_ERROR
- *
- * \return KB_OK in case an event was found
- * \return KB_ERROR in case no event was found (return due to timeout)
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-int KbWaitForKeyEvent(u_long dwTimeout)
-{
-
-    int nError = KB_OK;
-    int nTimeout;
-
-    nTimeout = NutEventWait(&hKBEvent, dwTimeout);
-    if (nTimeout == -1)
-    {
-        nError = KB_ERROR;
-    }
-
-    return(nError);
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Return the databyte that was receeived in the IR-stream
- *
- * In case a valid key is found in the keyboard scan, the key-code is
- * stored in the keyboardbuffer. This routine returns the first available
- * valid key in this buffer
-
- * \return the keycode that was found by the keyboard scan
- *
- * \todo implement a key-buffer for this routine
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-u_char KbGetKey()
-{
-    return(KeyBuffer[0]);
-}
-
-/*!
- * \brief inject a virtual key into the system
- *
- */
-void KbInjectKey(u_char VirtualKey)
-{
-    KeyBuffer[0]=VirtualKey;
-    NutEventPostFromIrq(&hKBEvent);   // 'valid key' detected -> generate Event
-}
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Initialise the Keyboard module
- *
- *
- * - initialise the keyboard read- and write port
- * - flush the keyboardbuffer
- * - flush the eventqueue for this module
- *
- * \note PORTF uses internal pull-ups. That's why a '1' is read
- * when no key is pressed. Use negative logic to detect keys.
- * So default state of the colums is '1'
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-void KbInit()
-{
-    u_char i;
-
-    sbi (KB_OUT_WRITE_A, KB_COL_0);
-    sbi (KB_OUT_WRITE_A, KB_COL_1);
-    sbi (KB_OUT_WRITE_B, KB_COL_2);
-    sbi (KB_OUT_WRITE_B, KB_COL_3);
-
-    KbState = KB_IDLE;
-    KeyFound = KEY_NO_KEY;
-
-    KbClearEvent(&hKBEvent);
-
-    for (i=0;i<KB_BUFFER_SIZE;++i)
-    {
-        KeyBuffer[i] = (u_char)KEY_NO_KEY;
-    }
-
-    for (i=0; i<KEY_NROF_KEYS; ++i)
-    {
-        KeyRepeatArray[i]=KEY_NO_REPEAT;
-    }
-
-    HoldCounter=0;
-
-    // arrow keys are repeating keys by default
-    KbSetKeyRepeating(KEY_UP, KEY_REPEAT);
-    KbSetKeyRepeating(KEY_DOWN, KEY_REPEAT);
-    KbSetKeyRepeating(KEY_LEFT, KEY_REPEAT);
-    KbSetKeyRepeating(KEY_RIGHT, KEY_REPEAT);
-}
-/* ---------- end of module ------------------------------------------------ */
-
-/*@}*/

ipac-base-27JAN2011/source/led.c

@@ -1,111 +0,0 @@
-/*! \file
- * Led.c contains all interface- and low-level routines to
- * control the LED
- *  Copyright STREAMIT BV 2010
- *  \version 1.0
- *  \date 26 september 2003
- */
-
-
-#define LOG_MODULE  LOG_LED_MODULE
-
-#include <sys/timer.h>
-#include <sys/thread.h>
-#include <sys/event.h>
-
-#include "system.h"
-#include "portio.h"
-#include "led.h"
-
-static u_char LedStatus;
-
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-
-
-/*!
- * \addtogroup Led
- */
-
-/*@{*/
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Interface routine to control the SIR LED
- *
- * Using this routine, the LED can be set to 'ON', 'OFF" or it's state can
- * be toggeld
- *
- * \param LedMode can be eiter 'ON', 'OFF' or 'TOGGLE'
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/************************************************************/
-/*  Control the LED: ON, OFF or TOGGLE                      */
-/*                   in case Lucas is 'OFF' -> return       */
-/************************************************************/
-void LedControl(u_char LedMode)
-{
-   switch (LedMode)
-    {
-        case LED_OFF:
-        case LED_POWER_OFF:
-        case LED_FLASH_OFF:
-            cbi (LED_OUT_WRITE, LED_PIN);
-            LedStatus = LedMode;
-            break;
-        case LED_ON:
-        case LED_POWER_ON:
-        case LED_FLASH_ON:
-            sbi (LED_OUT_WRITE, LED_PIN);
-            LedStatus = LedMode;
-            break;
-        case LED_TOGGLE:
-            if (LedStatus == LED_ON)
-            {
-                cbi (LED_OUT_WRITE, LED_PIN);
-                LedStatus = LED_OFF;
-            }
-            else
-            {
-                sbi (LED_OUT_WRITE, LED_PIN);
-                LedStatus = LED_ON;
-            }
-            break;
-    }
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Initialise the Led module
- *
- * clear LED and update LedStatus
- *
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-void LedInit()
-{
-    cbi (LED_OUT_WRITE, LED_PIN);
-    LedStatus = LED_OFF;
-}
-
-/*!
- * \brief Get LedStatus for external use
- *
- */
-u_char LedGetStatus()
-{
-  return(LedStatus);
-}
-
-/* ---------- end of module ------------------------------------------------ */
-
-/*@}*/

ipac-base-27JAN2011/source/log.c

@@ -1,371 +0,0 @@
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : Log
- *  File name  $Workfile:   Log.c  $
- *       Last Save $Date:   2003/08/16 15:01:19  $
- *             $Revision:   0.1  $
- *  Creation Date       : 2003/08/16 15:01:19
- *
- *  Description         : Keeps track of log messages
- *                        As an initial implementation this module
- *                        outputs messages to the serial port and uses
- *                        no buffering. (As a result logging delays execution
- *                        as long as the serial write takes)
- *                        At a later stage this module will have a logging
- *                        queue. This will not have much impact on execution
- *                        time. It will output messages to either a serial port
- *                        or telnet client.
- *
- */
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#define LOG_MODULE  LOG_LOG_MODULE
-
-#include <stdio.h>
-#include <string.h>
-
-#include <sys/thread.h>
-#include <sys/heap.h>
-#include <sys/device.h>
-#include <sys/osdebug.h>
-
-//#pragma text:appcode
-
-#include "uart0driver.h"
-//#include "settings.h"
-#include "log.h"
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-/*!\brief Max length of address */
-#define MAX_OFFSET_LEN  8
-
-/*!\brief Max byte values printed on a line */
-#define BYTES_PER_LINE  16
-
-/*!\brief Max number of characters hex dump takes: 2 digits plus trailing blank */
-#define HEX_DUMP_LEN    (BYTES_PER_LINE*3)
-
-/*!\brief Number of characters hex dump + ascii take: 3 chars, 2 blanks, 1 char */
-#define DATA_DUMP_LEN   (HEX_DUMP_LEN + 2 + BYTES_PER_LINE)
-
-/*!\brief Number of characters per line: address, 2 blanks, data dump */
-#define MAX_LINE_LEN    (MAX_OFFSET_LEN + 2 + DATA_DUMP_LEN)
-
-#define LEVEL_MASK      0x07        // b0...b2
-#define NAME_MASK       0xF8        // b3..b7
-
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local variables                                                         */
-/*--------------------------------------------------------------------------*/
-/*!\brief The current log level */
-static TLogLevel    g_tLevel;
-
-/*!\brief Stream to output the log data to */
-static FILE         *g_tStream;
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local functions                                                         */
-/*--------------------------------------------------------------------------*/
-
-/*!
- * \brief Return the prefix-level for the given log level.
- *
- * \param   tLevel [in] The log level.
- *
- * \return  Pointer to a string in program space.
- */
-static PGM_P LogPrefixLevel_P(TLogLevel tLevel)
-{
-
-    switch (tLevel)
-    {
-        case LOG_EMERG_LEV   :return(PSTR("\n#Emerg "));
-        case LOG_ALERT_LEV   :return(PSTR("\n#Alert "));
-        case LOG_CRIT_LEV    :return(PSTR("\n#Crit  "));
-        case LOG_ERR_LEV     :return(PSTR("\n#Err   "));
-        case LOG_WARNING_LEV :return(PSTR("\n#Warn  "));
-        case LOG_NOTICE_LEV  :return(PSTR("\n#Notic "));
-        case LOG_INFO_LEV    :return(PSTR("\n#Info  "));
-        case LOG_DEBUG_LEV   :return(PSTR("\n#Debug "));
-        default          :return(PSTR("\n"));
-    }
-}
-
-/*!
- * \brief Return the prefix-name for the given log module.
- *
- * \param   tLevel [in] The log module.
- *
- * \return  Pointer to a string in program space.
- */
-static PGM_P LogPrefixName_P(TLogLevel tLevel)
-{
-
-    switch (tLevel)
-    {
-        case LOG_AUDIO_MODULE        :return(PSTR("AU: "));
-        case LOG_CHANNEL_MODULE      :return(PSTR("CH: "));
-        case LOG_COMAND_MODULE       :return(PSTR("CM: "));
-        case LOG_DISPLAY_MODULE      :return(PSTR("DP: "));
-        case LOG_FAT_MODULE          :return(PSTR("FA: "));
-        case LOG_FLASH_MODULE        :return(PSTR("FL: "));
-        case LOG_HTTP_MODULE         :return(PSTR("HT: "));
-        case LOG_INET_MODULE         :return(PSTR("IN: "));
-        case LOG_KEYBOARD_MODULE     :return(PSTR("KB: "));
-        case LOG_LED_MODULE          :return(PSTR("LE: "));
-        case LOG_LOG_MODULE          :return(PSTR("LG: "));
-        case LOG_MAIN_MODULE         :return(PSTR("SY: "));
-        case LOG_MENU_MODULE         :return(PSTR("ME: "));
-        case LOG_MMC_MODULE          :return(PSTR("MM: "));
-        case LOG_MMCDRV_MODULE       :return(PSTR("MD: "));
-        case LOG_PARSE_MODULE        :return(PSTR("PA: "));
-        case LOG_PLAYER_MODULE       :return(PSTR("PL: "));
-        case LOG_REMCON_MODULE       :return(PSTR("RC: "));
-        case LOG_RTC_MODULE          :return(PSTR("RT: "));
-        case LOG_SELFTEST_MODULE     :return(PSTR("ST: "));
-        case LOG_SESSION_MODULE      :return(PSTR("SE: "));
-        case LOG_SETTINGS_MODULE     :return(PSTR("SG: "));
-        case LOG_SPIDRV_MODULE       :return(PSTR("SP: "));
-        case LOG_STREAMER_MODULE     :return(PSTR("SR: "));
-        case LOG_UART0DRIVER_MODULE  :return(PSTR("UA: "));
-        case LOG_UPDATE_MODULE       :return(PSTR("UD: "));
-        case LOG_UTIL_MODULE         :return(PSTR("UT: "));
-        case LOG_VERSION_MODULE      :return(PSTR("VE: "));
-        case LOG_VS10XX_MODULE       :return(PSTR("VS: "));
-        case LOG_WATCHDOG_MODULE     :return(PSTR("WD: "));
-        default          :return(PSTR("?? <DMK> "));
-    }
-}
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*!
- * \brief Initialises this module
- *
- * \param   -
- *
- * \return  -
- */
-void LogInit(void)
-{
-    /* Set default level */
-    g_tLevel = LOG_DEBUG_LEV;
-
-    LogOpen();
-}
-
-/*!
- * \brief Opens the module for use.
- *
- * \param   -
- *
- * \return  -
- */
-void LogOpen(void)
-{
-    /* Associate our stream with a device */
-    g_tStream = Uart0DriverGetStream();
-}
-
-/*!
- * \brief Closes the module.
- *
- * All interface functions from this module will result in void
- * operations.
- *
- * \param   -
- *
- * \return  -
- */
-void LogClose(void)
-{
-    FILE *tPrevStream = g_tStream;
-
-    /* Don't allow adding of new output. */
-    g_tStream = NULL;
-
-    /* Finish all current output. */
-    fflush(tPrevStream);
-}
-
-/*!
- * \brief Log a message to the log medium using a fixed string.
- *
- * The fixed string must reside in program space. It is parsed
- * using the rules of (s)printf.
- *
- * \param tLevel priority level of the message.
- * \param szMsg  format string of the message.
- * \param ...    arguments to the format string.
- */
-void LogMsg_P(TLogLevel tLevel, PGM_P szMsg, ...)
-{
-    va_list ap;
-
-    if (g_tStream)
-    {
-        /* Log the string if the message is more important than the current level */
-        if ((tLevel&LEVEL_MASK) <= g_tLevel)
-        {
-            fputs_P(LogPrefixLevel_P(tLevel&LEVEL_MASK), g_tStream);
-            fputs_P(LogPrefixName_P(tLevel&NAME_MASK), g_tStream);
-            va_start(ap, szMsg);
-            vfprintf_P(g_tStream, szMsg, ap);
-            va_end(ap);
-        }
-    }
-}
-
-void LogChar_P(const char bChar)
-{
-    if (g_tStream)
-    {
-        fputc(bChar, g_tStream);
-    }
-}
-
-/*!
- * \brief Set the priority level
- *
- * \param tNewLevel New priority level
- *
- * \return The previous priority level
- */
-TLogLevel LogSetLevel(TLogLevel tNewLevel)
-{
-    TLogLevel tPrevLevel = g_tLevel;
-
-    if (tNewLevel <= LOG_DEBUG_LEV)
-    {
-        g_tLevel = tNewLevel;
-    }
-    return(tPrevLevel);
-}
-
-/*!
- * \brief Print a block of memory
- *
- * Prints out 16 bytes of data per line
- * Every line starts with the address (offset),
- * the data in hex and that same data in ascii.
- *
- * \param tStream The stream to print to
- * \param cp The data
- * \param length The length of the data
- *
- * \return none
- */
-void HexDump(FILE *tStream, CONST u_char *cp, size_t length)
-{
-    register unsigned int address, i, hex_pos, ascii_pos, l;
-    unsigned int address_len;
-    unsigned char c;
-    char line[MAX_LINE_LEN + 1];
-    static CONST char binhex[16] =
-    {
-        '0', '1', '2', '3', '4', '5', '6', '7',
-        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
-    };
-
-    if (tStream != NULL)
-    {
-        /*
-         * How many digits do we need for the address?
-         * We use at least 4 digits or more as needed
-         */
-        if (((length - 1) & 0xF0000000) != 0)
-        {
-            address_len = 8;
-        }
-        else if (((length - 1) & 0x0F000000) != 0)
-        {
-            address_len = 7;
-        }
-        else if (((length - 1) & 0x00F00000) != 0)
-        {
-            address_len = 6;
-        }
-        else if (((length - 1) & 0x000F0000) != 0)
-        {
-            address_len = 5;
-        }
-        else
-        {
-            address_len = 4;
-        }
-
-        address = 0;
-        i = 0;
-        hex_pos = 0;
-        ascii_pos = 0;
-        while (i < length)
-        {
-            if ((i & 15) == 0)
-            {
-                /*
-                 * Start of a new line.
-                 */
-                memset(line, ' ', sizeof(line));
-                hex_pos = 0;
-                ascii_pos = 0;
-                l = address_len;
-                do
-                {
-                    l--;
-                    c = (address >> (l*4)) & 0xF;
-                    line[hex_pos++] = binhex[c];
-                } while (l != 0);
-
-                /* 2 spaces */
-                hex_pos += 2;
-
-                /*
-                 * Offset in line of ASCII dump.
-                 */
-                ascii_pos = hex_pos + HEX_DUMP_LEN + 2;
-            }
-            c = *cp++;
-
-            /* Dump the hex value */
-            line[hex_pos++] = binhex[c >> 4];
-            line[hex_pos++] = binhex[c & 0xF];
-            hex_pos++;
-
-            /* Print the ascii value */
-            line[ascii_pos++] = (c >= ' ' && c < 127) ? c : '.';
-
-            i++;
-            if ((i & 15) == 0 || i == length)
-            {
-                /*
-                 * We'll be starting a new line, or
-                 * we're finished printing this buffer;
-                 * dump out the line we've constructed,
-                 * and advance the offset.
-                 */
-                line[ascii_pos] = '\0';
-                fputs(line, tStream);
-                fputc('\n', tStream);
-                address += BYTES_PER_LINE;
-            }
-        }
-    }
-}
-

ipac-base-27JAN2011/source/main.c

@@ -1,299 +0,0 @@
-/*! \mainpage SIR firmware documentation
- *
- *  \section intro Introduction
- *  A collection of HTML-files has been generated using the documentation in the sourcefiles to
- *  allow the developer to browse through the technical documentation of this project.
- *  \par
- *  \note these HTML files are automatically generated (using DoxyGen) and all modifications in the
- *  documentation should be done via the sourcefiles.
- */
-
-/*! \file
- *  COPYRIGHT (C) STREAMIT BV 2010
- *  \date 19 december 2003
- */
- 
- 
- 
-
-#define LOG_MODULE  LOG_MAIN_MODULE
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <stdio.h>
-#include <string.h>
-
-#include <sys/thread.h>
-#include <sys/timer.h>
-#include <sys/version.h>
-#include <dev/irqreg.h>
-
-#include "system.h"
-#include "portio.h"
-#include "display.h"
-#include "remcon.h"
-#include "keyboard.h"
-#include "led.h"
-#include "log.h"
-#include "uart0driver.h"
-#include "mmc.h"
-#include "watchdog.h"
-#include "flash.h"
-#include "spidrv.h"
-
-#include <time.h>
-#include "rtc.h"
-
-
-/*-------------------------------------------------------------------------*/
-/* global variable definitions                                             */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-
-
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-static void SysMainBeatInterrupt(void*);
-static void SysControlMainBeat(u_char);
-
-/*-------------------------------------------------------------------------*/
-/* Stack check variables placed in .noinit section                         */
-/*-------------------------------------------------------------------------*/
-
-/*!
- * \addtogroup System
- */
-
-/*@{*/
-
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief ISR MainBeat Timer Interrupt (Timer 2 for Mega128, Timer 0 for Mega256).
- *
- * This routine is automatically called during system
- * initialization.
- *
- * resolution of this Timer ISR is 4,448 msecs
- *
- * \param *p not used (might be used to pass parms from the ISR)
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static void SysMainBeatInterrupt(void *p)
-{
-
-    /*
-     *  scan for valid keys AND check if a MMCard is inserted or removed
-     */
-    KbScan();
-    CardCheckCard();
-}
-
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Initialise Digital IO
- *  init inputs to '0', outputs to '1' (DDRxn='0' or '1')
- *
- *  Pull-ups are enabled when the pin is set to input (DDRxn='0') and then a '1'
- *  is written to the pin (PORTxn='1')
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-void SysInitIO(void)
-{
-    /*
-     *  Port B:     VS1011, MMC CS/WP, SPI
-     *  output:     all, except b3 (SPI Master In)
-     *  input:      SPI Master In
-     *  pull-up:    none
-     */
-    outp(0xF7, DDRB);
-
-    /*
-     *  Port C:     Address bus
-     */
-
-    /*
-     *  Port D:     LCD_data, Keypad Col 2 & Col 3, SDA & SCL (TWI)
-     *  output:     Keyboard colums 2 & 3
-     *  input:      LCD_data, SDA, SCL (TWI)
-     *  pull-up:    LCD_data, SDA & SCL
-     */
-    outp(0x0C, DDRD);
-    outp((inp(PORTD) & 0x0C) | 0xF3, PORTD);
-
-    /*
-     *  Port E:     CS Flash, VS1011 (DREQ), RTL8019, LCD BL/Enable, IR, USB Rx/Tx
-     *  output:     CS Flash, LCD BL/Enable, USB Tx
-     *  input:      VS1011 (DREQ), RTL8019, IR
-     *  pull-up:    USB Rx
-     */
-    outp(0x8E, DDRE);
-    outp((inp(PORTE) & 0x8E) | 0x01, PORTE);
-
-    /*
-     *  Port F:     Keyboard_Rows, JTAG-connector, LED, LCD RS/RW, MCC-detect
-     *  output:     LCD RS/RW, LED
-     *  input:      Keyboard_Rows, MCC-detect
-     *  pull-up:    Keyboard_Rows, MCC-detect
-     *  note:       Key row 0 & 1 are shared with JTAG TCK/TMS. Cannot be used concurrent
-     */
-#ifndef USE_JTAG
-    sbi(JTAG_REG, JTD); // disable JTAG interface to be able to use all key-rows
-    sbi(JTAG_REG, JTD); // do it 2 times - according to requirements ATMEGA128 datasheet: see page 256
-#endif //USE_JTAG
-
-    outp(0x0E, DDRF);
-    outp((inp(PORTF) & 0x0E) | 0xF1, PORTF);
-
-    /*
-     *  Port G:     Keyboard_cols, Bus_control
-     *  output:     Keyboard_cols
-     *  input:      Bus Control (internal control)
-     *  pull-up:    none
-     */
-    outp(0x18, DDRG);
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Starts or stops the 4.44 msec mainbeat of the system
- * \param OnOff indicates if the mainbeat needs to start or to stop
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static void SysControlMainBeat(u_char OnOff)
-{
-    int nError = 0;
-
-    if (OnOff==ON)
-    {
-        nError = NutRegisterIrqHandler(&OVERFLOW_SIGNAL, SysMainBeatInterrupt, NULL);
-        if (nError == 0)
-        {
-            init_8_bit_timer();
-        }
-    }
-    else
-    {
-        // disable overflow interrupt
-        disable_8_bit_timer_ovfl_int();
-    }
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Main entry of the SIR firmware
- *
- * All the initialisations before entering the for(;;) loop are done BEFORE
- * the first key is ever pressed. So when entering the Setup (POWER + VOLMIN) some
- * initialisatons need to be done again when leaving the Setup because new values
- * might be current now
- *
- * \return \b never returns
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-int main(void)
-{
-	int t = 0;
-	int x = 0;
-	
-	/* 
-	 * Kroeske: time struct uit nut/os time.h (http://www.ethernut.de/api/time_8h-source.html)
-	 *
-	 */
-	tm gmt;
-	/*
-	 * Kroeske: Ook kan 'struct _tm gmt' Zie bovenstaande link
-	 */
-	
-    /*
-     *  First disable the watchdog
-     */
-    WatchDogDisable();
-
-    NutDelay(100);
-
-    SysInitIO();
-	
-	SPIinit();
-    
-	LedInit();
-	
-	LcdLowLevelInit();
-
-    Uart0DriverInit();
-    Uart0DriverStart();
-	LogInit();
-	LogMsg_P(LOG_INFO, PSTR("Hello World"));
-
-    CardInit();
-
-	/*
-	 * Kroeske: sources in rtc.c en rtc.h
-	 */
-    X12Init();
-    if (X12RtcGetClock(&gmt) == 0)
-    {
-		LogMsg_P(LOG_INFO, PSTR("RTC time [%02d:%02d:%02d]"), gmt.tm_hour, gmt.tm_min, gmt.tm_sec );
-    }
-
-
-    if (At45dbInit()==AT45DB041B)
-    {
-        // ......
-    }
-
-
-    RcInit();
-    
-	KbInit();
-
-    SysControlMainBeat(ON);             // enable 4.4 msecs hartbeat interrupt
-
-    /*
-     * Increase our priority so we can feed the watchdog.
-     */
-    NutThreadSetPriority(1);
-
-	/* Enable global interrupts */
-	sei();
-	
-    for (;;)
-    {
-        NutSleep(100);
-		if( !((t++)%15) )
-		{
-			LogMsg_P(LOG_INFO, PSTR("Yes!, I'm alive ... [%d]"),t);
-			
-			LedControl(LED_TOGGLE);
-		
-			if( x )
-			{
-				LcdBackLight(LCD_BACKLIGHT_ON);
-				x = 0;
-			}
-			else
-			{
-				LcdBackLight(LCD_BACKLIGHT_OFF);
-				x = 1;
-			}
-		}
-		
-        WatchDogRestart();
-    }
-
-    return(0);      // never reached, but 'main()' returns a non-void, so.....
-}
-/* ---------- end of module ------------------------------------------------ */
-
-/*@}*/

ipac-base-27JAN2011/source/mmc.c

@@ -1,347 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR100
- * [MODULE]     MMC driver
- * [TITLE]      Media Card driver
- * [FILE]       mmc.c
- * [VSN]        1.0
- * [CREATED]    02 october 2006
- * [LASTCHNGD]  20 may 2007
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    routines and API to support MMC-application
- * ======================================================================== */
-
-#define LOG_MODULE  LOG_MMC_MODULE
-
-#include <string.h>
-#include <stdio.h>
-#include <io.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <ctype.h>
-
-#include <sys/event.h>
-#include <sys/thread.h>
-#include <sys/timer.h>
-#include <sys/device.h>
-#include <sys/bankmem.h>
-#include <sys/heap.h>
-
-//#pragma text:appcode
-
-#include "system.h"
-#include "mmc.h"
-#include "portio.h"
-#include "vs10xx.h"
-#include "display.h"
-#include "log.h"
-#include "fat.h"
-#include "mmcdrv.h"
-#include "led.h"
-#include "keyboard.h"
-
-#ifdef DEBUG
-//#define MMC__DEBUG
-#endif /* #ifdef DEBUG */
-/*-------------------------------------------------------------------------*/
-/* local defines                                                           */
-/*-------------------------------------------------------------------------*/
-
-#define CARD_PRESENT_COUNTER_OK         30
-#define CARD_NOT_PRESENT_COUNTER_OK     20
-
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-/*!\brief Statemachine for card-detection */
-typedef enum T_CARD_STATE
-{
-    CARD_IDLE,                      /* nothing to do */
-    CARD_PRESENT,                   /* card seen at least one time */
-    CARD_VALID,                     /* card seen at least <valid> times */
-    CARD_NOT_PRESENT                /* card not seen at least (valid> times */
-}TCardState;
-
-
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-static u_char CardPresentFlag;
-static u_char ValidateCounter;
-
-/*!\brief state-variable for Card-statemachine */
-static TCardState CardState;
-
-/*!\brief Status of this module */
-static TError g_tStatus;
-
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-
-
-
-/*!
- * \addtogroup Card
- */
-
-/*@{*/
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-
-/*!
- * \brief check if MM-Card is inserted or removed.
- *
- * \Note: this routine is called from an ISR !
- *
- */
-u_char CardCheckCard(void)
-{
-    u_char RetValue=CARD_NO_CHANGE;
-
-    switch (CardState)
-    {
-        case CARD_IDLE:
-            {
-                if (bit_is_clear(MMC_IN_READ, MMC_CDETECT))
-                {
-                    ValidateCounter=1;
-                    CardState = CARD_PRESENT;
-                }
-            }
-            break;
-        case CARD_PRESENT:
-            {
-                if (bit_is_clear(MMC_IN_READ, MMC_CDETECT))
-                {
-                    if (++ValidateCounter==CARD_PRESENT_COUNTER_OK)
-                    {
-                        CardPresentFlag=CARD_IS_PRESENT;
-                        CardState=CARD_VALID;
-                        RetValue=CARD_IS_PRESENT;
-                    }
-                }
-                else
-                {
-                    CardState=CARD_IDLE;                  // false alarm,start over again
-                }
-            }
-            break;
-        case CARD_VALID:
-            {
-                if (bit_is_set(MMC_IN_READ, MMC_CDETECT))
-                {
-                    ValidateCounter=1;
-                    CardState=CARD_NOT_PRESENT;         // Card removed
-                }
-            }
-            break;
-        case CARD_NOT_PRESENT:
-            {
-                if (++ValidateCounter==CARD_NOT_PRESENT_COUNTER_OK)
-                {
-                    CardPresentFlag=CARD_IS_NOT_PRESENT;
-                    CardState=CARD_IDLE;
-                    RetValue=CARD_IS_NOT_PRESENT;
-                }
-            }
-            break;
-    }
-    return(RetValue);
-}
-
-/*!
- * \brief return status of "Card is Present"
- *
- */
-u_char CardCheckPresent()
-{
-    return(CardPresentFlag);
-}
-
-/*!
- * \brief initialise the card by reading card contents (.pls files)
- *
- * We initialse the card by registering the card and the filesystem
- * that is on the card.
- *
- * Then we start checking if a number of playlists are
- * present on the card. The names of these playlists are hardcoded
- * (1.pls, 2.pls, to 20.pls). We 'search' the card for these list
- * of playlists by trying to open them. If succesfull, we read the
- * number of songs present (int) in that list
- * Finally we update some administration (global) variables
- *
- */
-int CardInitCard()
-{
-    int iResult=-1;
-    int fid;        // current file descriptor
-    char szFileName[10];
-    //u_char i;
-	u_char ief;
-
-    /*
-     * Register our device for the file system (if not done already.....)
-     */
-    if (NutDeviceLookup(devFAT.dev_name) == 0)
-    {
-        ief = VsPlayerInterrupts(0);
-        if ((iResult=NutRegisterDevice(&devFAT, FAT_MODE_MMC, 0)) == 0)
-        {
-            iResult=NutRegisterDevice(&devFATMMC0, FAT_MODE_MMC, 0);
-        }
-        VsPlayerInterrupts(ief);
-    }
-    else
-    {
-        NUTDEVICE * dev;
-
-        /*
-         *  we must call 'FatInit' here to initialise and mount the filesystem (again)
-         */
-
-        FATRelease();
-        ief = VsPlayerInterrupts(0);
-        dev=&devFAT;
-        if (dev->dev_init == 0 || (*dev->dev_init)(dev) == 0)
-        {
-            dev=&devFATMMC0;
-            if (dev->dev_init == 0 || (*dev->dev_init)(dev) == 0)
-            {
-                iResult=0;
-            }
-        }
-        VsPlayerInterrupts(ief);
-    }
-
-    if (iResult==0)
-    {
-        LogMsg_P(LOG_INFO, PSTR("Card mounted"));
-        /*
-         *  try to open the playlists. If an error is returned, we assume the
-         *  playlist does not exist and we do not check any further lists
-         */
-
-		 /* Kroeske: onderstaande code ter illustratie om file op card te openen */
-		 
- //       for (i=1; i<SETTINGS_NROF_PLAYLISTST; ++i)
- //       {
-            // compose name to open
-            //sprintf_P(szFileName, PSTR("FM0:%d.pls"), i);
-            if ((fid = _open(szFileName, _O_RDONLY)) != -1)
-            {
-                _close(fid);
-            }
-            else
-            {
-
-                //g_NrofPlayLists=i-1;
-                //LogMsg_P(LOG_INFO, PSTR("Found %d Playlists on the Card"), i-1);
- //               break;
-            }
-//        }
-    }
-    else
-    {
-        LogMsg_P(LOG_ERR, PSTR("Error initialising File system and Card-driver"));
-    }
-
-    return(iResult);
-}
-
-/*!
- * \brief The CardPresent thread.
- *
- * execute code when card is inserted or redrawn
- *
- * \param   -
- *
- * \return  -
- */
-THREAD(CardPresent, pArg)
-{
-    static u_char OldCardStatus;
-
-    OldCardStatus=CardPresentFlag;
-
-    for (;;)
-    {
-        if ((CardPresentFlag==CARD_IS_PRESENT) && (OldCardStatus==CARD_IS_NOT_PRESENT))
-        {
-            LogMsg_P(LOG_INFO, PSTR("Card inserted"));
-            if (CardInitCard()==0)
-            {
-                KbInjectKey(KEY_MMC_IN);
-            }
-            OldCardStatus=CardPresentFlag;
-        }
-        else if ((CardPresentFlag==CARD_IS_NOT_PRESENT) && (OldCardStatus==CARD_IS_PRESENT))
-        {
-            LogMsg_P(LOG_INFO, PSTR("Card removed"));
-            CardClose();
-            OldCardStatus=CardPresentFlag;
-        }
-        else
-        {
-            NutSleep(500);
-        }
-    }
-}
-
-
-/*!
- * \brief return global variable that indicates the status of this module
- *
- */
-TError CardStatus(void)
-{
-    return(g_tStatus);
-}
-
-/*!
- * \brief Stop playing.
- *
- * \param   -
- *
- * \return  -
- */
-void CardClose(void)
-{
-
-}
-
-
-/*!
- * \brief initialise this module
- *
- */
-void CardInit()
-{
-    char ThreadName[10];
-
-    CardState=CARD_IDLE;
-    CardPresentFlag=CARD_IS_NOT_PRESENT;
-
-    /*
-     * Create a CardPresent thread
-     */
-    strcpy_P(ThreadName, PSTR("CardPres"));
-
-    if (GetThreadByName((char *)ThreadName) == NULL)
-    {
-        if (NutThreadCreate((char *)ThreadName, CardPresent, 0, 768) == 0)
-        {
-            LogMsg_P(LOG_EMERG, PSTR("Thread failed"));
-        }
-    }
-
-}
-
-/* ---------- end of module ------------------------------------------------ */
-
-/*@}*/
-
-

ipac-base-27JAN2011/source/mmcdrv.c

@@ -1,758 +0,0 @@
-/****************************************************************************
-*  This file is part of the MMC device driver.
-*
-*  Copyright (c) 2004 by Michael Fischer. All rights reserved.
-*
-*  Thanks to Sylvain Bissonnette for some of his low level functions.
-*  Take a look at www.microsyl.com (Led Sign with MMC MemoryCard)
-*
-*  Redistribution and use in source and binary forms, with or without
-*  modification, are permitted provided that the following conditions
-*  are met:
-*
-*  1. Redistributions of source code must retain the above copyright
-*     notice, this list of conditions and the following disclaimer.
-*  2. Redistributions in binary form must reproduce the above copyright
-*     notice, this list of conditions and the following disclaimer in the
-*     documentation and/or other materials provided with the distribution.
-*  3. Neither the name of the author nor the names of its contributors may
-*     be used to endorse or promote products derived from this software
-*     without specific prior written permission.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-*  THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-*  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-*  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-*  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-*  SUCH DAMAGE.
-*
-****************************************************************************
-*  History:
-*
-*  10.10.04  mifi   First Version
-****************************************************************************/
-#define __MMCDRV_C__
-
-#define LOG_MODULE  LOG_MMCDRV_MODULE
-
-#include <stdio.h>
-#include <string.h>
-
-#include <sys/timer.h>
-#include <sys/thread.h>
-#include <sys/event.h>
-#include <sys/heap.h>
-
-#include "typedefs.h"
-#include "portio.h"
-#include "mmcdrv.h"
-#include "vs10xx.h"
-#include "led.h"
-#include "log.h"
-#include "spidrv.h"
-
-/*==========================================================*/
-/*  DEFINE: All Structures and Common Constants             */
-/*==========================================================*/
-#define MMC_MAX_SUPPORTED_DEVICE    1
-
-/*
- * Drive Flags
- */
-#define MMC_SUPPORT_LBA             0x0001
-#define MMC_SUPPORT_LBA48           0x0002
-
-#define MMC_READ_ONLY               0x4000
-#define MMC_READY                   0x8000
-
-#define Delay_1ms(_x) NutDelay(_x)
-
-#define SPIDDR        DDRB
-#define SPIPORT       PORTB
-#define SPIPIN        PINB
-
-/*
-    PragmaLab: disable PIN-defines (already defined in 'portio.h'
-#define SCLK          0x02
-#define MOSI          0x04
-#define MISO          0x08
-#define CS            0x20
-#define ENABLE        0x40
-    end PragmaLab
-*/
-
-#define MMC_RESET         0
-#define MMC_INIT          1
-#define MMC_READ_CSD    9
-#define MMC_READ_CID    10
-
-typedef struct _drive
-{
-    /*
-     * Interface values
-     */
-    WORD  wFlags;
-    BYTE  bDevice;
-
-    /*
-     * LBA value
-     */
-    DWORD dTotalSectors;
-    WORD  wSectorSize;
-} DRIVE;
-
-/*==========================================================*/
-/*  DEFINE: Definition of all local Data                    */
-/*==========================================================*/
-static HANDLE          hMMCSemaphore;
-static DRIVE           sDrive[MMC_MAX_SUPPORTED_DEVICE];
-
-static MMC_MOUNT_FUNC *pUserMountFunc;
-static MMC_MOUNT_FUNC *pUserUnMountFunc;
-
-/*==========================================================*/
-/*  DEFINE: Definition of all local Procedures              */
-/*==========================================================*/
-
-
-/************************************************************/
-/*  MMCLock                                                 */
-/************************************************************/
-static void MMCLock(void)
-{
-    NutEventWait(&hMMCSemaphore, 0);
-} /* MMCLock */
-
-/************************************************************/
-/*  MMCFree                                                 */
-/************************************************************/
-static void MMCFree(void)
-{
-    NutEventPost(&hMMCSemaphore);
-} /* MMCFree */
-
-/************************************************************/
-/*  MMCSemaInit                                             */
-/************************************************************/
-static void MMCSemaInit(void)
-{
-    NutEventPost(&hMMCSemaphore);
-} /* MMCSemaInit */
-
-
-/************************************************************
- * int MMCDataToken(void)
- *
- * - pings the card until it gets data token
- * - returns one byte of read info (data token)
- ************************************************************/
-static BYTE MMCDataToken(void)
-{
-    WORD i = 0xffff;
-    BYTE Byte = 0xff;
-
-    while ((Byte != 0xfe) && (--i))
-    {
-        Byte = SPIgetByte();
-    }
-    return(Byte);
-} /* MMCDataToken */
-
-/************************************************************
- * unsigned char MMCGet(void)
- *
- * - pings the card until it gets a non-0xff value
- * - returns one byte of read info
- ************************************************************/
-static BYTE MMCGet(void)
-{
-    WORD i = 0xffff;
-    BYTE Byte = 0xff;
-
-    while ((Byte == 0xff) && (--i))
-    {
-        Byte = SPIgetByte();
-    }
-
-    return(Byte);
-} /* MMCGet */
-
-/************************************************************
- * void MMCCommand(unsigned char command, unsigned int px, unsigned int py)
- *
- * - send one byte of 0xff, then issue command + params + (fake) crc
- * - eat up the one command of nothing after the CRC
- ************************************************************/
-static void MMCCommand(unsigned char command, unsigned int px, unsigned int py)
-{
-    SPIselect(SPI_DEV_MMC);
-
-    SPIputByte(0xff);
-    SPIputByte(command | 0x40);
-    SPIputByte((unsigned char)((px >> 8)&0x0ff)); /* high byte of param y */
-    SPIputByte((unsigned char)(px & 0x00ff));     /* low byte of param y */
-    SPIputByte((unsigned char)((py >> 8)&0x0ff)); /* high byte of param x */
-    SPIputByte((unsigned char)(py & 0x00ff));     /* low byte of param x */
-    SPIputByte(0x95);            /* correct CRC for first command in SPI          */
-                              /* after that CRC is ignored, so no problem with */
-                              /* always sending 0x95                           */
-    SPIputByte(0xff);
-} /* MMCCommand */
-
-/************************************************************/
-/* GetCSD                                                   */
-/************************************************************/
-static int GetCSD (DRIVE *pDrive)
-{
-    int   i;
-    int  nError = MMC_ERROR;
-    BYTE bData[16];
-    WORD wREAD_BL_LEN;
-    WORD wC_SIZE;
-    WORD wC_SIZE_MULT;
-    WORD wDummy;
-    DWORD dTotalSectors = 0;
-
-    MMCCommand(MMC_READ_CSD, 0, 0);
-    if (MMCDataToken() != 0xfe)
-    {
-        LogMsg_P(LOG_ERR, PSTR("error during CSD read"));
-    }
-    else
-    {
-        for (i=0; i<16; i++)
-        {
-            bData[i] = SPIgetByte();
-        }
-
-        SPIputByte(0xff);    /* checksum -> don't care about it for now */
-        SPIputByte(0xff);    /* checksum -> don't care about it for now */
-
-        SPIdeselect();
-
-        /*
-         * Get the READ_BL_LEN
-         */
-        wREAD_BL_LEN = (1 << (bData[5] & 0x0F));
-
-        /*
-         * Get the C_SIZE
-         */
-        wC_SIZE  = (bData[6] & 0x03);
-        wC_SIZE  = wC_SIZE << 10;
-
-        wDummy   = bData[7];
-        wDummy   = wDummy << 2;
-        wC_SIZE |= wDummy;
-
-        wDummy   = (bData[8] & 0xC0);
-        wDummy   = wDummy >> 6;
-        wC_SIZE |= wDummy;
-
-        /*
-         * Get the wC_SIZE_MULT
-         */
-        wC_SIZE_MULT  = (bData[9] & 0x03);
-        wC_SIZE_MULT |= wC_SIZE_MULT << 1;
-        wDummy        = (bData[10] & 0x80);
-        wDummy        = wDummy >> 7;
-        wC_SIZE_MULT |= wDummy;
-        wC_SIZE_MULT  = (1 << (wC_SIZE_MULT+2));
-
-        dTotalSectors  = wC_SIZE+1;
-        dTotalSectors *= wC_SIZE_MULT;
-
-        pDrive->dTotalSectors = dTotalSectors;
-        pDrive->wSectorSize   = wREAD_BL_LEN;
-
-        nError = MMC_OK;
-    }
-
-    return(nError);
-} /* GetCSD */
-
-#if 0
-/************************************************************/
-/* GetCID                                                   */
-/************************************************************/
-static void GetCID(void)
-{
-    int i;
-    BYTE bData[16];
-
-    MMCCommand(MMC_READ_CID, 0, 0);
-    if (MMCDataToken() != 0xfe)
-    {
-        printf("MMC: error during CID read\n");
-    }
-    else
-    {
-        printf("MMC: CID read\n");
-    }
-
-    for (i=0; i<16; i++)
-    {
-        bData[i] = SPIgetByte();
-    }
-
-    SPIputByte(0xff);    /* checksum -> don't care about it for now */
-    SPIputByte(0xff);    /* checksum -> don't care about it for now */
-
-    SPIdeselect();
-
-    printf("MMC: Product Name: %c%c%c%c%c%c\n",
-           bData[3], bData[4], bData[5],
-           bData[6], bData[7], bData[8]);
-} /* GetCID */
-#endif
-
-/************************************************************/
-/*  InitMMCCard                                             */
-/*                                                          */
-/* - flushes card receive buffer                            */
-/* - selects card                                           */
-/* - sends the reset command                                */
-/* - sends the initialization command, waits for card ready */
-/************************************************************/
-static int InitMMCCard(void)
-{
-    WORD i;
-
-    /* PragmaLab: disable initit of PINS and SPI, already done in 'SystemInitIO()'
-    SPIDDR = SCLK + MOSI + CS;
-    SPIPORT = 0x00;
-    Delay_1ms(250);
-    Delay_1ms(250);
-    SPIPORT |= CS;
-    SPCR = (1 << SPE) | (1 << MSTR);  // enable SPI as master, set clk divider
-                                      // set to max speed
-    Delay_1ms(250);
-
-
-    SPIdeselect();
-
-    // start off with 80 bits of high data with card deselected
-
-    PragmaLab: why send dummy bytes with card DEselected? This messes up the VS10XX init */
-    for (i = 0; i < 10; i++)
-    {
-        SPIputByte(0xff);
-    }
-
-    /*end PragmaLab */
-
-    /* send CMD0 - go to idle state */
-    MMCCommand(MMC_RESET, 0, 0);
-
-    if (MMCGet() != 1)
-    {
-        SPIdeselect();
-        return(MMC_ERROR);  // MMC Not detected
-    }
-
-    /* send CMD1 until we get a 0 back, indicating card is done initializing */
-    i = 0xffff;
-    while ((SPIgetByte() != 0) && (--i))
-    {
-        MMCCommand(MMC_INIT, 0, 0);
-    }
-    if (i == 0)
-    {
-        SPIdeselect();
-        return(MMC_ERROR);  // Init Fail
-    }
-
-    SPIdeselect();
-    return(MMC_OK);
-} /* InitMMCCard */
-
-/************************************************************/
-/*  ReadSectors                                             */
-/************************************************************/
-static int ReadSectors(DRIVE *pDrive, BYTE *pBuffer, DWORD dStartSector, WORD wSectorCount)
-{
-    int   nError = MMC_OK;
-    int   nSector;
-    WORD  wDataCount;
-    DWORD dReadSector;
-
-    pDrive = pDrive;
-
-    for (nSector=0; nSector<wSectorCount; nSector++)
-    {
-        dReadSector = dStartSector + nSector;
-
-        MMCCommand(17,(dReadSector>>7) & 0xffff, (dReadSector<<9) & 0xffff);
-        if (MMCDataToken() != 0xfe)
-        {
-            nError = MMC_ERROR;
-            SPIdeselect();
-            break;
-        }
-
-        for (wDataCount=0; wDataCount<512; wDataCount++)
-        { /* read the sector */
-            *pBuffer = SPIgetByte();
-            pBuffer++;
-        }
-
-        SPIputByte(0xff);    /* checksum -> don't care about it for now */
-        SPIputByte(0xff);    /* checksum -> don't care about it for now */
-        SPIdeselect();
-    }
-
-    return(nError);
-} /* ReadSectors */
-
-#if (MMC_SUPPORT_WRITE == 1)
-/************************************************************/
-/*  WriteSectors                                            */
-/************************************************************/
-static BYTE WriteSectors(DRIVE *pDrive, BYTE *pBuffer, DWORD dStartSector, WORD wSectorCount)
-{
-    int   nError = MMC_OK;
-    int   nSector;
-    WORD  wDataCount;
-    DWORD dWriteSector;
-
-    pDrive = pDrive;
-
-    for (nSector=0; nSector<wSectorCount; nSector++)
-    {
-        dWriteSector = dStartSector + nSector;
-
-        MMCCommand(24, (dWriteSector>>7)& 0xffff, (dWriteSector<<9)& 0xffff);
-        if (MMCGet() == 0xff)
-        {
-            nError = MMC_ERROR;
-            SPIdeselect();
-            break;
-        }
-
-        SPIputByte(0xfe);  // Send Start Byte
-
-        for (wDataCount=0; wDataCount<512; wDataCount++)
-        { /* read the sector */
-            SPIputByte(*pBuffer);
-            pBuffer++;
-        }
-
-        SPIputByte(0xff);  /* checksum -> don't care about it for now */
-        SPIputByte(0xff);  /* checksum -> don't care about it for now */
-        SPIputByte(0xff);  /* Read "data response byte"               */
-
-        wDataCount = 0xffff;
-        while ((SPIgetByte() == 0x00) && (--wDataCount)); /* wait for write finish */
-        if (wDataCount == 0)
-        {
-            nError = MMC_ERROR;
-            SPIdeselect();
-            break;
-        }
-
-        SPIdeselect();
-    }
-
-    return(nError);
-}
-#endif /* WriteSectors */
-
-/*==========================================================*/
-/*  DEFINE: All code exported                               */
-/*==========================================================*/
-/************************************************************/
-/*  MMCInit                                                 */
-/************************************************************/
-int MMCInit(int nMMCMode, MMC_MOUNT_FUNC *pMountFunc,
-            MMC_MOUNT_FUNC *pUnMountFunc)
-{
-    int  nError = MMC_OK;
-    BYTE bIndex;
-
-    nMMCMode         = nMMCMode;
-    pUserMountFunc   = pMountFunc;
-    pUserUnMountFunc = pUnMountFunc;
-
-    for (bIndex=0; bIndex<MMC_MAX_SUPPORTED_DEVICE; bIndex++)
-    {
-        memset((BYTE *) & sDrive[bIndex], 0x00, sizeof(DRIVE));
-
-        sDrive[bIndex].bDevice  = bIndex;
-    }
-
-    MMCSemaInit();
-
-    nError = InitMMCCard();
-    if (nError == MMC_OK)
-    {
-        sDrive[MMC_DRIVE_C].wFlags = MMC_READY;
-        //GetCID();
-    }
-
-    return(nError);
-} /* MMCInit */
-
-/************************************************************/
-/*  MMCMountAllDevices                                      */
-/************************************************************/
-int MMCMountAllDevices(int nMMCMode, BYTE *pSectorBuffer)
-{
-    int    nError = MMC_ERROR;
-    DRIVE *pDrive;
-
-    nMMCMode = nMMCMode;
-
-    pDrive = NULL;
-
-    MMCLock();
-
-    pDrive = &sDrive[MMC_DRIVE_C];
-    if (pDrive->wFlags & MMC_READY)
-    {
-        nError = GetCSD(pDrive);
-    }
-
-    MMCFree();
-
-    if (nError == MMC_OK)
-    {
-        nError = MMCReadSectors(MMC_DRIVE_C, pSectorBuffer, 0, 1);
-    }
-
-    return(nError);
-} /* MMCMountDevice */
-
-/************************************************************/
-/*  MMCGetSectorSize                                        */
-/************************************************************/
-int MMCGetSectorSize(BYTE bDevice)
-{
-    int    nSectorSize;
-    DRIVE *pDrive;
-
-    nSectorSize = 0;
-
-    MMCLock();
-
-    if (bDevice >= MMC_MAX_SUPPORTED_DEVICE)
-    {
-        nSectorSize = 0;
-    }
-    else
-    {
-        pDrive = &sDrive[bDevice];
-        nSectorSize = pDrive->wSectorSize;
-    }
-
-    MMCFree();
-
-    return(nSectorSize);
-} /* MMCGetSectorSize */
-
-/************************************************************/
-/*  MMCIsCDROMDevice                                        */
-/************************************************************/
-int MMCIsCDROMDevice(BYTE bDevice)
-{
-    return(FALSE);
-} /* MMCIsCDROMDevice */
-
-/************************************************************/
-/*  MMCIsZIPDevice                                          */
-/************************************************************/
-int MMCIsZIPDevice(BYTE bDevice)
-{
-    return(FALSE);
-} /* MMCIsZIPDevice */
-
-/************************************************************/
-/*  MMCUnMountDevice                                        */
-/************************************************************/
-int MMCUnMountDevice(BYTE bDevice)
-{
-    return(MMC_OK);
-} /* MMCUnMountDevice */
-
-/************************************************************/
-/*  MMCGetTotalSectors                                      */
-/************************************************************/
-DWORD MMCGetTotalSectors(BYTE bDevice)
-{
-    DWORD  dwTotalSectors;
-    DRIVE *pDrive;
-
-    dwTotalSectors = 0;
-
-    MMCLock();
-
-    if (bDevice >= MMC_MAX_SUPPORTED_DEVICE)
-    {
-        dwTotalSectors = 0;
-    }
-    else
-    {
-        pDrive = &sDrive[bDevice];
-        dwTotalSectors = pDrive->dTotalSectors;
-
-        //dwTotalSectors -= 64;
-    }
-
-    MMCFree();
-
-    return(dwTotalSectors);
-} /* MMCGetTotalSectors */
-
-/************************************************************/
-/*  MMCReadSectors                                          */
-/************************************************************/
-int MMCReadSectors(BYTE bDevice, void *pData, DWORD dwStartSector, WORD wSectorCount)
-{
-    int    nError;
-    WORD   wReadCount;
-    DRIVE *pDrive = 0;
-    BYTE  *pByte;
-
-    nError = MMC_OK;
-
-    MMCLock();
-
-    if (bDevice >= MMC_MAX_SUPPORTED_DEVICE)
-    {
-        nError = MMC_DRIVE_NOT_FOUND;
-    }
-    else
-    {
-        pDrive = &sDrive[bDevice];
-        if ((pDrive->wFlags & MMC_READY) == 0)
-        {
-            nError = MMC_DRIVE_NOT_FOUND;
-        }
-        else
-        {
-            if ((dwStartSector + wSectorCount) > pDrive->dTotalSectors)
-            {
-                nError = MMC_PARAM_ERROR;
-            }
-        }
-    }
-
-    if (nError == MMC_OK)
-    {
-        pByte = (BYTE *)pData;
-
-        if (wSectorCount != 1)
-        {
-            while (wSectorCount > 0)
-            {
-
-                if (wSectorCount < 256)
-                {
-                    wReadCount = wSectorCount;
-                }
-                else
-                {
-                    wReadCount = 256;
-                }
-
-                nError = ReadSectors(pDrive, pByte, dwStartSector, wReadCount);
-                if (nError != MMC_OK)
-                {
-                    break;
-                }
-
-                dwStartSector += wReadCount;
-                wSectorCount -= wReadCount;
-                pByte += (wReadCount * pDrive->wSectorSize);
-            }
-        }
-        else
-        {
-            nError = ReadSectors(pDrive, pByte, dwStartSector, 1);
-        }
-    }
-
-    MMCFree();
-
-    return(nError);
-} /* MMCReadSectors */
-
-#if (MMC_SUPPORT_WRITE == 1)
-/************************************************************/
-/*  MMCWriteSectors                                         */
-/************************************************************/
-int MMCWriteSectors(BYTE   bDevice,      void *pData,
-                    DWORD dwStartSector, WORD  wSectorCount)
-{
-    int    nError;
-    WORD   wWriteCount;
-    DRIVE *pDrive = 0;
-    BYTE  *pByte;
-
-    nError = MMC_OK;
-
-    MMCLock();
-
-    if (bDevice >= MMC_MAX_SUPPORTED_DEVICE)
-    {
-        nError = MMC_DRIVE_NOT_FOUND;
-    }
-    else
-    {
-        pDrive = &sDrive[bDevice];
-
-        if ((dwStartSector + wSectorCount) > pDrive->dTotalSectors)
-        {
-            nError = MMC_PARAM_ERROR;
-        }
-        if ((pDrive->wFlags & MMC_READY) == 0)
-        {
-            nError = MMC_DRIVE_NOT_FOUND;
-        }
-        if (pDrive->wFlags & MMC_READ_ONLY)
-        {
-            nError = MMC_NOT_SUPPORTED;
-        }
-    }
-
-    if (nError == MMC_OK)
-    {
-        pByte = (BYTE *) pData;
-        while (wSectorCount > 0)
-        {
-
-            if (wSectorCount < 256)
-            {
-                wWriteCount = wSectorCount;
-            }
-            else
-            {
-                wWriteCount = 256;
-            }
-
-            nError = WriteSectors(pDrive, pByte, dwStartSector, wWriteCount);
-            if (nError != MMC_OK)
-            {
-                break;
-            }
-
-            dwStartSector += wWriteCount;
-            wSectorCount  -= wWriteCount;
-            pByte         += (wWriteCount * MMC_SECTOR_SIZE);
-        }
-    }
-
-    MMCFree();
-
-    return(nError);
-} /* MMCWriteSectors */
-#endif
-
-
-
-

ipac-base-27JAN2011/source/remcon.c

@@ -1,151 +0,0 @@
-/*! \file
- * remcon.c contains all interface- and low-level routines that
- * perform handling of the infrared bitstream
- * [COPYRIGHT]  Copyright (C) STREAMIT BV
- *  \version 1.0
- *  \date 26 september 2003
- */
-
-
-
-#define LOG_MODULE  LOG_REMCON_MODULE
-
-#include <stdlib.h>
-#include <fs/typedefs.h>
-#include <sys/heap.h>
-
-#include <sys/event.h>
-#include <sys/atom.h>
-#include <sys/types.h>
-#include <dev/irqreg.h>
-
-#include "system.h"
-#include "portio.h"
-#include "remcon.h"
-#include "display.h"
-#include "keyboard.h"
-#include "led.h"
-
-
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-static HANDLE  hRCEvent;
-
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-static void RcInterrupt(void*);
-static void RcClearEvent(HANDLE*);
-
-
-/*!
- * \addtogroup RemoteControl
- */
-
-/*@{*/
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-
-
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief ISR Remote Control Interrupt (ISR called by Nut/OS)
- *
- *  NEC-code consists of 5 parts:
- *
- *  - leader (9 msec high, 4,5 msec low)
- *  - address (8 bits)
- *  - inverted address (8 bits)
- *  - data (8 bits)
- *  - inverted data (8 bits)
- *
- *  The first sequence contains these 5 parts, next
- *  sequences only contain the leader + 1 '0' bit as long
- *  as the user holds down the button
- *  repetition time is 108 msec in that case
- *
- *  Resolution of the 16-bit timer we use here is 4,3 usec
- *
- *  13,5 msecs are 3109 ticks
- *  '0' is 1,25 msecs (260 ticks)
- *  '1' is 2,25 msecs (517 ticks)
- *
- * \param *p not used (might be used to pass parms from the ISR)
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static void RcInterrupt(void *p)
-{
-	// Hier ISR implementeren voor bijv. NEC protocol
-}
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Clear the eventbuffer of this module
- *
- * This routine is called during module initialization.
- *
- * \param *pEvent pointer to the event queue
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-static void RcClearEvent(HANDLE *pEvent)
-{
-    NutEnterCritical();
-
-    *pEvent = 0;
-
-    NutExitCritical();
-}
-
-
-
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-/*!
- * \brief Initialise the Remote Control module
- *
- * - register the ISR in NutOS
- * - initialise the HW-timer that is used for this module (Timer1)
- * - initialise the external interrupt that inputs the infrared data
- * - flush the remote control buffer
- * - flush the eventqueue for this module
- */
-/* ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-void RcInit()
-{
-    int nError = 0;
-
-    EICRB &= ~RC_INT_SENS_MASK;    // clear b0, b1 of EICRB
-
-    // Install Remote Control interrupt
-    nError = NutRegisterIrqHandler(&sig_INTERRUPT4, RcInterrupt, NULL);
-    if (nError == FALSE)
-    {
-/*
- *  ToDo: control External Interrupt following NutOS calls
-#if (NUTOS_VERSION >= 421)
-        NutIrqSetMode(&sig_INTERRUPT4, NUT_IRQMODE_FALLINGEDGE);
-#else
-        EICRB |= RC_INT_FALLING_EDGE;
-#endif
-        EIMSK |= 1<<IRQ_INT4;         // enable interrupt
- */
-        EICRB |= RC_INT_FALLING_EDGE;
-        EIMSK |= 1<<IRQ_INT4;         // enable interrupt
-    }
-
-    // Initialise 16-bit Timer (Timer1)
-    TCCR1B |= (1<<CS11) | (1<<CS10); // clockdivider = 64
-    TIFR   |= 1<<ICF1;
-    //TIMSK = 1<<TICIE1;
-
-    RcClearEvent(&hRCEvent);
-
-
-}
-
-/* ---------- end of module ------------------------------------------------ */
-
-/*@}*/

ipac-base-27JAN2011/source/rtc.c

@@ -1,471 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR
- * [MODULE]     Real Time Clock
- * [TITLE]      High- and low level Routines for INtersil X1205 RTC chip
- * [FILE]       rtc.c
- * [VSN]        1.0
- * [CREATED]    13042007
- * [LASTCHNGD]  131042007
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    contains all interface- and low-level routines to
- *              read/write date/time/status strings from the X1205
- * ======================================================================== */
-
-#define LOG_MODULE  LOG_RTC_MODULE
-
-#include <cfg/os.h>
-#include <dev/twif.h>
-#include <sys/event.h>
-#include <sys/timer.h>
-
-#include <time.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "rtc.h"
-#include "portio.h"
-
-#define I2C_SLA_RTC         0x6F
-#define I2C_SLA_EEPROM      0x57
-#define EEPROM_PAGE_SIZE    64
-
-
-static u_long rtc_status;
-
-/*!
- * \brief Enable or disable write access.
- *
- * \param on Write access is disabled if this parameter is 0, or
- *           enabled otherwise.
- *
- * \return 0 on success or -1 in case of an error.
- */
-static int X12WriteEnable(int on)
-{
-    int rc;
-    u_char buf[3];
-
-    buf[0] = 0;
-    buf[1] = 0x3F;
-    if (on)
-    {
-        buf[2] = 0x02;
-        if ((rc = TwMasterTransact(I2C_SLA_RTC, buf, 3, 0, 0, NUT_WAIT_INFINITE)) == 0)
-        {
-            buf[2] = 0x06;
-            rc = TwMasterTransact(I2C_SLA_RTC, buf, 3, 0, 0, NUT_WAIT_INFINITE);
-        }
-    }
-    else
-    {
-        buf[2] = 0x00;
-        rc = TwMasterTransact(I2C_SLA_RTC, buf, 3, 0, 0, NUT_WAIT_INFINITE);
-    }
-    return(rc);
-}
-
-/*!
- * \brief Wait until non-volatile write cycle finished.
- *
- * \return 0 on success or -1 in case of an error.
- */
-static int X12WaitReady(void)
-{
-    u_char poll;
-    int cnt = 20;
-
-    /* Poll for write cycle finished. */
-    while (--cnt && TwMasterTransact(I2C_SLA_EEPROM, 0, 0, &poll, 1, NUT_WAIT_INFINITE) == -1)
-    {
-        NutSleep(1);
-    }
-    return(cnt ? 0 : -1);
-}
-
-/*!
- * \brief Read RTC registers.
- *
- * \param reg  The first register to read.
- * \param buff Pointer to a buffer that receives the register contents.
- * \param cnt  The number of registers to read.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int X12RtcReadRegs(u_char reg, u_char *buff, size_t cnt)
-{
-    int rc = -1;
-    u_char wbuf[2];
-
-    wbuf[0] = 0;
-    wbuf[1] = reg;
-    if (TwMasterTransact(I2C_SLA_RTC, wbuf, 2, buff, cnt, NUT_WAIT_INFINITE) == cnt)
-    {
-        rc = 0;
-    }
-    return(rc);
-}
-
-/*!
- * \brief Write to RTC registers.
- *
- * \param nv   Must be set to 1 when writing to non-volatile registers.
- *             In this case the routine will poll for write cycle
- *             completion before returning to the caller. Set to zero
- *             if writing to volatile registers.
- * \param buff This buffer must contain all bytes to be transfered to
- *             the RTC chip, including the register address.
- * \param cnt  Number of valid bytes in the buffer.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int X12RtcWrite(int nv, CONST u_char *buff, size_t cnt)
-{
-    int rc;
-
-    if ((rc = X12WriteEnable(1)) == 0)
-    {
-        rc = TwMasterTransact(I2C_SLA_RTC, buff, cnt, 0, 0, NUT_WAIT_INFINITE);
-        if (rc == 0 && nv)
-        {
-            rc = X12WaitReady();
-        }
-        X12WriteEnable(0);
-    }
-    return(rc);
-}
-
-/*!
- * \brief Get date and time from an X12xx hardware clock.
- *
- * \deprecated New applications must use NutRtcGetTime().
- *
- * \param tm Points to a structure that receives the date and time
- *           information.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int X12RtcGetClock(struct _tm *tm)
-{
-    int rc;
-    u_char data[8];
-
-    if ((rc = X12RtcReadRegs(X12RTC_SC, data, 8)) == 0)
-    {
-        tm->tm_sec = BCD2BIN(data[0]);
-        tm->tm_min = BCD2BIN(data[1]);
-        tm->tm_hour = BCD2BIN(data[2] & 0x3F);
-        tm->tm_mday = BCD2BIN(data[3]);
-        tm->tm_mon = BCD2BIN(data[4]) - 1;
-        tm->tm_year = BCD2BIN(data[5]) + 100;
-        if (BCD2BIN(data[7]) > 0x19)
-        {
-            tm->tm_year += 100;
-        }
-        tm->tm_wday = data[6];
-    }
-    return(rc);
-}
-
-/*!
- * \brief Set an X12xx hardware clock.
- *
- * \deprecated New applications must use NutRtcSetTime().
- *
- * New time will be taken over at the beginning of the next second.
- *
- * \param tm Points to a structure which contains the date and time
- *           information.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int X12RtcSetClock(CONST struct _tm *tm)
-{
-    u_char data[10];
-
-    memset(data, 0, sizeof(data));
-    if (tm)
-    {
-        data[1] = X12RTC_SC;
-        data[2] = BIN2BCD(tm->tm_sec);
-        data[3] = BIN2BCD(tm->tm_min);
-        data[4] = BIN2BCD(tm->tm_hour) | 0x80;
-        data[5] = BIN2BCD(tm->tm_mday);
-        data[6] = BIN2BCD(tm->tm_mon + 1);
-        if (tm->tm_year > 99)
-        {
-            data[7] = BIN2BCD(tm->tm_year - 100);
-            data[9] = 0x20;
-        }
-        else
-        {
-            data[7] = BIN2BCD(tm->tm_year);
-            data[9] = 0x19;
-        }
-        data[8] = tm->tm_wday;
-    }
-    return(X12RtcWrite(0, data, 10));
-}
-
-/*!
- * \brief Get alarm date and time of an X12xx hardware clock.
- *
- * \deprecated New applications must use NutRtcGetAlarm().
- *
- * \param idx   Zero based index. Two alarms are supported.
- * \param tm    Points to a structure that receives the date and time
- *              information.
- * \param aflgs Points to an unsigned long that receives the enable flags.
- *
- * \return 0 on success or -1 in case of an error.
- *
- */
-int X12RtcGetAlarm(int idx, struct _tm *tm, int *aflgs)
-{
-    int rc;
-    u_char data[8];
-
-    *aflgs = 0;
-    memset(tm, 0, sizeof(struct _tm));
-    if ((rc = X12RtcReadRegs(idx * 8, data, 8)) == 0)
-    {
-        if (data[0] & X12RTC_SCA_ESC)
-        {
-            *aflgs |= RTC_ALARM_SECOND;
-            tm->tm_sec = BCD2BIN(data[0] & 0x7F);
-        }
-        if (data[1] & X12RTC_MNA_EMN)
-        {
-            *aflgs |= RTC_ALARM_MINUTE;
-            tm->tm_min = BCD2BIN(data[1]);
-        }
-        if (data[2] & X12RTC_HRA_EHR)
-        {
-            *aflgs |= RTC_ALARM_HOUR;
-            tm->tm_hour = BCD2BIN(data[2] & ~0x80);
-        }
-        if (data[3] & X12RTC_DTA_EDT)
-        {
-            *aflgs |= RTC_ALARM_MDAY;
-            tm->tm_mday = BCD2BIN(data[3]);
-        }
-        if (data[4] & X12RTC_MOA_EMO)
-        {
-            *aflgs |= RTC_ALARM_MONTH;
-            tm->tm_mon = BCD2BIN(data[4]) - 1;
-        }
-        if (data[6] & X12RTC_DWA_EDW)
-        {
-            *aflgs |= RTC_ALARM_WDAY;
-            tm->tm_wday = BCD2BIN(data[6]);
-        }
-    }
-    return(rc);
-}
-
-/*!
- * \brief Set alarm of an X12xx hardware clock.
- *
- * \deprecated New applications must use NutRtcSetAlarm().
- *
- * \param idx   Zero based index. Two alarms are supported.
- * \param tm    Points to a structure which contains the date and time
- *              information. May be NULL to clear the alarm.
- * \param aflgs Each bit enables a specific comparision.
- *              - Bit 0: Seconds
- *              - Bit 1: Minutes
- *              - Bit 2: Hours
- *              - Bit 3: Day of month
- *              - Bit 4: Month
- *              - Bit 7: Day of week (Sunday is zero)
- *
- * \return 0 on success or -1 in case of an error.
- */
-int X12RtcSetAlarm(int idx, CONST struct _tm *tm, int aflgs)
-{
-    u_char data[10];
-
-    memset(data, 0, sizeof(data));
-    data[1] = idx * 8;
-    if (tm)
-    {
-        if (aflgs & RTC_ALARM_SECOND)
-        {
-            data[2] = BIN2BCD(tm->tm_sec) | X12RTC_SCA_ESC;
-        }
-        if (aflgs & RTC_ALARM_MINUTE)
-        {
-            data[3] = BIN2BCD(tm->tm_min) | X12RTC_MNA_EMN;
-        }
-        if (aflgs & RTC_ALARM_HOUR)
-        {
-            data[4] = BIN2BCD(tm->tm_hour) | X12RTC_HRA_EHR;
-        }
-        if (aflgs & RTC_ALARM_MDAY)
-        {
-            data[5] = BIN2BCD(tm->tm_mday) | X12RTC_DTA_EDT;
-        }
-        if (aflgs & RTC_ALARM_MONTH)
-        {
-            data[6] = BIN2BCD(tm->tm_mon + 1) | X12RTC_MOA_EMO;
-        }
-        if (aflgs & RTC_ALARM_WDAY)
-        {
-            data[8] = BIN2BCD(tm->tm_wday) | X12RTC_DWA_EDW;
-        }
-    }
-    return(X12RtcWrite(1, data, 10));
-}
-
-/*!
- * \brief Query RTC status flags.
- *
- * \deprecated New applications must use NutRtcGetStatus().
- *
- * \param sflgs Points to an unsigned long that receives the status flags.
- *              - Bit 0: Power fail.
- *              - Bit 5: Alarm 0 occured.
- *              - Bit 6: Alarm 1 occured.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int X12RtcGetStatus(u_long *sflgs)
-{
-    int rc;
-    u_char data;
-
-    if ((rc = X12RtcReadRegs(X12RTC_SR, &data, 1)) == 0)
-    {
-        rtc_status |= data;
-        *sflgs = rtc_status;
-    }
-    return(rtc_status);
-}
-
-/*!
- * \brief Clear RTC status flags.
- *
- * \deprecated New applications must use NutRtcClearStatus().
- *
- * \param sflgs Status flags to clear.
- *
- * \return Always 0.
- */
-int X12RtcClearStatus(u_long sflgs)
-{
-    rtc_status &= ~sflgs;
-
-    return(0);
-}
-
-/*!
- * \brief Read contents from non-volatile EEPROM.
- *
- * \param addr  Start location.
- * \param buff  Points to a buffer that receives the contents.
- * \param len   Number of bytes to read.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int X12EepromRead(u_int addr, void *buff, size_t len)
-{
-    int rc = -1;
-    u_char wbuf[2];
-
-    wbuf[0] = (u_char)(addr >> 8);
-    wbuf[1] = (u_char)addr;
-    if (TwMasterTransact(I2C_SLA_EEPROM, wbuf, 2, buff, len, NUT_WAIT_INFINITE) == len)
-    {
-        rc = 0;
-    }
-    return(rc);
-}
-
-/*!
- * \brief Store buffer contents in non-volatile EEPROM.
- *
- * The EEPROM of the X122x has a capacity of 512 bytes, while the X1286 is
- * able to store 32 kBytes.
- *
- * \param addr  Storage start location.
- * \param buff  Points to a buffer that contains the bytes to store.
- * \param len   Number of valid bytes in the buffer.
- *
- * \return 0 on success or -1 in case of an error.
- */
-int X12EepromWrite(u_int addr, CONST void *buff, size_t len)
-{
-    int rc = 0;
-    u_char *wbuf;
-    size_t wlen;
-    CONST u_char *wp = buff;
-
-    /*
-     * Loop for each page to be written to.
-     */
-    while (len)
-    {
-        /* Do not cross page boundaries. */
-        wlen = EEPROM_PAGE_SIZE - (addr & (EEPROM_PAGE_SIZE - 1));
-        if (wlen > len)
-        {
-            wlen = len;
-        }
-
-        /* Allocate and set a TWI write buffer. */
-        if ((wbuf = malloc(wlen + 2)) == 0)
-        {
-            rc = -1;
-            break;
-        }
-        wbuf[0] = (u_char)(addr >> 8);
-        wbuf[1] = (u_char)addr;
-        memcpy(wbuf + 2, (void *)wp, wlen);
-
-        /* Enable EEPROM write access and send the write buffer. */
-        if ((rc = X12WriteEnable(1)) == 0)
-        {
-            rc = TwMasterTransact(I2C_SLA_EEPROM, wbuf, wlen + 2, 0, 0, NUT_WAIT_INFINITE);
-        }
-
-        /* Release the buffer and check the result. */
-        free(wbuf);
-        if (rc)
-        {
-            break;
-        }
-        len -= wlen;
-        addr += wlen;
-        wp += wlen;
-
-        /* Poll for write cycle finished. */
-        if ((rc = X12WaitReady()) != 0)
-        {
-            break;
-        }
-    }
-    X12WriteEnable(0);
-
-    return(rc);
-}
-
-/*!
- * \brief Initialize the interface to an Intersil X12xx hardware clock.
- *
- * \deprecated New applications must use NutRegisterRtc().
- *
- * \return 0 on success or -1 in case of an error.
- *
- */
-int X12Init(void)
-{
-    int rc;
-    u_long tmp;
-
-    if ((rc = TwInit(0)) == 0)
-    {
-        rc = X12RtcGetStatus(&tmp);
-    }
-    return (rc);
-}
-
-

ipac-base-27JAN2011/source/session.c

@@ -1,550 +0,0 @@
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : Session
- *  File name  $Workfile: Session.c  $
- *       Last Save $Date: 2003/08/16  $
- *             $Revision: 0.1  $
- *  Creation Date       : 2003/08/16
- *
- *  Description         : Handles the connection to the Internet via
- *                        ethernet or modem/ppp
- *
- */
-
-#define LOG_MODULE  LOG_SESSION_MODULE
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <stdio.h>
-#include <string.h>
-
-#include <io.h>
-#include <fcntl.h>
-
-#include <dev/nicrtl.h>
-#include <dev/uartavr.h>
-#include <dev/ppp.h>
-
-#include <sys/heap.h>
-#include <sys/thread.h>
-#include <sys/timer.h>
-#include <sys/confnet.h>
-
-#include <netdb.h>
-#include <net/route.h>
-
-#include <arpa/inet.h>
-
-#include <pro/httpd.h>
-#include <pro/dhcp.h>
-
-#ifdef NUTDEBUG
-    #include <sys/osdebug.h>
-    #include <net/netdebug.h>
-#endif
-
-#include <sys/confos.h>
-
-//#pragma text:appcode
-
-#include "system.h"
-#include "session.h"
-#include "log.h"
-//#include "settings.h"
-#include "display.h"
-#include "version.h"
-
-/*!
- * \addtogroup Session
- */
-
-/*@{*/
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-
-/*!\brief Ethernet chip definitions */
-#define ETH0_BASE   0xC300
-#define ETH0_IRQ    5
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-/*!\brief State of this module */
-typedef enum T_SESSION_STATE
-{
-    STATE_IDLE = 0,                 /* We are idle */
-    STATE_STARTING,                 /* We're setting up the session */
-    STATE_OPEN,                     /* We have a session */
-    STATE_STOPPING                  /* We're stopping */
-} TStreamerState;
-
-/*--------------------------------------------------------------------------*/
-/*  Local variables                                                         */
-/*--------------------------------------------------------------------------*/
-/*!\brief Uart device */
-static FILE *g_pUart;
-
-/*!\brief Name of the ethernet device */
-static char szEthernetIfName[sizeof(devEth0.dev_name)];
-
-/*!\brief Global error code. */
-static TError           g_tError;
-
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local functions                                                         */
-/*--------------------------------------------------------------------------*/
-static void SetDhcpDnsServers(u_long dwDns1, u_long dwDns2);
-static void SetFixedDnsServers(void);
-static INLINE TError NetConfig(CONST char *szIfName);
-
-
-/*!
- * \brief Set and save DNS server settings
- *
- * If no servers are specified, NutOS is asked
- * for the DNS servers. If NutOS doesn't have any,
- * we retrieve the previously saved servers
- * Finally, the servers that are current, are stored
- * in the settings and NutOS itself
- *
- * \param dwDns1 IP address of first DNS server
- * \param dwDns2 IP address of second DNS server
- *
- * \return -
- */
-static void SetDhcpDnsServers(u_long dwDns1, u_long dwDns2)
-{
-    // //char szDns[sizeof(SETTINGS_POINTER->Isp.szDns1)];
-
-    // /*
-     // * If not specified get current DNS' from NutOs
-     // */
-    // if ((dwDns1 == 0) && (dwDns2 == 0))
-    // {
-        // NutGetDnsServers(&dwDns1, &dwDns2);
-    // }
-
-    // /*
-     // * If still no DNS servers, get previously saved config
-     // */
-    // if ((dwDns1 == 0) && (dwDns2 == 0))
-    // {
-        // //SettingsGet(szDns, &SETTINGS_POINTER->Isp.szDns1, sizeof(szDns));
-        // if ((dwDns1 = inet_addr(szDns)) == (u_long)-1)
-        // {
-            // dwDns1 = 0;
-        // }
-        // //SettingsGet(szDns, &SETTINGS_POINTER->Isp.szDns2, sizeof(szDns));
-        // if ((dwDns2 = inet_addr(szDns)) == (u_long)-1)
-        // {
-            // dwDns2 = 0;
-        // }
-    // }
-
-    // /*
-     // * Save DNS servers and let NutOs use them
-     // */
-    // if ((dwDns1 != 0) || (dwDns2 != 0))
-    // {
-        // strcpy(szDns, inet_ntoa(dwDns1));
-        // //SettingsSet(szDns, &SETTINGS_POINTER->Isp.szDns1, sizeof(szDns));
-        // strcpy(szDns, inet_ntoa(dwDns2));
-        // //SettingsSet(szDns, &SETTINGS_POINTER->Isp.szDns2, sizeof(szDns));
-
-        // NutDnsConfig2(0, 0, dwDns1, dwDns2);
-    // }
-}
-
-static void SetFixedDnsServers(void)
-{
-    // u_long dwDns1, dwDns2;
-    // char szDns[sizeof(SETTINGS_POINTER->Isp.szDns1)];
-
-    // //SettingsGet(szDns, &SETTINGS_POINTER->Isp.szDns1, sizeof(szDns));
-    // if ((dwDns1 = inet_addr(szDns)) == (u_long)-1)
-    // {
-        // dwDns1 = 0;
-    // }
-
-    // //SettingsGet(szDns, &SETTINGS_POINTER->Isp.szDns2, sizeof(szDns));
-    // if ((dwDns2 = inet_addr(szDns)) == (u_long)-1)
-    // {
-        // dwDns2 = 0;
-    // }
-
-    // NutDnsConfig2(0, 0, dwDns1, dwDns2);
-}
-
-
-static void TryGetDhcp(u_long timeout)
-{
-    /*
-     * Make sure DHCP is started by setting the
-     * *CONFIGURED* IP address to zero.
-     * AND erase the previous IP address, just in case
-     * our MAC address changed.
-     */
-    confnet.cdn_cip_addr = 0;
-    confnet.cdn_ip_addr = 0;
-    confnet.cdn_ip_mask = 0;
-
-#ifdef NUTDEBUG
-    NutTraceTcp(stdout, 1);
-    NutTraceHeap(stdout, 0); // doesn't function !!
-    NutTraceOs(stdout, 0); // doesn't function !!
-#endif
-
-    /*
-     * Start DHCP, and wait for the answer (or timeout)
-     */
-    LogMsg_P(LOG_DEBUG, PSTR("DHCP client started"));
-    if (NutDhcpIfConfig(szEthernetIfName, confnet.cdn_mac, timeout))
-    {
-        LogMsg_P(LOG_DEBUG, PSTR("No DHCP address retrieved"));
-    }
-    else
-    {
-        LogMsg_P(LOG_INFO, PSTR("Ethernet interface %s ready"), inet_ntoa(confnet.cdn_ip_addr));
-
-#ifdef NUTDEBUG
-        NutTraceTcp(stdout, 0);
-        NutTraceHeap(stdout, 0);
-        NutTraceOs(stdout, 0);
-#endif
-    }
-}
-
-/*!
- * \brief Configures the ethernet interface
- *
- * Send out a DHCP request.
- * An error is returned if no response from a DHCP server
- * was received
- *
- * \param szIfName Name of the device.
- *
- * \return OK if success, TError otherwise
- */
-static INLINE TError NetConfig(CONST char *szIfName)
-{
-    // u_long ulMac;
-    // u_long ulSerialNumber;
-    // u_long ulIpAddress;
-    // u_char byTempValue;
-    // char szIp[sizeof(SETTINGS_POINTER->Isp.szIp)];
-
-    // LogMsg_P(LOG_DEBUG, PSTR("Configuring ethernet %s"), szIfName);
-
-    // /*
-     // * LAN configuration using EEPROM values or DHCP/ARP method.
-     // * If it fails, use fixed values.
-     // */
-    // if (NutNetLoadConfig(szIfName) != 0)
-    // {
-        // /*
-         // * No previous config, ignore
-         // */
-    // }
-
-    // /*
-     // * Override any previously used MAC address by
-     // * the one from our own setup
-     // *
-     // * The MAC address is 00:xx:xx:0y:yy:yy
-     // * where x = 4 digits from the IEEE assigned adres
-     // *       y = 5 digits from our serial number
-     // */
-    // ulMac = SettingsGetMacIeee();
-    // ulMac = __byte_swap4(ulMac) >> 8;
-    // memcpy(confnet.cdn_mac, &ulMac, sizeof(confnet.cdn_mac)/2);
-
-    // //ulSerialNumber = SettingsGetSerialnumber();
-    // ulSerialNumber = __byte_swap4(ulSerialNumber) >> 8;
-    // memcpy(&confnet.cdn_mac[sizeof(confnet.cdn_mac)/2], &ulSerialNumber, sizeof(confnet.cdn_mac)/2);
-
-    // LogMsg_P(LOG_INFO, PSTR("MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x"),
-             // confnet.cdn_mac[0],
-             // confnet.cdn_mac[1],
-             // confnet.cdn_mac[2],
-             // confnet.cdn_mac[3],
-             // confnet.cdn_mac[4],
-             // confnet.cdn_mac[5]);
-
-    // /*
-     // * Save the new MAC address
-     // */
-    // NutNetSaveConfig();
-
-    // /*
-     // * Bring up the network.
-     // * Use fixed settings if DHCP is disabled.
-     // * If the fixed IP address is invalid use DHCP anyway.
-     // */
-    // //SettingsGet(szIp, &SETTINGS_POINTER->Isp.szIp, sizeof(szIp));
-    // ulIpAddress = inet_addr(szIp);
-    // if (ulIpAddress == -1)
-    // {
-        // ulIpAddress = 0;
-    // }
-
-    // //SettingsGet(&byTempValue, &SETTINGS_POINTER->Isp.bDhcp, sizeof(byTempValue));
-    // if ((byTempValue == 0) &&
-        // (ulIpAddress != 0))
-    // {
-        // /*
-         // * Use fixed settings.
-         // */
-        // LogMsg_P(LOG_INFO, PSTR("Fixed IP address used"));
-        // confnet.cdn_cip_addr = inet_addr(szIp);
-
-        // //SettingsGet(szIp, &SETTINGS_POINTER->Isp.szGateway, sizeof(szIp));
-        // confnet.cdn_gateway = inet_addr(szIp);
-        // if (confnet.cdn_gateway == -1)
-        // {
-            // confnet.cdn_gateway = 0;
-        // }
-        // //SettingsGet(szIp, &SETTINGS_POINTER->Isp.szNetmask, sizeof(szIp));
-        // confnet.cdn_ip_mask = inet_addr(szIp);
-        // if (confnet.cdn_ip_mask == -1)
-        // {
-            // confnet.cdn_ip_mask = 0;
-        // }
-
-        // if (NutNetIfConfig(szIfName, confnet.cdn_mac, confnet.cdn_cip_addr, confnet.cdn_ip_mask) == 0)
-        // {
-            // NUTDEVICE *dev;
-
-            // /*
-             // * Add the default route
-             // */
-            // if ((dev = NutDeviceLookup(szIfName)) != 0 && dev->dev_type == IFTYP_NET)
-            // {
-                // NutIpRouteAdd(0, 0, confnet.cdn_gateway, dev);
-            // }
-
-            // LogMsg_P(LOG_INFO, PSTR("Ethernet interface %s ready"), inet_ntoa(confnet.cdn_ip_addr));
-        // }
-        // else
-        // {
-            // LogMsg_P(LOG_ERR, PSTR("Incorrect static Ip settings"));
-        // }
-        // SetFixedDnsServers();
-    // }
-    // else
-    // {
-        // /*
-         // * Use DHCP.
-         // */
-        // TryGetDhcp(20000L);
-        // SetDhcpDnsServers(0,0);
-    // }
-    return(OK);
-}
-
-/*!
- * \brief Starts the ethernet interface
- *
- * Waits for DHCP to finish configuring the interface
- * If that doesn't happen the interface is configured
- * using the previous settings.
- *
- * \return OK if success, TError otherwise
- */
-static INLINE TError StartNet(void)
-{
-    TError tError = OK;
-    u_char byTempValue = 0;
-
-    /*
-     * Check if we use DHCP
-     */
-    //SettingsGet(&byTempValue, &SETTINGS_POINTER->Isp.bDhcp, sizeof(byTempValue));
-    if (byTempValue != 0)
-    {
-        if (NutDhcpIsConfigured() == 0)
-        {
-            if (NutNetLoadConfig(szEthernetIfName) ||
-                NutNetIfConfig(szEthernetIfName, confnet.cdn_mac, confnet.cdn_ip_addr, confnet.cdn_ip_mask))
-            {
-                LogMsg_P(LOG_ERR, PSTR("No usable network"));
-                tError = SESSION_NODHCP_NOEEPROM;
-            }
-            else
-            {
-                NUTDEVICE *dev;
-
-                /*
-                 * Add the default route
-                 */
-                if ((dev = NutDeviceLookup(szEthernetIfName)) != 0 && dev->dev_type == IFTYP_NET)
-                {
-                    NutIpRouteAdd(0, 0, confnet.cdn_gateway, dev);
-                }
-
-                LogMsg_P(LOG_WARNING, PSTR("No DHCP response, trying previous network settings..."));
-            }
-            /*
-             * Set current DNS servers
-             */
-            SetDhcpDnsServers(0, 0);
-        }
-    }
-
-
-    /*
-     * Stop all debugging
-     */
-#ifdef NUTDEBUG
-    NutTraceTcp(stdout, 0);
-    NutTraceHeap(stdout, 0);
-    NutTraceOs(stdout, 0);
-#endif
-
-    return(tError);
-}
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*!
- * \brief Initialises this module
- *
- * \note With NutOS 3.2.1 it is not possible
- *       to have both a ppp and eth0 device
- *       registered at the same time and still
- *       have DHCP working.
- *       So switching interface is currently
- *       a reason for reboot!
- *
- * \return OK if success, TError otherwise
- */
-TError SessionInit(void)
-{
-    TError tError = OK;
-
-    /*
-     * Initialise globals
-     */
-    g_pUart = 0;
-    g_tError = OK;
-
-    strncpy_P(szEthernetIfName, PSTR("eth0"), sizeof(szEthernetIfName));
-
-    /*
-     * Create a unique hostname from our serial number
-     * Save the hostname in NutOS
-     */
-    //sprintf_P(confos.hostname, PSTR("%.10s%5.5lX"), VersionGetAppProductName(), SettingsGetSerialnumber());
-    NutSaveConfig();
-
-    /*
-     * Try to bring up the selected
-     * interface. Error if none configured
-     */
-    /*
-     * Register Realtek controller
-     */
-    if (NutRegisterDevice(&devEth0, ETH0_BASE, ETH0_IRQ))
-    {
-        LogMsg_P(LOG_EMERG, PSTR("Registering ethernet failed"));
-        tError = SESSION_NODEVICE;
-    }
-    else
-    {
-        /* Let the chip settle down from init */
-        NutSleep(1000);
-    }
-
-    /*
-     * If we have an ethernet interface start it on init
-     */
-    if (tError == OK)
-    {
-        tError = NetConfig(szEthernetIfName);
-    }
-
-    g_tError = tError;
-
-    return(tError);
-}
-
-/*!
- * \brief Opens a session
- *
- * If this succeeds you can start communicating
- * to the Internet
- *
- * \return OK if success, TError otherwise
- */
-TError SessionOpen(void)
-{
-    TError tError = OK;
-
-    g_tError = OK;
-
-    /*
-     * Try to bring up the selected
-     * interface. Error if none configured
-     */
-    tError = StartNet();
-
-    /*
-     * Display our network settings
-     */
-    if (tError == OK)
-    {
-        u_long ulPrimaryDNS;
-        u_long ulSecondaryDNS;
-
-        /*
-         * Display our IP settings.
-         */
-        LogMsg_P(LOG_INFO, PSTR("  Local IP: %s"), inet_ntoa(confnet.cdn_ip_addr));
-        LogMsg_P(LOG_INFO, PSTR("Gateway IP: %s"), inet_ntoa(confnet.cdn_gateway));
-
-        NutGetDnsServers(&ulPrimaryDNS, &ulSecondaryDNS);
-        LogMsg_P(LOG_INFO, PSTR("  Pri. DNS: %s"), inet_ntoa(ulPrimaryDNS));
-        LogMsg_P(LOG_INFO, PSTR("  Sec. DNS: %s"), inet_ntoa(ulSecondaryDNS));
-    }
-
-    g_tError = tError;
-
-    return(tError);
-}
-
-/*!
- * \brief Return the session status
- *
- * Call to check the status of a session.
- *
- * \return see above
- */
-TError SessionStatus(void)
-{
-    return(g_tError);
-}
-
-/*!
- * \brief Stop the session
- *
- * \return OK if success, TError otherwise
- */
-TError SessionClose(void)
-{
-    g_tError = USER_ABORT;
-
-    return(OK);
-}
-
-/*@}*/

ipac-base-27JAN2011/source/spidrv.c

@@ -1,228 +0,0 @@
-/* ========================================================================
- * [PROJECT]    SIR100
- * [MODULE]     SPI
- * [TITLE]      SPI source file
- * [FILE]       spi.c
- * [VSN]        1.0
- * [CREATED]    06102006
- * [LASTCHNGD]  06102006
- * [COPYRIGHT]  Copyright (C) STREAMIT BV 2010
- * [PURPOSE]    contains all interface- and low-level routines to
- *              control audiofunctions of the VS1003//AT45DBXX/MMC-SD(HC)card
- * ======================================================================== */
-
-#define LOG_MODULE  LOG_SPIDRV_MODULE
-
-/*-------------------------------------------------------------------------*/
-/* includes                                                                */
-/*-------------------------------------------------------------------------*/
-#include <stdio.h>
-
-#include "system.h"
-#include "spidrv.h"
-#include "portio.h"
-#include "log.h"
-
-#include "vs10xx.h"
-
-#include <sys/timer.h>
-
-/*-------------------------------------------------------------------------*/
-/* local defines                                                           */
-/*-------------------------------------------------------------------------*/
-/*-------------------------------------------------------------------------*/
-/* typedefs & structs                                                      */
-/*-------------------------------------------------------------------------*/
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-static u_char g_Speedmode;
-
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-
-/*!
- * \addtogroup Drivers
- */
-
-/*@{*/
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-/*!
- * \brief enable SPI-logic for given device
- *
- * SPI bits:
- * SPSR:  SPI2X         double speed as set in SPR0, SPR1
- * SPCR:  SPIE:         SPI interrupt enable
- *        SPE:          SPI enable
- *        SPR1, SPR0:   clockrate
- *        MSTR:         set to master
- *
- * SPI2X SPR1 SPR0 for a ATMEGA @  14.7456 MHz
- *
- * 1     0    0:  fosc/2  = 136 ns  -> 7.37 MHz
- * 0     0    0:  fosc/4  = 271 ns  -> 3.6864 MHz
- * 1     0    1:  fosc/8  = 542 ns  -> 1.8432 MHz
- * 0     0    1:  fosc/16 = 1085 ns -> 0.9216 MHz
- *
- */
-
-void SPIselect(TSPIDevice Device)
-{
-
-    // set SPI-speed for selected device
-    if (Device==SPI_DEV_VS10XX)
-    {
-        if (g_Speedmode==SPEED_SLOW)
-        {
-            // set speed to Fosc/8
-            outb(SPSR, BV(SPI2X));
-            outb(SPCR, BV(MSTR) | BV(SPE) | BV(SPR0));
-        }
-        else if (g_Speedmode==SPEED_FAST)
-        {
-            // set speed to Fosc/4
-            outb(SPSR, 0);
-            outb(SPCR, BV(MSTR) | BV(SPE));
-        }
-        else if (g_Speedmode==SPEED_ULTRA_FAST)
-        {
-            // set speed to Fosc/2
-            outb(SPSR, BV(SPI2X));
-            outb(SPCR, BV(MSTR) | BV(SPE));
-        }
-        else
-        {
-            LogMsg_P(LOG_ERR,PSTR("invalid Speed"));
-        }
-    }
-    else if (Device==SPI_DEV_FLASH)
-    {
-        // set speed for flash to Fosc/2
-        outb(SPSR, BV(SPI2X));
-        outb(SPCR, BV(MSTR) | BV(SPE));
-    }
-    else
-    {
-        // set speed for flash to Fosc/2
-//        outb(SPSR, BV(SPI2X));
-//        outb(SPCR, BV(MSTR) | BV(SPE));
-
-        // set speed for card to Fosc/4
-        outb(SPSR, 0);
-        outb(SPCR, BV(MSTR) | BV(SPE));
-
-        // set speed for card to Fosc/8
-//        outb(SPSR, BV(SPI2X));
-//        outb(SPCR, BV(MSTR) | BV(SPE) | BV(SPR0));
-
-        // set speed for card to Fosc/16
-//        outb(SPSR, 0);
-//        outb(SPCR, BV(MSTR) | BV(SPE) | BV(SPR0));
-    }
-
-    // enable selected device
-    switch (Device)
-    {
-        case SPI_DEV_VS10XX:
-            {
-                sbi(FLASH_OUT_WRITE, FLASH_ENABLE);    // disable serial Flash
-                sbi(MMCVS_OUT_WRITE, MMC_ENABLE);      // disable MMC/SDHC
-                sbi(MMCVS_OUT_WRITE, VS_ENABLE);       // enable VS10XX
-                break;
-            }
-        case SPI_DEV_FLASH:
-            {
-                sbi(MMCVS_OUT_WRITE, MMC_ENABLE);      // disable MMC/SDHC
-                cbi(MMCVS_OUT_WRITE, VS_ENABLE);       // disable VS10XX
-                cbi(FLASH_OUT_WRITE, FLASH_ENABLE);    // enable serial Flash
-                break;
-            }
-        case SPI_DEV_MMC:
-            {
-                sbi(FLASH_OUT_WRITE, FLASH_ENABLE);    // disable serial Flash
-                cbi(MMCVS_OUT_WRITE, VS_ENABLE);       // disable VS10XX
-                cbi(MMCVS_OUT_WRITE, MMC_ENABLE);      // enable MMC/SDHC
-                break;
-            }
-        default: break;
-    }
-}
-
-/*!
- * \brief disable SPI-logic for ALL devices
- *
- */
-void SPIdeselect()
-{
-    sbi(FLASH_OUT_WRITE, FLASH_ENABLE);    // disable serial Flash
-    cbi(MMCVS_OUT_WRITE, VS_ENABLE);       // disable VS10XX
-    sbi(MMCVS_OUT_WRITE, MMC_ENABLE);      // disable MMC/SDHC
-}
-
-/*!
- * \brief not all devices can operate always on maximum speed. This routine determines the several speed modes.
- *
- */
-void SPImode(u_char data)
-{
-    g_Speedmode = data;
-}
-
-u_char SPIgetmode(void)
-{
-    return(g_Speedmode);
-}
-/*!
- * \brief send a byte using SPI, ignore result
- *
- */
-void SPIputByte(u_char data)
-{
-    SPDR = data;
-    while (!(SPSR & (1<<SPIF)));     // wait for completion
-}
-
-/*!
- * \brief read byte using SPI, don't use any input
- *
- */
-u_char SPIgetByte()
-{
-    SPDR = 0xFF;                     // dummy
-    while (!(SPSR & (1<<SPIF)));     // wait for completion
-    return(SPDR);                    // return with byte shifted in from receiver
-}
-
-/*!
- * \brief send byte using SPI, return result
- *
- */
-u_char SPItransferByte(u_char data)
-{
-    SPDR = data;
-    while (!(SPSR & (1<<SPIF)));     // wait for completion
-    return(SPDR);                    // return with byte shifted in from receiver
-}
-
-/*!
- * \brief Initialise SPI registers (speed)
- *
- *  Note that the IO-lines (SCK, SI, SO) are already set in 'SysInitIO()'
- *  in the main-module
- *
- */
-void SPIinit()
-{
-    sbi(FLASH_OUT_WRITE, FLASH_ENABLE);    // disable serial Flash
-    cbi(MMCVS_OUT_WRITE, VS_ENABLE);       // disable VS10XX
-    sbi(MMCVS_OUT_WRITE, MMC_ENABLE);      // disable MMC/SDHC
-}
-
-
-/*  ÍÍÍÍ  End Of File  ÍÍÍÍÍÍÍÍ ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ */
-
-

ipac-base-27JAN2011/source/uart0driver.c

@@ -1,151 +0,0 @@
-/*!
- * Copyright (C) 2003 by Streamit All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this
- *    software must display the following acknowledgement:
- *
-  *    This product includes software developed by Streamit
- *    and its contributors.
- *
- * THIS SOFTWARE IS PROVIDED BY STREAMIT AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CALL DIRECT
- * CELLULAR SOLUTIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * For additional information see http://www.streamit.nl/
- */
-
-/*!
- *
- * COPYRIGHT STREAMIT BV 2010
- * Tested except for the DTR code. This will be done when the final hardware is available
- *
- *
- * [Note] this UART0 is used for serial communication with LTP (or a PC in general).
- */
-
-
-#define LOG_MODULE  LOG_UART0DRIVER_MODULE
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <io.h>
-
-#include <dev/uartavr.h>
-//#include <sys/heap.h>
-#include <sys/thread.h>
-#include <sys/timer.h>
-
-//#pragma text:appcode
-
-#include "system.h"
-#include "uart0driver.h"
-
-
-//----------------------------------------------------------
-
-static FILE *stream=NULL;
-
-//----------------------------------------------------------
-
-/*!
- * \brief Handle input.
- */
-// THREAD(Uart0KeyEvents, arg)
-// {
-    // NutThreadSetPriority(254);  // low prio
-    // for (;;)
-    // {
-        // if (stream==NULL)
-        // {
-            // NutSleep(2000);           //Mhe
-            // continue;
-        // }
-
-       // CommandHandler(stream);
-    // }
-// }
-
-//----------------------------------------------------------
-
-/*!
- * \brief return stream that is connected to terminal program (serial or TCP/IP)
- */
-FILE *Uart0DriverGetStream(void)
-{
-    return(stream);
-}
-
-/*!
- * \brief Uart0 process initialisation. Uses stdout in combination with Uart0.
- */
-void Uart0DriverInit(void)
-{
-    stream = NULL;
-
-    // register Uart0
-    NutRegisterDevice(&devUart0, 0, 0);
-}
-
-/*!
- * \brief Creates a thread to handle incoming data from User.
- */
-void Uart0DriverStart(void)
-{
-    u_long baud = 115200;
-    char DeviceNameBuffer[6];
-    char FileModeBuffer[3];
-
-    strcpy_P(DeviceNameBuffer, PSTR("uart0"));
-    strcpy_P(FileModeBuffer, PSTR("w"));
-
-    /* Open the stream, connect to stdout */
-    if ((stream=freopen(DeviceNameBuffer, FileModeBuffer, stdout)) != NULL)
-    {
-        _ioctl(_fileno(stream), UART_SETSPEED, &baud);
-    }
-
-    // if (stream != NULL)
-    // {
-        // if (GetThreadByName(DeviceNameBuffer) == NULL)
-        // {
-            // NutThreadCreate(DeviceNameBuffer, Uart0KeyEvents, 0, 512);
-        // }
-    // }
-}
-
-void Uart0DriverSetCookedMode(u_long CookedMode)
-{
-    _ioctl(_fileno(stream), UART_SETCOOKEDMODE, &CookedMode);
-}
-
-/*!
- * \brief Close the stream.
- */
-void Uart0DriverStop(void)
-{
-    if (stream)
-    {
-        // needed? (void)_close(_fileno(stream));
-        (void)fclose(stream);
-        stream = NULL;
-    }
-}

ipac-base-27JAN2011/source/util.c

@@ -1,267 +0,0 @@
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : Util
- *  File name  $Workfile: Util.c  $
- *       Last Save $Date: 2006/05/11 9:53:22  $
- *             $Revision: 0.1  $
- *  Creation Date       : 2006/05/11 9:53:22
- *
- *  Description         : Utility functions for the SIR project
- *
- */
-
-#define LOG_MODULE  LOG_UTIL_MODULE
-
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <stdio.h>
-#include <string.h>
-
-#include <sys/heap.h>
-
-//#pragma text:appcode
-
-#include "system.h"
-#include "log.h"
-
-#include "util.h"
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-#ifdef DEBUG
-//#define UTIL_DEBUG
-#endif /* #ifdef DEBUG */
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local variables                                                         */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local functions                                                         */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*!
- * \brief Allocate memory.
- *
- * \param   unSize [in] Amount of memory to allocate.
- *
- * \return  pointer to the allocated memory.
- *          NULL if there is no memory left or you requested 0 size.
- */
-void *MyMalloc(unsigned int unSize)
-{
-    void *pResult = NULL;
-
-    if ((unSize != 0) &&
-        ((pResult = NutHeapAlloc(unSize)) == NULL))
-    {
-        LogMsg_P(LOG_ERR, PSTR("No memory [%u]"), unSize);
-    }
-    return (pResult);
-}
-
-/*!
- * \brief Create a copy of a string.
- *
- * Allocates sufficient memory from heap for a copy of the string
- * and does the copy.
- *
- * \param   str [in] Pointer to the string to copy.
- *
- * \return  A pointer to the new string.
- *          NULL if allocating memory failed.
- */
-char *strdup(CONST char *str)
-{
-    char *copy = NULL;
-
-    if (str != NULL)
-    {
-        size_t siz = strlen(str) + 1;
-
-        if ((copy = MyMalloc(siz)) != NULL)
-        {
-            memcpy(copy, str, siz);
-        }
-    }
-    return (copy);
-}
-
-/*!
- * \brief Allocate new memory if needed.
- *
- * Checks if a memory block is large enough to hold additional data.
- * If it is not, the buffer is reallocated so it can hold the additional data.
- *
- * \param   ppcBuf [in,out] Address of a pointer to a memory block.
- * \param   punBufSize [in,out] The currently allocated size, [out] the new blocksize
- * \param   unBufInUse [in] Currently in use.
- * \param   unSizeNeeded [in] Size of the data to add.
- *
- * \return  0 when the buffer is large enough to add the data.
- *          -1 if no new memory could be allocated.
- */
-int BufferMakeRoom(char **ppcBuf, unsigned int *punBufSize, unsigned int unBufInUse, unsigned int unSizeNeeded)
-{
-#ifdef UTIL_DEBUG
-    LogMsg_P(LOG_DEBUG, PSTR("Have %u,Need %u"), (*punBufSize - unBufInUse), unSizeNeeded);
-#endif /* #ifdef UTIL_DEBUG */
-
-    if (unSizeNeeded > (*punBufSize - unBufInUse))
-    {
-        unsigned int unBlockSize = 256;
-        char *pNewBuf = NULL;
-
-        if (unBlockSize < unSizeNeeded)
-        {
-            unBlockSize = unSizeNeeded;
-        }
-
-        pNewBuf = MyMalloc(*punBufSize + unBlockSize);
-        if (pNewBuf == NULL)
-        {
-            return (-1);
-        }
-        else
-        {
-            *punBufSize += unBlockSize;
-
-#ifdef UTIL_DEBUG
-            LogMsg_P(LOG_DEBUG, PSTR("MemBlock is %u now"), *punBufSize);
-#endif /* #ifdef UTIL_DEBUG */
-
-            if (*ppcBuf != NULL)
-            {
-                memcpy(pNewBuf, *ppcBuf, unBufInUse);
-            }
-            MyFree(*ppcBuf);
-            *ppcBuf = pNewBuf;
-        }
-    }
-    return (0);
-}
-
-/*!
- * \brief Add a string to a memory block.
- *
- * \param   ppcBuf [in] Address of a pointer to a memory block.
- * \param   punBufSize [in,out] The currently allocated size, [out] the new blocksize
- * \param   unBufInUse [in,out] Currently in use, [out] in use after adding the string
- * \param   pszString [in] String to add.
- *
- * \return  0 when the string was successfully added.
- *          -1 on errors.
- */
-int BufferAddString(char **ppcBuf, unsigned int *punBufSize, unsigned int *punBufInUse, CONST char *pszString)
-{
-    unsigned int unStringLen = 0;
-
-    if (pszString == NULL)
-    {
-        return (-1);
-    }
-
-    /*
-     * Add the line to the response buffer
-     */
-    unStringLen = strlen(pszString);
-    if (unStringLen > 0)
-    {
-        unStringLen += 1;   /* Correct for \0 */
-        if (BufferMakeRoom(ppcBuf, punBufSize, *punBufInUse, unStringLen) < 0)
-        {
-            return (-1);
-        }
-        else
-        {
-            /* Only count one \0 (so, in the InUse counter, only count the \0 the very first time) */
-            if (*punBufInUse != 0)
-            {
-                *punBufInUse -= 1;
-            }
-            memcpy(&(*ppcBuf)[*punBufInUse], pszString, unStringLen);
-            *punBufInUse += unStringLen;
-        }
-    }
-    return (0);
-}
-
-/*!
- * \brief Find a descriptor for a piece of text.
- *
- * A LookUp Table (LUT) is searched for matching text.
- * The row in which the match was found is returned.
- * If no match was found, the descriptor of the last entry
- * is returned. As a result, the table should always contain
- * at least one entry. And that last one should be the
- * default/empty or error value, depending on your needs.
- *
- * \note    The compare used is not case sensitive.
- * \note    If byLen is 0, only the first part of pcText
- *          needs to match.
- *          E.g. "foo" in the LUT will match "foo",
- *          E.g. "foo" in the LUT will match "foobar"
- *          By passing the length of pcText (not including the
- *          \0 character), will force an exact match.
- *          E.g. "foo" in the LUT will match "foo",
- *          E.g. "foo" in the LUT will not match "foobar",
- *
- * \param   tLookupTable [in] The lookup table.
- * \param   pcText [in] The text to find the value for
- *          this does not need to be 0 terminated.
- * \param   byLen [in] See notes above.
- *
- * \return  The descriptor of the row that matched.
- *          Or the descriptor of the last row if no match.
- */
-void *LutSearch(CONST tLut tLookupTable[],
-                CONST char *pcText,
-                unsigned char byLen)
-{
-    unsigned char byRow = 0;
-
-    for (byRow = 0; byRow < (unsigned char)(-1); byRow++)
-    {
-        unsigned char byTagLen = 0;
-
-        if (tLookupTable[byRow].pszTag == NULL)
-        {
-            break;
-        }
-
-        byTagLen = strlen_P(tLookupTable[byRow].pszTag);
-
-        if ((byLen != 0) && (byTagLen != byLen))
-        {
-            continue;   /* not the same size; keep looking */
-        }
-
-        /* case-insensitive compare */
-        if (strncasecmp_P(pcText, tLookupTable[byRow].pszTag, byTagLen) == 0)
-        {
-            break;
-        }
-    }
-
-#ifdef UTIL_DEBUG
-    LogMsg_P(LOG_DEBUG, PSTR("Match %d"), byRow);
-#endif /* #ifdef UTIL_DEBUG */
-
-    return (tLookupTable[byRow].pDesc);
-}

ipac-base-27JAN2011/source/vs10xx.c

@@ -1,965 +0,0 @@
-/*
- * Copyright (C) 2003 by Pavel Chromy. All rights reserved.
- * Copyright (C) 2001-2003 by egnite Software GmbH. All rights reserved.
- * Copyright (C) 2003-2004 by Streamit. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the copyright holders nor the names of
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
- * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * For additional information see http://www.ethernut.de/
- * -
- *
- * This software has been inspired by all the valuable work done by
- * Jesper Hansen <jesperh@telia.com>. Many thanks for all his help.
- */
-
-/*
- * [COPYRIGHT]  Copyright (C) STREAMIT BV
- *
- *
- */
-#define LOG_MODULE  LOG_VS10XX_MODULE
-
-#include <stdlib.h>
-
-#include <sys/atom.h>
-#include <sys/event.h>
-#include <sys/timer.h>
-#include <sys/heap.h>
-
-#include <dev/irqreg.h>
-
-#include <sys/bankmem.h>
-
-#if (NUTOS_VERSION >= 433)
-    #include <cpu_load.h>
-#endif
-
-
-#include "system.h"
-#include "vs10xx.h"
-#include "platform.h"
-#include "log.h"
-#include "portio.h"    // for debug purposes only
-#include "spidrv.h"    // for debug purposes only
-#include "watchdog.h"
-
-
-/*-------------------------------------------------------------------------*/
-/* global variable definitions                                             */
-/*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-
-#define LOW         0
-#define HIGH        1
-
-#define MONO        0
-#define STEREO      1
-
-#define VsDeselectVs()  SPIdeselect()
-#define VsSelectVs()    SPIselect(SPI_DEV_VS10XX)
-
-
-/*-------------------------------------------------------------------------*/
-/* local variable definitions                                              */
-/*-------------------------------------------------------------------------*/
-static volatile u_char vs_status = VS_STATUS_STOPPED;
-static u_short g_vs_type;
-static u_char VsPlayMode;
-
-
-static void VsLoadProgramCode(void);
-
-/*-------------------------------------------------------------------------*/
-/* local routines (prototyping)                                            */
-/*-------------------------------------------------------------------------*/
-
-#define CODE_SIZE 437
-static prog_char atab[CODE_SIZE] = { /* Register addresses */
-    7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6
-};
-
-prog_int dtab[CODE_SIZE] = { /* Data to write */
-    0x8030, 0x0030, 0x0717, 0xb080, 0x3c17, 0x0006, 0x5017, 0x3f00,
-    0x0024, 0x0006, 0x2016, 0x0012, 0x578f, 0x0000, 0x10ce, 0x2912,
-    0x9900, 0x0000, 0x004d, 0x4080, 0x184c, 0x0006, 0x96d7, 0x2800,
-    0x0d55, 0x0000, 0x0d48, 0x0006, 0x5b50, 0x3009, 0x0042, 0xb080,
-    0x8001, 0x4214, 0xbc40, 0x2818, 0xc740, 0x3613, 0x3c42, 0x3e00,
-    0xb803, 0x0014, 0x1b03, 0x0015, 0x59c2, 0x6fd6, 0x0024, 0x3600,
-    0x9803, 0x2812, 0x57d5, 0x0000, 0x004d, 0x2800, 0x2b40, 0x36f3,
-    0x0024, 0x804c, 0x3e10, 0x3814, 0x3e10, 0x780a, 0x3e13, 0xb80d,
-    0x3e03, 0xf805, 0x0006, 0x5595, 0x3009, 0x1415, 0x001b, 0xffd4,
-    0x0003, 0xffce, 0x0001, 0x000a, 0x2400, 0x16ce, 0xb58a, 0x0024,
-    0xf292, 0x9400, 0x6152, 0x0024, 0xfe02, 0x0024, 0x48b2, 0x0024,
-    0x454a, 0xb601, 0x36f3, 0xd805, 0x36f3, 0x980d, 0x36f0, 0x580a,
-    0x2000, 0x0000, 0x36f0, 0x1814, 0x8061, 0x3613, 0x0024, 0x3e12,
-    0xb817, 0x3e12, 0x3815, 0x3e05, 0xb814, 0x3625, 0x0024, 0x0000,
-    0x800a, 0x3e10, 0xb803, 0x4194, 0xb805, 0x3e11, 0x0024, 0x3e11,
-    0xb807, 0x3e14, 0x7812, 0x3e14, 0xf80d, 0x3e03, 0xf80e, 0x0006,
-    0x0051, 0x2800, 0x24d5, 0x0000, 0x0024, 0xb888, 0x0012, 0x6404,
-    0x0405, 0x0000, 0x0024, 0x2800, 0x2158, 0x4094, 0x0024, 0x2400,
-    0x2102, 0x0000, 0x0024, 0x6498, 0x0803, 0xfe56, 0x0024, 0x48b6,
-    0x0024, 0x4dd6, 0x0024, 0x3a10, 0xc024, 0x32f0, 0xc024, 0xfe56,
-    0x0024, 0x48b6, 0x0024, 0x4dd6, 0x0024, 0x4384, 0x4483, 0x6396,
-    0x888c, 0xf400, 0x40d5, 0x3d00, 0x8024, 0x0006, 0x0091, 0x003f,
-    0xfec3, 0x0006, 0x0053, 0x3101, 0x8024, 0xfe60, 0x0024, 0x48be,
-    0x0024, 0xa634, 0x0c03, 0x4324, 0x0024, 0x4284, 0x2c02, 0x0006,
-    0x0011, 0x2800, 0x24d8, 0x3100, 0x8024, 0x0006, 0x5011, 0x3900,
-    0x8024, 0x0006, 0x0011, 0x3100, 0x984c, 0x4284, 0x904c, 0xf400,
-    0x4088, 0x2800, 0x2845, 0x0000, 0x0024, 0x3cf0, 0x3840, 0x3009,
-    0x3841, 0x3009, 0x3810, 0x2000, 0x0000, 0x0000, 0x2788, 0x3009,
-    0x1bd0, 0x2800, 0x2880, 0x3009, 0x1b81, 0x34f3, 0x1bcc, 0x36f3,
-    0xd80e, 0x36f4, 0xd80d, 0x36f4, 0x5812, 0x36f1, 0x9807, 0x36f1,
-    0x1805, 0x36f0, 0x9803, 0x3405, 0x9014, 0x36f3, 0x0024, 0x36f2,
-    0x1815, 0x2000, 0x0000, 0x36f2, 0x9817, 0x80ad, 0x3e12, 0xb817,
-    0x3e12, 0x3815, 0x3e05, 0xb814, 0x3615, 0x0024, 0x0000, 0x800a,
-    0x3e10, 0x7802, 0x3e10, 0xf804, 0x3e11, 0x7810, 0x3e14, 0x7812,
-    0x2913, 0xc980, 0x3e14, 0xc024, 0x2913, 0xc980, 0x4088, 0x184c,
-    0xf400, 0x4005, 0x0000, 0x18c0, 0x6400, 0x0024, 0x0000, 0x1bc0,
-    0x2800, 0x3095, 0x0030, 0x0310, 0x2800, 0x3f80, 0x3801, 0x4024,
-    0x6400, 0x0024, 0x0000, 0x1a40, 0x2800, 0x3755, 0x0006, 0x55d0,
-    0x0000, 0x7d03, 0xb884, 0x184c, 0x3009, 0x3805, 0x3009, 0x0000,
-    0xff8a, 0x0024, 0x291d, 0x7b00, 0x48b2, 0x0024, 0x0000, 0x1841,
-    0x0006, 0x5010, 0x408a, 0xb844, 0x2900, 0x1300, 0x4088, 0x0024,
-    0x3000, 0x1bcc, 0x6014, 0x0024, 0x0030, 0x0351, 0x2800, 0x36d5,
-    0x0000, 0x0024, 0x0006, 0x0011, 0x3100, 0x0024, 0x0030, 0x0351,
-    0x3800, 0x0024, 0x2800, 0x3f80, 0x3901, 0x4024, 0x6400, 0x0024,
-    0x0030, 0x03d0, 0x2800, 0x3f55, 0x0000, 0x7d03, 0x0006, 0x55d0,
-    0xb884, 0x184c, 0x3009, 0x3805, 0x3009, 0x0000, 0xff8a, 0x0024,
-    0x291d, 0x7b00, 0x48b2, 0x0024, 0x408a, 0x9bcc, 0x0000, 0x1841,
-    0x2800, 0x3b55, 0x0006, 0x5010, 0x689a, 0x0024, 0x3000, 0x0024,
-    0x6014, 0x0024, 0x0030, 0x0392, 0x2800, 0x3e85, 0x0006, 0x0091,
-    0x0006, 0x0011, 0x0000, 0x1852, 0x0006, 0x0053, 0xb880, 0x2400,
-    0x0006, 0x0091, 0x3804, 0x8024, 0x0030, 0x0392, 0x3b00, 0x0024,
-    0x3901, 0x4024, 0x2800, 0x3f80, 0x3a01, 0x4024, 0x3801, 0x4024,
-    0xb880, 0x1bd3, 0x36f4, 0x5812, 0x36f1, 0x5810, 0x36f0, 0xd804,
-    0x36f0, 0x5802, 0x3405, 0x9014, 0x36f3, 0x0024, 0x36f2, 0x1815,
-    0x2000, 0x0000, 0x36f2, 0x9817, 0x0030
-};
-
-/*!
- * \addtogroup VS1003B
- */
-
-/*@{*/
-
-/*-------------------------------------------------------------------------*/
-/*                         start of code                                   */
-/*-------------------------------------------------------------------------*/
-
-
-/*!
- * \brief Write a specified number of bytes to the VS10XX data interface.
- *
- * Decoder interrupts must have been disabled before calling this function.
- */
-static void VsSdiWrite(CONST u_char * data, u_short len)
-{
-    VsSelectVs();
-
-    while (len--)
-    {
-        SPIputByte(*data);
-        data++;
-    }
-
-    VsDeselectVs();
-    return;
-}
-
-/*!
- * \brief Write a specified number of bytes from program space to the
- *        VS10XX data interface.
- *
- * This function is similar to VsSdiWrite() except that the data is
- * located in program space.
- */
-static void VsSdiWrite_P(PGM_P data, u_short len)
-{
-    VsSelectVs();
-
-    while (len--)
-    {
-        SPIputByte(PRG_RDB(data));
-        data++;
-    }
-
-    VsDeselectVs();
-    return;
-}
-
-
-/*!
- * \brief Write to a decoder register.
- *
- * Decoder interrupts must have been disabled before calling this function.
- */
-void VsRegWrite(u_char reg, u_short data)
-{
-    u_char spimode;
-
-    spimode = SPIgetmode();
-    SPImode(SPEED_SLOW);
-
-    VsSelectVs();
-
-    cbi(VS_XCS_PORT, VS_XCS_BIT);
-
-    SPIputByte(VS_OPCODE_WRITE);
-    SPIputByte(reg);
-    SPIputByte((u_char) (data >> 8));
-    SPIputByte((u_char) data);
-
-    sbi(VS_XCS_PORT, VS_XCS_BIT);
-
-    VsDeselectVs();
-
-    SPImode(spimode);
-
-    return;
-}
-
-/*!
- * \brief determine if the stream is valid. If true, returns value; if false returns 0
- *
- */
-u_short VsStreamValid(void)
-{
-    u_short value;
-    u_short result;
-
-    value = VsRegInfo(VS_HDAT1_REG);
-
-    if (value > 0xFFE0)
-    {
-        value = 0xFFE0;
-    }
-
-    switch (value)
-    {
-        case 0x7665: /* WAV */
-        case 0x4154: /* AAC DTS */
-        case 0x4144: /* AAC ADIF */
-        case 0x4D34: /* AAC .mp4 / .m4a */
-        case 0x574D: /* WMA without broadcast patch*/
-            {
-                result= (g_vs_type==VS_VS1003? 0 : value);
-            }
-            break;
-
-        case 0x576d: /* WMA with broadcast patch*/
-        case 0x4D54: /* MIDI */
-        case 0xFFE0: /* MP3 */
-            {
-                result=value;
-            }
-            break;
-
-        default:
-            {
-                result=0;
-            }
-    }
-
-    return(result);
-}
-/*
- * \brief Read from a register.
- *
- * Decoder interrupts must have been disabled before calling this function.
- *
- * \return Register contents.
- */
-static u_short VsRegRead(u_char reg)
-{
-    u_short data;
-    u_char spimode;
-
-    spimode = SPIgetmode();
-    SPImode(SPEED_SLOW);
-
-    VsSelectVs();
-
-    cbi(VS_XCS_PORT, VS_XCS_BIT);
-
-    SPIputByte(VS_OPCODE_READ);
-    SPIputByte(reg);
-
-    data=SPIgetByte()<<8;           // get MSB
-    data |= SPIgetByte();           // get LSB
-
-    sbi(VS_XCS_PORT, VS_XCS_BIT);
-
-    VsDeselectVs();
-    SPImode(spimode);
-
-    return(data);
-}
-
-/*!
- * \brief read data from a specified register from the VS10XX
- *
- */
-u_short VsRegInfo(u_char reg)
-{
-    u_char ief;
-    u_short value;
-
-    ief = VsPlayerInterrupts(0);
-    value = VsRegRead(reg);
-    VsPlayerInterrupts(ief);
-
-    return(value);
-}
-
-
-/*!
- * \brief Enable or disable player interrupts.
- *
- * This routine is typically used by applications when dealing with
- * unprotected buffers.
- *
- * \param enable Disables interrupts when zero. Otherwise interrupts
- *               are enabled.
- *
- * \return Zero if interrupts were disabled before this call.
- */
-u_char VsPlayerInterrupts(u_char enable)
-{
-    u_char rc;
-
-    NutEnterCritical();
-    rc = (inb(EIMSK) & _BV(VS_DREQ_BIT)) != 0;
-    if (enable)
-    {
-        sbi(EIMSK, VS_DREQ_BIT);
-    }
-    else
-    {
-        cbi(EIMSK, VS_DREQ_BIT);
-    }
-    NutExitCritical();
-
-    return(rc);
-}
-
-/*
- * \brief Feed the decoder with data.
- *
- * This function serves two purposes:
- * - It is called by VsPlayerKick() to initially fill the decoder buffer.
- * - It is used as an interrupt handler for the decoder.
- *
- * Note that although this routine is an ISR, it is called from 'VsPlayerKick' as well
- */
-static void VsPlayerFeed(void *arg)
-{
-    u_short j = 32;
-    u_char ief;
-
-    char *bp;
-    size_t consumed;
-    size_t available;
-
-    // leave if not running.
-    if ((vs_status != VS_STATUS_RUNNING) || (bit_is_clear(VS_DREQ_PIN, VS_DREQ_BIT)))
-    {
-        return;
-    }
-
-    /*
-     * We are hanging around here some time and may block other important
-     * interrupts. Disable decoder interrupts and enable global interrupts.
-     */
-    ief = VsPlayerInterrupts(0);
-
-    sei();
-
-    bp = 0;
-    consumed = 0;
-    available = 0;
-
-    /*
-     * Feed the decoder with j bytes or we ran out of data.
-     */
-    VsSelectVs();
-
-    do
-    {
-        if (consumed >= available)
-        {
-            // Commit previously consumed bytes.
-            if (consumed)
-            {
-                NutSegBufReadCommit(consumed);
-                consumed = 0;
-            }
-            // All bytes consumed, request new.
-            bp = NutSegBufReadRequest(&available);
-            if (available == 0)
-            {
-                /* End of stream. */
-                vs_status = VS_STATUS_EOF;
-                break;
-            }
-        }
-        if (available != 0) // We have some data in the buffer, feed it.
-        {
-            SPIputByte(*bp);
-            bp++;
-            consumed++;
-        }
-        /*
-         * appearantly DREQ goes low when less then 32 byte are available
-         * in the internal buffer (2048 bytes)
-         */
-
-        /* Allow 32 bytes to be sent as long as DREQ is set. This includes the one in progress */
-        if (bit_is_set(VS_DREQ_PIN, VS_DREQ_BIT))
-        {
-            j = 32;
-        }
-    } while (--j);          // bug solved: j-- counts one too many....
-
-    VsDeselectVs();
-
-    /* Finally re-enable the producer buffer. */
-    NutSegBufReadLast(consumed);
-    VsPlayerInterrupts(ief);
-}
-
-
-/*!
- * \brief Start playback.
- *
- * This routine will send the first MP3 data bytes to the
- * decoder. The data buffer
- * should have been filled before calling this routine.
- *
- * Decoder interrupts will be enabled.
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsPlayerKick(void)
-{
-    /*
-     * Start feeding the decoder with data.
-     */
-    if (vs_status != VS_STATUS_RUNNING)
-    {
-        VsPlayerInterrupts(0);
-        /*
-         *  for the VS1003 we need an extra reset
-         *  here before we start playing a stream...
-         */
-//        VsPlayerSetMode(VS_SM_RESET);
-//        NutDelay(10);
-//        LogMsg_P(LOG_DEBUG,PSTR("Kick: CLOCKF = [0x%02X]"),VsRegRead(VS_CLOCKF_REG));
-//        LogMsg_P(LOG_DEBUG,PSTR("Kick: CLOCKF = [0x%02X]"),VsRegRead(VS_CLOCKF_REG));
-//        LogMsg_P(LOG_DEBUG,PSTR("Kick: CLOCKF = [0x%02X]"),VsRegRead(VS_CLOCKF_REG));
-//        LogMsg_P(LOG_DEBUG,PSTR("Kick: CLOCKF = [0x%02X]"),VsRegRead(VS_CLOCKF_REG));
-//        LogMsg_P(LOG_DEBUG,PSTR("Kick: CLOCKF = [0x%02X]"),VsRegRead(VS_CLOCKF_REG));
-
-        VsLoadProgramCode();
-        vs_status = VS_STATUS_RUNNING;
-        VsPlayerFeed(NULL);
-        VsPlayerInterrupts(1);
-    }
-    return(0);
-}
-
-/*!
- * \brief Stops the playback.
- *
- * This routine will stops the MP3 playback, VsPlayerKick() may be used
- * to resume the playback.
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsPlayerStop(void)
-{
-    u_char ief;
-
-    ief = VsPlayerInterrupts(0);
-    /* Check whether we need to stop at all to not overwrite other than running status */
-    if (vs_status == VS_STATUS_RUNNING)
-        vs_status = VS_STATUS_STOPPED;
-    VsPlayerInterrupts(ief);
-
-    return(0);
-}
-
-
-/*!
- * \brief Initialize the VS10xx hardware interface.
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsPlayerInit(void)
-{
-
-    /* Disable decoder interrupts. */
-
-    VsPlayerInterrupts(0);
-
-    /* Keep decoder in reset state. */
-    cbi(VS_RESET_PORT, VS_RESET_BIT);
-
-    /* Set VS10XX chip select output inactive for SCI bus (high) */
-    sbi(VS_XCS_PORT, VS_XCS_BIT);
-
-    /* Set SCK output low. */
-    cbi(VS_SCK_PORT, VS_SCK_BIT);
-    sbi(VS_SCK_DDR, VS_SCK_BIT);
-
-
-    /*
-     * Init SPI mode to no interrupts, enabled, MSB first, master mode,
-     * rising clock and fosc/8 clock speed. Send an initial byte to
-     * make sure SPIF is set. Note, that the decoder reset line is still
-     * active.
-     */
-    NutDelay(4);
-
-    SPImode(SPEED_SLOW);
-
-    vs_status = VS_STATUS_STOPPED;
-
-    /* Release decoder reset line. */
-    sbi(VS_RESET_PORT, VS_RESET_BIT);
-
-    /* Wait until DREQ is active
-     * Write 0x9800 to SCI_CLOCKF
-     * do another register write
-     * wait at least 11000 clockcycles
-     */
-    NutDelay(4);
-
-    /* Read the status register to determine the VS type. */
-    g_vs_type = (VsRegRead(VS_STATUS_REG) >> 4) & 7;
-
-    /* Force frequency change (see datasheet). */
-    switch (g_vs_type)
-    {
-        case VS_VS1003:
-            {
-                VsRegWrite(VS_CLOCKF_REG, 0xE000); // 4.5x
-                break;
-            }
-        default:
-            {
-                VsRegWrite(VS_CLOCKF_REG, 0x9800); // 2x
-                break;
-            }
-    }
-
-    NutDelay(50);
-
-    // Datasheet requires 2 write instructions before speeding up SPI interface
-    VsPlayerSetMode(0);
-    VsSetVolume(0,0);
-
-    NutDelay(50);
-
-    // now switch to new speed...
-    switch (g_vs_type)
-    {
-        case VS_VS1003:
-        case VS_VS1053:
-            {
-                SPImode(SPEED_ULTRA_FAST);
-                break;
-            }
-        case VS_VS1011e:
-        default:
-            {
-                SPImode(SPEED_FAST);
-                break;
-            }
-    }
-
-    /* Register the interrupt routine */
-    NutRegisterIrqHandler(&sig_INTERRUPT6, VsPlayerFeed, NULL);
-
-    /* Rising edge will generate interrupts. */
-    NutIrqSetMode(&sig_INTERRUPT6, NUT_IRQMODE_RISINGEDGE);
-
-    /* Clear any spurious interrupt. */
-    outp(BV(VS_DREQ_BIT), EIFR);
-
-    return(0);
-}
-
-/*!
- * \brief Software reset the decoder.
- *
- * This function is typically called after VsPlayerInit() and at the end
- * of each track.
- *
- * \param mode Any of the following flags may be or'ed
- * - VS_SM_DIFF Left channel inverted.
- * - VS_SM_FFWD Fast forward.
- * - VS_SM_RESET Force hardware reset.
- * - VS_SM_PDOWN Switch to power down mode.
- * - VS_SM_BASS Bass/treble enhancer.
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsPlayerReset(u_short mode)
-{
-    /* Disable decoder interrupts and feeding. */
-    VsPlayerInterrupts(0);
-    vs_status = VS_STATUS_STOPPED;
-
-    /* Software reset, set modes of decoder. */
-    VsPlayerSetMode(VS_SM_RESET | mode);
-    NutDelay(10);
-
-    /* Clear any spurious interrupts. */
-    outp(BV(VS_DREQ_BIT), EIFR);
-
-    return(0);
-}
-
-/*!
- * \brief Set mode register of the decoder.
- *
- * \param mode Any of the following flags may be or'ed
- * - VS_SM_DIFF Left channel inverted.
- * - VS_SM_FFWD Fast forward.
- * - VS_SM_RESET Software reset.
- * - VS_SM_PDOWN Switch to power down mode.
- * - VS_SM_BASS Bass/treble enhancer.
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsPlayerSetMode(u_short mode)
-{
-    u_char ief;
-
-    ief = VsPlayerInterrupts(0);
-    /*
-     *  We need to be sure that the way of interfacing
-     *  is not corrupted by setting some new mode
-     *  We need to have SM_SDINEW & SM_SDISHARE set to '1'
-     *  at all times
-     */
-    mode |= (VS_SM_SDISHARE | VS_SM_SDINEW);
-    VsRegWrite(VS_MODE_REG, mode);
-    VsPlayerInterrupts(ief);
-
-    return(0);
-}
-
-/*!
- * \brief Returns status of the player.
- *
- * \return Any of the following value:
- * - VS_STATUS_STOPPED Player is ready to be started by VsPlayerKick().
- * - VS_STATUS_RUNNING Player is running.
- * - VS_STATUS_EOF Player has reached the end of a stream after VsPlayerFlush() has been called.
- * - VS_STATUS_EMPTY Player runs out of data. VsPlayerKick() will restart it.
- */
-u_char VsGetStatus(void)
-{
-    return(vs_status);
-}
-
-
-/*!
- * \brief Initialize decoder memory test and return result.
- *
- * \return Memory test result.
- * - Bit(s) Mask            Meaning
-            VS1011e/ VS1053
-            VS1003
- * - 15     0x8000  0x8000  Test finished
- * - 14:7   Unused
- * - 14:10          Unused
- * - 9:             0x0200  Mux test succeeded
- * - 8:             0x0100  Good MAC RAM
- * - 7:             0x0080  Good I RAM
- * - 6:     0x0040          Mux test succeeded
- * - 6:             0x0040  Good Y RAM
- * - 5:     0x0020          Good I RAM
- * - 5:             0x0020  Good X RAM
- * - 4:     0x0010          Good Y RAM
- * - 4:             0x0010  Good I ROM 1
- * - 3:     0x0008          Good X RAM
- * - 3:             0x0008  Good I ROM 2
- * - 2:     0x0004          Good I ROM
- * - 2:             0x0004  Good Y ROM
- * - 1:     0x0002          Good Y ROM
- * - 1:             0x0002  Good X ROM 1
- * - 0:     0x0001          Good X ROM
- * - 0:             0x0001  Good X ROM 2
- *          0x807F  0x83FF  All ok
- *
- * - return 0 on succes; rc otherwise
- */
-u_short VsMemoryTest(void)
-{
-    u_short rc = -1;
-    u_char ief;
-    static prog_char mtcmd[] = { 0x4D, 0xEA, 0x6D, 0x54, 0x00, 0x00, 0x00, 0x00};
-
-    VsPlayerReset(0);
-    VsPlayerSetMode(VS_SM_TESTS);
-
-    ief = VsPlayerInterrupts(0);
-
-    VsSdiWrite_P(mtcmd, sizeof(mtcmd));
-    NutDelay(40);
-
-    rc = VsRegRead(VS_HDAT0_REG);
-
-    VsPlayerInterrupts(ief);
-
-    if ((VsGetType()==VS_VS1003) && (rc == 0x807F))
-    {
-        rc=0;
-    }
-
-    return(rc);
-}
-
-/*!
- * \brief Set volume.
- *
- * \param left  Left channel volume.
- * \param right Right channel volume.
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsSetVolume(u_char left, u_char right)
-{
-    u_char ief;
-
-    ief = VsPlayerInterrupts(0);
-
-    VsRegWrite(VS_VOL_REG, (((u_short) left) << 8) | (u_short) right);
-
-    VsPlayerInterrupts(ief);
-
-    return(0);
-}
-
-
-/*!
- * \brief Get volume.
- *
- * \return u_short Volume.
- */
-u_short VsGetVolume()
-{
-    u_char ief;
-    u_short vol;
-    ief = VsPlayerInterrupts(0);
-    vol=VsRegRead(VS_VOL_REG);
-    VsPlayerInterrupts(ief);
-    return(vol);
-}
-
-/*!
- * \brief Return the number of the VS10xx chip.
- *
- * \return  The actual type number as defined
- */
-u_short VsGetType(void)
-{
-    return(g_vs_type);
-}
-
-
-/*!
- * \brief Return the number of the VS10xx chip.
- *
- * \return  The actual type number coded in HEX!
- */
-u_short VsGetTypeHex(void)
-{
-    switch (g_vs_type)
-    {
-        case VS_VS1003:  return(0x03);
-        default:         break;         /* Other codes use the actual number. */
-    }
-
-    return(g_vs_type);
-}
-
-/*!
- * \brief Sine wave beep.
- *
- * \param fsin Frequency.
- * \param ms   Duration.
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsBeep(u_char fsin, u_short ms)
-{
-    u_char ief;
-    static prog_char on[] = { 0x53, 0xEF, 0x6E};
-    static prog_char off[] = { 0x45, 0x78, 0x69, 0x74};
-    static prog_char end[] = { 0x00, 0x00, 0x00, 0x00};
-
-    /* Disable decoder interrupts. */
-    ief = VsPlayerInterrupts(0);
-
-    VsPlayerSetMode(VS_SM_TESTS);
-
-    fsin = (fsin* 16) + 56;
-    VsSdiWrite_P(on, sizeof(on));
-    VsSdiWrite(&fsin, 1);
-    VsSdiWrite_P(end, sizeof(end));
-    NutDelay(ms);
-    VsSdiWrite_P(off, sizeof(off));
-    VsSdiWrite_P(end, sizeof(end));
-
-    /* Enable decoder interrupts. */
-    VsPlayerInterrupts(ief);
-
-    return(0);
-}
-
-/*!
- * \brief Sine wave beep start.
- *
- * \param fsin Frequency.
- *
- * \note this routine uses a fixed sample rate (12.000Hz) and
- *       therefor the possible frequencies are limited.
- *       Use 'VsBeepStartRaw' to generate a sinus with
- *       an arbitrary freqeuncy
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsBeepStart(u_char fsin)
-{
-    return(VsBeepStartRaw(56 + (fsin & 7) * 9));
-}
-
-/*!
- * \brief Sine wave beep start in Raw mode.
- *
- * \param Raw: b7..b5 determines samplerate
- *        while b4..b0 determines finepitch
- *
- * \note use the VS1003/VS1011 datasheet to figure out
- *       which value to use for Fs (b7..b5) and
- *       which value to use for S (b4..b0)
- *
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsBeepStartRaw(u_char Raw)
-{
-    u_char ief;
-    static prog_char on[] = { 0x53, 0xEF, 0x6E};
-    static prog_char end[] = { 0x00, 0x00, 0x00, 0x00};
-
-    /* Disable decoder interrupts. */
-    ief = VsPlayerInterrupts(0);
-
-    VsPlayerSetMode(VS_SM_TESTS);
-
-    VsSdiWrite_P(on, sizeof(on));
-    VsSdiWrite(&Raw, 1);
-    VsSdiWrite_P(end, sizeof(end));
-
-    /* Enable decoder interrupts. */
-    VsPlayerInterrupts(ief);
-
-    return(0);
-}
-
-/*!
- * \brief Sine wave beep stop.
- *
- * \return 0 on success, -1 otherwise.
- */
-int VsBeepStop()
-{
-    u_char ief;
-    static prog_char off[] = { 0x45, 0x78, 0x69, 0x74};
-    static prog_char end[] = { 0x00, 0x00, 0x00, 0x00};
-
-    /* Disable decoder interrupts. */
-    ief = VsPlayerInterrupts(0);
-
-    VsSdiWrite_P(off, sizeof(off));
-    VsSdiWrite_P(end, sizeof(end));
-
-    /* Enable decoder interrupts. */
-    VsPlayerInterrupts(ief);
-
-    return(0);
-}
-
-static void VsLoadProgramCode(void)
-{
-    int i;
-
-    for (i=0;i<CODE_SIZE;i++)
-    {
-        VsRegWrite(PRG_RDB(&atab[i]), PRG_RDW(&dtab[i]));
-        // kick watchdog on a regular base
-        if(i%500==0)
-        {
-            WatchDogRestart();
-        }
-    }
-}
-/*@}*/

ipac-base-27JAN2011/source/watchdog.c

@@ -1,169 +0,0 @@
-/*
- *  Copyright STREAMIT BV, 2010.
- *
- *  Project             : SIR
- *  Module              : watchdog
- *  File name  $Workfile: watchdog.c  $
- *       Last Save $Date: 2007/01/16 11:17:24  $
- *             $Revision: 0.1  $
- *  Creation Date       : 2007/01/16 11:17:25
- *
- *  Description         : Watchdog routines for the ATMega128/256
- *                        Inspired by the arch/xxx/dev/watchdog routines in
- *                        NutOS 4.2.1 and higher.
- *
- */
-
-#define LOG_MODULE  LOG_WATCHDOG_MODULE
-/*--------------------------------------------------------------------------*/
-/*  Include files                                                           */
-/*--------------------------------------------------------------------------*/
-#include <stdio.h>
-
-#ifdef __AVR__
-#ifdef __GNUC__
-    #include <avr/wdt.h>
-#endif /* #ifdef __GNUC__ */
-#endif /* #ifdef __AVR__ */
-
-#include "watchdog.h"
-
-/*--------------------------------------------------------------------------*/
-/*  Constant definitions                                                    */
-/*--------------------------------------------------------------------------*/
-/*!
- * \brief Watchdog oscillator frequency.
- */
-#ifndef NUT_WDT_FREQ
-#define NUT_WDT_FREQ    128000UL
-#endif
-
-#ifndef WDTO_15MS
-#define WDTO_15MS   0x00
-#define WDTO_30MS   0x01
-#define WDTO_60MS   0x02
-#define WDTO_120MS  0x03
-#define WDTO_250MS  0x04
-#define WDTO_500MS  0x05
-#define WDTO_1S     0x06
-#define WDTO_2S     0x07
-#define WDTO_4S     0x20
-#define WDTO_8S     0x21
-#endif /* #ifndef WDTO_15MS */
-
-#define WD_CONTROL      WDTCSR
-
-/*--------------------------------------------------------------------------*/
-/*  Type declarations                                                       */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local variables                                                         */
-/*--------------------------------------------------------------------------*/
-/*!\brief Counts nested calls */
-static unsigned char g_byNested;
-
-/*!\brief Watchdog Timeout constant */
-static unsigned char g_byWdtDivider;
-
-/*--------------------------------------------------------------------------*/
-/*  Global variables                                                        */
-/*--------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------*/
-/*  Local functions                                                         */
-/*--------------------------------------------------------------------------*/
-
-#ifndef wdt_enable
-#define wdt_enable(tmo) \
-{ \
-    register u_char s = _BV(WDCE) | _BV(WDE); \
-    register u_char r = tmo | _BV(WDE); \
-    asm("in R0, 0x3F\n"     \
-        "cli\n"             \
-        "wdr\n"             \
-        "sts 0x60, %s\n"    \
-        "sts 0x60, %r\n"    \
-        "out 0x3F, R0\n");  \
-}
-#endif /* #ifndef wdt_enable */
-
-#ifndef wdt_disable
-#define wdt_disable() \
-{ \
-    asm("in R0, $3F\n"      \
-        "cli\n"                 \
-        "wdr\n"                 \
-        "in      r24,0x34\n"    \
-        "andi    r24,0xF7\n"    \
-        "out     0x34,r24\n"    \
-        "lds     r24,0x0060\n"  \
-        "ori     r24,0x18\n"    \
-        "sts     0x0060,r24\n"  \
-        "clr     r2\n"          \
-        "sts     0x0060,r2\n"   \
-        "out 0x3F, R0\n");      \
-}
-#endif /* #ifndef wdt_disable */
-
-#ifndef wdt_reset
-#define wdt_reset() \
-{ \
-    _WDR(); \
-}
-#endif /* #ifndef wdt_reset */
-
-/*--------------------------------------------------------------------------*/
-/*  Global functions                                                        */
-/*--------------------------------------------------------------------------*/
-
-void WatchDogStart(unsigned long ms)
-{
-    const unsigned long unPrescaleFactor = 2048UL;       // PragmaLab: check datasheet Mega2561
-
-    unsigned char byPrescale = 1;
-
-    wdt_reset();
-
-    /*
-     * Calculate the needed prescaling for the timer ticks
-     */
-    while (((unPrescaleFactor << byPrescale) / (NUT_WDT_FREQ / 1000UL)) < ms)
-    {
-        byPrescale++;
-    }
-
-    g_byWdtDivider = byPrescale;
-
-    if (g_byWdtDivider > WDTO_8S)
-    {
-        // restrict timeout since HW only can handle 8 seconds for Mega256
-        g_byWdtDivider &= WDTO_8S;
-    }
-
-    wdt_enable(g_byWdtDivider);
-
-    g_byNested = 1;
-}
-
-void WatchDogRestart(void)
-{
-    wdt_reset();
-}
-
-void WatchDogDisable(void)
-{
-    if (g_byNested != 0)
-    {
-        g_byNested++;
-    }
-    wdt_disable();
-}
-
-void WatchDogEnable(void)
-{
-    if (g_byNested > 1 && --g_byNested == 1)
-    {
-        wdt_enable(g_byWdtDivider);
-    }
-}