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

basically finished, but EmuTOS does not seem to like it yet...

Browse Source
This commit is contained in:
Markus Fröschle
2013-05-05 17:15:24 +00:00
parent 9d1c5c905c
commit 28e1c6255a
1 changed files with 183 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

282
BaS_gcc/sources/xhdi_interface.c
View File

@@ -26,12 +26,14 @@
#include "xhdi_sd.h" #include "xhdi_sd.h"
#include "bas_printf.h" #include "bas_printf.h"
uint32_t xhdi_call(int xhdi_fun, ...)
{
va_list arguments;
va_start(arguments, xhdi_fun);
switch (xhdi_fun) uint32_t xhdi_call(struct XHDICALL_args *stack)
{
uint16_t opcode = stack->opcode;
xprintf("xhdi_call(): opcode %d\r\n", opcode);
switch (opcode)
{ {
case XHDI_VERSION: case XHDI_VERSION:
return xhdi_version(); return xhdi_version();
@@ -39,299 +41,275 @@ uint32_t xhdi_call(int xhdi_fun, ...)
case XHDI_INQUIRE_TARGET: case XHDI_INQUIRE_TARGET:
{ {
struct XHINQTARGET_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint32_t *block_size; uint32_t *blocksize;
uint32_t *flags; uint32_t *deviceflags;
char *product_name; char *productname;
}*args = (struct XHINQTARGET_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_inquire_target(args->major, args->minor, args->blocksize,
minor = va_arg(arguments, unsigned int); args->deviceflags, args->productname);
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; break;
case XHDI_RESERVE: case XHDI_RESERVE:
{ {
struct XHRESERVE_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint16_t do_reserve; uint16_t do_reserve;
uint16_t key; uint16_t key;
}*args = (struct XHRESERVE_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_reserve(args->major, args->minor, args->do_reserve, args->key);
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: case XHDI_LOCK:
{ {
struct XHLOCK_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint16_t do_lock; uint16_t do_lock;
uint16_t key; uint16_t key;
}*args = (struct XHLOCK_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_lock(args->major, args->minor, args->do_lock, args->key);
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: case XHDI_STOP:
{ {
struct XHSTOP_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint16_t do_stop; uint16_t do_stop;
uint16_t key; uint16_t key;
}*args = (struct XHSTOP_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_stop(args->major, args->minor, args->do_stop, args->key);
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: case XHDI_EJECT:
{ {
struct XHEJECT_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint16_t do_eject; uint16_t do_eject;
uint16_t key; uint16_t key;
}*args = (struct XHEJECT_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_eject(args->major, args->minor, args->do_eject, args->key);
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: case XHDI_DRIVEMAP:
{
return xhdi_drivemap(); return xhdi_drivemap();
break; }
case XHDI_INQUIRE_DEVICE: case XHDI_INQUIRE_DEVICE:
{ {
uint16_t bios_device; struct XHINQDEV_args
{
uint16_t opcode;
uint16_t drv;
uint16_t *major; uint16_t *major;
uint16_t *minor; uint16_t *minor;
uint32_t *start_sector; uint32_t *start;
void *bpb; BPB *bpb;
}*args = (struct XHINQDEV_args *) stack;
bios_device = va_arg(arguments, unsigned int); return xhdi_inquire_device(args->drv, args->major, args->minor, args->start,
major = va_arg(arguments, uint16_t *); args->bpb);
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: case XHDI_INQUIRE_DRIVER:
{ {
uint16_t bios_device; struct XHINQDRIVER_args
{
uint16_t opcode;
uint16_t dev;
char *name; char *name;
char *version; char *version;
char *company; char *company;
uint16_t *ahdi_version; uint16_t *ahdi_version;
uint16_t *maxIPL; uint16_t *maxIPL;
}*args = (struct XHINQDRIVER_args *) stack;
bios_device = va_arg(arguments, unsigned int); return xhdi_inquire_driver(args->dev, args->name, args->version, args->company,
name = va_arg(arguments, char *); args->ahdi_version, args->maxIPL);
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: case XHDI_NEW_COOKIE:
{ {
void *new_cookie; struct XHNEWCOOKIE_args
{
uint16_t opcode;
uint32_t newcookie;
}*args = (struct XHNEWCOOKIE_args *) stack;
new_cookie = va_arg(arguments, void *); return xhdi_new_cookie(args->newcookie);
return xhdi_new_cookie(new_cookie);
} }
break;
case XHDI_READ_WRITE: case XHDI_READ_WRITE:
{ {
struct XHREADWRITE_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint16_t rwflag; uint16_t rw;
uint32_t recno; uint32_t sector;
uint16_t count; uint16_t count;
void *buf; void *buf;
}*args = (struct XHREADWRITE_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_read_write(args->major, args->minor, args->rw, args->sector,
minor = va_arg(arguments, unsigned int); args->count, args->buf);
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: case XHDI_INQUIRE_TARGET2:
{ {
struct XHINQTARGET2_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint32_t *block_size; uint32_t *blocksize;
uint32_t *device_flags; uint32_t *deviceflags;
char *product_name; char *productname;
uint16_t strlen; uint16_t stringlen;
}*args = (struct XHINQTARGET2_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_inquire_target2(args->major, args->minor, args->blocksize,
minor = va_arg(arguments, unsigned int); args->deviceflags, args->productname, args->stringlen);
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: case XHDI_INQUIRE_DEVICE2:
{ {
uint16_t bios_device; struct XHINQDEV2_args
{
uint16_t opcode;
uint16_t drv;
uint16_t *major; uint16_t *major;
uint16_t *minor; uint16_t *minor;
uint16_t *start_sector; uint32_t *start;
void *bpb; BPB *bpb;
uint32_t *blocks; uint32_t *blocks;
char *partid; char *partid;
}*args = (struct XHINQDEV2_args *) stack;
bios_device = va_arg(arguments, unsigned int); return xhdi_inquire_device2(args->drv, args->major, args->minor, args->start,
major = va_arg(arguments, uint16_t *); args->bpb, args->blocks, args->partid);
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: case XHDI_DRIVER_SPECIAL:
{ {
struct XHDRIVERSPECIAL_args
{
uint16_t opcode;
uint32_t key1; uint32_t key1;
uint32_t key2; uint32_t key2;
uint16_t subopcode; uint16_t subopcode;
void *data; void *data;
}*args = (struct XHDRIVERSPECIAL_args *) stack;
key1 = va_arg(arguments, uint32_t); return xhdi_driver_special(args->key1, args->key2, args->subopcode,
key2 = va_arg(arguments, uint32_t); args->data);
subopcode = va_arg(arguments, unsigned int);
data = va_arg(arguments, void *);
return xhdi_driver_special(key1, key2, subopcode, data);
} }
break;
case XHDI_GET_CAPACITY: case XHDI_GET_CAPACITY:
{ {
struct XHGETCAPACITY_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint32_t *blocks; uint32_t *blocks;
uint32_t *bs; uint32_t *blocksize;
}*args = (struct XHGETCAPACITY_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_get_capacity(args->major, args->minor, args->blocks,
minor = va_arg(arguments, unsigned int); args->blocksize);
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: case XHDI_MEDIUM_CHANGED:
{ {
struct XHMEDIUMCHANGED_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
}*args = (struct XHMEDIUMCHANGED_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_medium_changed(args->major, args->minor);
minor = va_arg(arguments, unsigned int);
return xhdi_medium_changed(major, minor);
} }
break;
case XHDI_MINT_INFO: case XHDI_MINT_INFO:
{
struct XHMINTINFO_args
{ {
uint16_t opcode; uint16_t opcode;
uint16_t subopcode;
void *data; void *data;
}*args = (struct XHMINTINFO_args *) stack;
opcode = va_arg(arguments, unsigned int); return xhdi_mint_info(args->subopcode, args->data);
data = va_arg(arguments, void *);
return xhdi_mint_info(opcode, data);
} }
break;
case XHDI_DOS_LIMITS: case XHDI_DOS_LIMITS:
{ {
struct XHDOSLIMITS_args
{
uint16_t opcode;
uint16_t which; uint16_t which;
uint32_t limit; uint32_t limit;
}*args = (struct XHDOSLIMITS_args *) stack;
which = va_arg(arguments, unsigned int); return xhdi_dos_limits(args->which, args->limit);
limit = va_arg(arguments, uint32_t);
return xhdi_dos_limits(which, limit);
} }
break;
case XHDI_LAST_ACCESS: case XHDI_LAST_ACCESS:
{ {
struct XHLASTACCESS_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
uint32_t *ms; uint32_t *ms;
}*args = (struct XHLASTACCESS_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_last_access(args->major, args->minor, args->ms);
minor = va_arg(arguments, unsigned int);
ms = va_arg(arguments, uint32_t *);
return xhdi_last_access(major, minor, ms);
} }
break;
case XHDI_REACCESS: case XHDI_REACCESS:
{ {
struct XHREACCESS_args
{
uint16_t opcode;
uint16_t major; uint16_t major;
uint16_t minor; uint16_t minor;
}*args = (struct XHREACCESS_args *) stack;
major = va_arg(arguments, unsigned int); return xhdi_reaccess(args->major, args->minor);
minor = va_arg(arguments, unsigned int);
return xhdi_reaccess(major, minor);
} }
break;
default: default:
{
xprintf("unknown XHDI function 0x%x\r\n", opcode);
return EINVFN;
break; break;
} }
xprintf("unknown XHDI function %d\r\n");
return EINVFN;
} }
}