Firebee/FireBee_SVN
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial (experimental) version of BaS_gcc SD-card driver for EmuTOS

Browse Source
This commit is contained in:
Markus Fröschle
2013-05-01 08:51:18 +00:00
parent 77a1440290
commit 5b4204a1d8
4 changed files with 465 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
BaS_gcc/Makefile
View File

@@ -72,7 +72,8 @@ CSRCS= \
$(SRCDIR)/wait.c \
$(SRCDIR)/s19reader.c \
$(SRCDIR)/flash.c \
$(SRCDIR)/xhdi_sd.c
$(SRCDIR)/xhdi_sd.c \
$(SRCDIR)/xhdi_interface.c
ASRCS= \
$(SRCDIR)/startcf.S \

46
BaS_gcc/include/xhdi_sd.h
View File

@@ -7,6 +7,48 @@
#ifndef _XHDI_SD_H_
#define _XHDI_SD_H_
/* XHDI function numbers */
#define XHDI_VERSION 0
#define XHDI_INQUIRE_TARGET 1
#define XHDI_RESERVE 2
#define XHDI_LOCK 3
#define XHDI_STOP 4
#define XHDI_EJECT 5
#define XHDI_DRIVEMAP 6
#define XHDI_INQUIRE_DEVICE 7
#define XHDI_INQUIRE_DRIVER 8
#define XHDI_NEW_COOKIE 9
#define XHDI_READ_WRITE 10
#define XHDI_INQUIRE_TARGET2 11
#define XHDI_INQUIRE_DEVICE2 12
#define XHDI_DRIVER_SPECIAL 13
#define XHDI_GET_CAPACITY 14
#define XHDI_MEDIUM_CHANGED 15
#define XHDI_MINT_INFO 16
#define XHDI_DOS_LIMITS 17
#define XHDI_LAST_ACCESS 18
/* XHDI error codes */
#define E_OK 0 /* OK */
#define ERROR -1 /* unspecified error */
#define EDRVNR -2 /* drive not ready */
#define EUNDEV -15 /* invalid device/target number */
#define EINVFN -32 /* invalid function number */
#define EACCDN -36 /* access denied (device currently reserved) */
#define EDRIVE -46 /* BIOS device not served by driver */
/* XHDI device capabilities */
#define XH_TARGET_STOPPABLE (1 << 0)
#define XH_TARGET_REMOVABLE (1 << 1)
#define XH_TARGET_LOCKABLE (1 << 2)
#define XH_TARGET_EJECTABLE (1 << 3)
#define XH_TARGET_LOCKED (1 << 29)
#define XH_TARGET_STOPPED (1 << 30)
#define XH_TARGET_RESERVED (1 << 31)
/*
* FIXME: dangerous TRAP here!
*
@@ -27,11 +69,11 @@
extern uint32_t xhdi_call(int xhdi_fun, ...);
extern uint32_t xhdi_version(void); /* XHDI 0 */
extern uint32_t xhdi_inquire_target(uint32_t major, uint32_t minor, uint32_t block_size, uint32_t flags,
extern uint32_t xhdi_inquire_target(UINT16_T major, UINT16_T minor, uint32_t *block_size, uint32_t *flags,
char *product_name); /* XHDI 1 */
extern uint32_t xhdi_reserve(UINT16_T major, UINT16_T minor, UINT16_T do_reserve, UINT16_T key); /* XHDI 2 */
extern uint32_t xhdi_lock(UINT16_T major, UINT16_T minor, UINT16_T do_lock, UINT16_T key); /* XHDI 3 */
extern uint32_t xhdi_stop(UINT16_T major, UINT16_T minor, UINT16_T do_lock, UINT16_T key); /* XHDI 4 */
extern uint32_t xhdi_stop(UINT16_T major, UINT16_T minor, UINT16_T do_stop, UINT16_T key); /* XHDI 4 */
extern uint32_t xhdi_eject(UINT16_T major, UINT16_T minor, UINT16_T do_eject, UINT16_T key); /* XHDI 5 */
extern uint32_t xhdi_drivemap(void); /* XHDI 6 */
extern uint32_t xhdi_inquire_device(UINT16_T bios_device, UINT16_T *major, UINT16_T *minor,

310
BaS_gcc/sources/xhdi_interface.c Normal file
View File

@@ -0,0 +1,310 @@
/*
* xhdi_sd.c
*
* Created on: 01.05.2013
* Author: mfro
*/
#include <stdint.h>
#include <stdarg.h>
#include "xhdi_sd.h"
#include "bas_printf.h"
uint32_t xhdi_call(int xhdi_fun, ...)
{
va_list arguments;
va_start(arguments, xhdi_fun);
switch (xhdi_fun)
{
case XHDI_VERSION:
return xhdi_version();
break;
case XHDI_INQUIRE_TARGET:
{
uint16_t major;
uint16_t minor;
uint32_t *block_size;
uint32_t *flags;
char *product_name;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
block_size = va_arg(arguments, uint32_t *);
flags = va_arg(arguments, uint32_t *);
product_name = va_arg(arguments, char *);
return xhdi_inquire_target(major, minor,
block_size, flags, product_name);
}
break;
case XHDI_RESERVE:
{
uint16_t major;
uint16_t minor;
uint16_t do_reserve;
uint16_t key;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
do_reserve = va_arg(arguments, unsigned int);
key = va_arg(arguments, unsigned int);
return xhdi_reserve(major, minor, do_reserve, key);
}
break;
case XHDI_LOCK:
{
uint16_t major;
uint16_t minor;
uint16_t do_lock;
uint16_t key;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
do_lock = va_arg(arguments, unsigned int);
key = va_arg(arguments, unsigned int);
return xhdi_lock(major, minor, do_lock, key);
}
break;
case XHDI_STOP:
{
uint16_t major;
uint16_t minor;
uint16_t do_stop;
uint16_t key;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
do_stop = va_arg(arguments, unsigned int);
key = va_arg(arguments, unsigned int);
return xhdi_stop(major, minor, do_stop, key);
}
break;
case XHDI_EJECT:
{
uint16_t major;
uint16_t minor;
uint16_t do_eject;
uint16_t key;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
do_eject = va_arg(arguments, unsigned int);
key = va_arg(arguments, unsigned int);
return xhdi_eject(major, minor, do_eject, key);
}
break;
case XHDI_DRIVEMAP:
return xhdi_drivemap();
break;
case XHDI_INQUIRE_DEVICE:
{
uint16_t bios_device;
uint16_t *major;
uint16_t *minor;
uint32_t *start_sector;
void *bpb;
bios_device = va_arg(arguments, unsigned int);
major = va_arg(arguments, uint16_t *);
minor = va_arg(arguments, uint16_t *);
start_sector = va_arg(arguments, uint32_t *);
bpb = va_arg(arguments, void *);
return xhdi_inquire_device(bios_device, major, minor, start_sector, bpb);
}
break;
case XHDI_INQUIRE_DRIVER:
{
uint16_t bios_device;
char *name;
char *version;
char *company;
uint16_t *ahdi_version;
uint16_t *maxIPL;
bios_device = va_arg(arguments, unsigned int);
name = va_arg(arguments, char *);
version = va_arg(arguments, char *);
company = va_arg(arguments, char *);
ahdi_version = va_arg(arguments, uint16_t *);
maxIPL = va_arg(arguments, uint16_t *);
return xhdi_inquire_driver(bios_device, name, version, company,
ahdi_version, maxIPL);
}
break;
case XHDI_NEW_COOKIE:
{
void *new_cookie;
new_cookie = va_arg(arguments, void *);
return xhdi_new_cookie(new_cookie);
}
break;
case XHDI_READ_WRITE:
{
uint16_t major;
uint16_t minor;
uint16_t rwflag;
uint32_t recno;
uint16_t count;
void *buf;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
rwflag = va_arg(arguments, unsigned int);
recno = va_arg(arguments, uint32_t);
count = va_arg(arguments, unsigned int);
buf = va_arg(arguments, void *);
return xhdi_read_write(major, minor, rwflag, recno, count, buf);
}
break;
case XHDI_INQUIRE_TARGET2:
{
uint16_t major;
uint16_t minor;
uint32_t *block_size;
uint32_t *device_flags;
char *product_name;
uint16_t strlen;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
block_size = va_arg(arguments, uint32_t *);
device_flags = va_arg(arguments, uint32_t *);
product_name = va_arg(arguments, char *);
strlen = va_arg(arguments, unsigned int);
return xhdi_inquire_target2(major, minor, block_size, device_flags,
product_name, strlen);
}
break;
case XHDI_INQUIRE_DEVICE2:
{
uint16_t bios_device;
uint16_t *major;
uint16_t *minor;
uint16_t *start_sector;
void *bpb;
uint32_t *blocks;
char *partid;
bios_device = va_arg(arguments, unsigned int);
major = va_arg(arguments, uint16_t *);
minor = va_arg(arguments, uint16_t *);
start_sector = va_arg(arguments, uint16_t *);
bpb = va_arg(arguments, void *);
blocks = va_arg(arguments, uint32_t *);
partid = va_arg(arguments, char *);
return xhdi_inquire_device2(bios_device, major, minor, start_sector,
bpb, blocks, partid);
}
break;
case XHDI_DRIVER_SPECIAL:
{
uint32_t key1;
uint32_t key2;
uint16_t subopcode;
void *data;
key1 = va_arg(arguments, uint32_t);
key2 = va_arg(arguments, uint32_t);
subopcode = va_arg(arguments, unsigned int);
data = va_arg(arguments, void *);
return xhdi_driver_special(key1, key2, subopcode, data);
}
break;
case XHDI_GET_CAPACITY:
{
uint16_t major;
uint16_t minor;
uint32_t *blocks;
uint32_t *bs;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
blocks = va_arg(arguments, uint32_t *);
bs = va_arg(arguments, uint32_t *);
return xhdi_get_capacity(major, minor, blocks, bs);
}
break;
case XHDI_MEDIUM_CHANGED:
{
uint16_t major;
uint16_t minor;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
return xhdi_medium_changed(major, minor);
}
break;
case XHDI_MINT_INFO:
{
uint16_t opcode;
void *data;
opcode = va_arg(arguments, unsigned int);
data = va_arg(arguments, void *);
return xhdi_mint_info(opcode, data);
}
break;
case XHDI_DOS_LIMITS:
{
uint16_t which;
uint32_t limit;
which = va_arg(arguments, unsigned int);
limit = va_arg(arguments, uint32_t);
return xhdi_dos_limits(which, limit);
}
break;
case XHDI_LAST_ACCESS:
{
uint16_t major;
uint16_t minor;
uint32_t *ms;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
ms = va_arg(arguments, uint32_t *);
return xhdi_last_access(major, minor, ms);
}
break;
default:
;
}
xprintf("unknown XHDI function %d\r\n");
return EINVFN;
}

202
BaS_gcc/sources/xhdi_sd.c
View File

@@ -6,113 +6,117 @@
*/
#include <stdint.h>
#include <stdarg.h>
#include <stddef.h>
#include "xhdi_sd.h"
#include "bas_printf.h"
uint32_t xhdi_call(int xhdi_fun, ...)
#define DRIVER_VERSION 0x130
uint32_t xhdi_version(void)
{
va_list arguments;
va_start(arguments, xhdi_fun);
return DRIVER_VERSION;
}
switch(xhdi_fun)
uint32_t xhdi_inquire_target(uint16_t major, uint16_t minor, uint32_t *block_size, uint32_t *flags,
char *product_name)
{
case 0:
return xhdi_version();
break;
case 1:
if (block_size != NULL)
{
uint16_t major;
uint16_t minor;
uint32_t block_size;
uint32_t flags;
char *product_name;
major = va_arg(arguments, unsigned int);
minor = va_arg(arguments, unsigned int);
block_size = va_arg(arguments, uint32_t);
flags = va_arg(arguments, uint32_t);
product_name = va_arg(arguments, char *);
return xhdi_inquire_target((uint32_t) major, (uint32_t) minor, block_size, flags,
product_name);
*block_size = 512;
}
break;
*flags = XH_TARGET_REMOVABLE; /* indicate that SD card can be removed */
#ifdef test
case 2:
return xhdi_reserve();
break;
case 3:
return xhdi_lock();
break;
case 4:
return xhdi_stop();
break;
case 5:
return xhdi_eject();
break;
case 6:
return xhdi_drivemap();
break;
case 7:
return xhdi_inquire_device();
break;
case 8:
return xhdi_inquire_driver();
break;
case 9:
return xhdi_new_cookie();
break;
case 10:
return xhdi_read_write();
break;
case 11:
return xhdi_inquire_target2();
break;
case 12:
return xhdi_inquire_device2();
break;
case 13:
return xhdi_driver_special();
break;
case 14:
return xhdi_get_capacity();
break;
case 15:
return xhdi_medium_changed();
break;
case 16:
return xhdi_mint_info();
break;
case 17:
return xhdi_dos_limits();
break;
case 18:
return xhdi_last_access();
break;
#endif
default:
;
return E_OK;
}
xprintf("unknown XHDI function %d\r\n");
return -32;
uint32_t xhdi_reserve(UINT16_T major, UINT16_T minor, UINT16_T do_reserve, UINT16_T key)
{
return ERROR; /* device cannot be reserved */
}
uint32_t xhdi_lock(UINT16_T major, UINT16_T minor, UINT16_T do_lock, UINT16_T key)
{
return ERROR; /* device cannot be locked */
}
uint32_t xhdi_stop(UINT16_T major, UINT16_T minor, UINT16_T do_stop, UINT16_T key)
{
return ERROR; /* device cannot be locked */
}
uint32_t xhdi_eject(UINT16_T major, UINT16_T minor, UINT16_T do_eject, UINT16_T key)
{
return ERROR; /* device cannot be ejected */
}
uint32_t xhdi_drivemap(void)
{
uint32_t map = 1;
return map;
}
uint32_t xhdi_inquire_device(UINT16_T bios_device, UINT16_T *major, UINT16_T *minor,
uint32_t *start_sector, /* BPB */ void *bpb)
{
return ERROR;
}
uint32_t xhdi_inquire_driver(UINT16_T bios_device, char *name, char *version,
char *company, UINT16_T *ahdi_version, UINT16_T *maxIPL)
{
return ERROR;
}
uint32_t xhdi_new_cookie(void *newcookie)
{
return ERROR;
}
uint32_t xhdi_read_write(UINT16_T major, UINT16_T minor, UINT16_T rwflag,
uint32_t recno, UINT16_T count, void *buf)
{
return ERROR;
}
uint32_t xhdi_inquire_target2(UINT16_T major, UINT16_T minor, uint32_t *block_size,
uint32_t *device_flags, char *product_name, UINT16_T stringlen)
{
return ERROR;
}
uint32_t xhdi_inquire_device2(UINT16_T bios_device, UINT16_T *major, UINT16_T *minor,
UINT16_T *start_sector, /* BPB */ void *bpb, uint32_t *blocks, char *partid)
{
return ERROR;
}
uint32_t xhdi_driver_special(uint32_t key1, uint32_t key2, UINT16_T subopcode, void *data)
{
return ERROR;
}
uint32_t xhdi_get_capacity(UINT16_T major, UINT16_T minor, uint32_t *blocks, uint32_t *bs)
{
return ERROR;
}
uint32_t xhdi_medium_changed(UINT16_T major, UINT16_T minor)
{
return ERROR;
}
uint32_t xhdi_mint_info(UINT16_T opcode, void *data)
{
return ERROR;
}
uint32_t xhdi_dos_limits(UINT16_T which, uint32_t limit)
{
return ERROR;
}
uint32_t xhdi_last_access(UINT16_T major, UINT16_T minor, uint32_t *ms)
{
return ERROR;
}