return NULL;
}
-static const int *kazzo_open(void)
+struct reader_handle{
+ usb_dev_handle *handle;
+ void (*except)(const char *str);
+};
+
+static const struct reader_handle *kazzo_open(void (*except)(const char *str))
{
- return (const int *) device_open();
+ struct reader_handle *h;
+ usb_dev_handle *usb = device_open();
+ if(usb == NULL){
+ return NULL;
+ }
+ h = Malloc(sizeof(struct reader_handle));
+ h->handle = usb;
+ h->except = except;
+ return h;
}
-static void kazzo_close(const int *h)
+static void kazzo_close(const struct reader_handle *h)
{
- usb_close((usb_dev_handle *) h);
+ usb_close(h->handle);
+ Free((void *) h);
}
enum{
TIMEOUT = 4000
};
//-------- read sequence --------
-static void device_read(usb_dev_handle *handle, enum request r, enum index index, long address, long length, uint8_t *data)
+static void device_read(const struct reader_handle *h, enum request r, enum index index, long address, long length, uint8_t *data)
{
int cnt = usb_control_msg(
- handle,
+ h->handle,
USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
r, address,
index, (char *) data, length, TIMEOUT
);
if(cnt != length){
- puts(__FUNCTION__);
- puts(usb_strerror());
- exit(1);
+ h->except(usb_strerror());
+// puts(__FUNCTION__);
+// puts(usb_strerror());
+// exit(1);
}
}
-static void read_main(const int *d, const struct gauge *g, const enum request r, enum index index, long address, long length, uint8_t *data)
+static void read_main(const struct reader_handle *h, const struct gauge *g, const enum request r, enum index index, long address, long length, uint8_t *data)
{
const int packet = READ_PACKET_SIZE;
while(length >= packet){
device_read(
- (usb_dev_handle *) d,
- r, index, address, packet, data
+ h, r, index, address, packet, data
);
data += packet;
address += packet;
}
if(length != 0){
device_read(
- (usb_dev_handle *) d,
- r, index, address, length, data
+ h, r, index, address, length, data
);
g->value_add(g->bar, g->label, packet);
}
}
-static void kazzo_cpu_read(const int *d, const struct gauge *g, long address, long length, uint8_t *data)
+static void kazzo_cpu_read(const struct reader_handle *h, const struct gauge *g, long address, long length, uint8_t *data)
{
- read_main(d, g, REQUEST_CPU_READ, INDEX_IMPLIED, address, length, data);
+ read_main(h, g, REQUEST_CPU_READ, INDEX_IMPLIED, address, length, data);
// read_main(REQUEST_CPU_READ_6502, address, length, data);
}
-static void kazzo_ppu_read(const int *d, const struct gauge *g, long address, long length, uint8_t *data)
+static void kazzo_ppu_read(const struct reader_handle *h, const struct gauge *g, long address, long length, uint8_t *data)
{
- read_main(d, g, REQUEST_PPU_READ, INDEX_IMPLIED, address, length, data);
+ read_main(h, g, REQUEST_PPU_READ, INDEX_IMPLIED, address, length, data);
}
//-------- write sequence --------
/*
When host send data that contains 0xff many times, v-usb losts some
bits. To prevent losting bits, mask data xor 0xa5;
*/
-static void device_write(usb_dev_handle *handle, enum request w, enum index index, long address, long length, const uint8_t *data)
+static void device_write(const struct reader_handle *h, enum request w, enum index index, long address, long length, const uint8_t *data)
{
uint8_t *d = Malloc(length);
int i;
d[i] ^= 0xa5;
}
int cnt = usb_control_msg(
- handle,
+ h->handle,
USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
w, address,
index, (char *) d, length, TIMEOUT
);
if(cnt != length){
- puts(__FUNCTION__);
- puts(usb_strerror());
- exit(1);
+// puts(__FUNCTION__);
+// puts(usb_strerror());
+// exit(1);
+ h->except(usb_strerror());
}
Free(d);
}
-static void kazzo_init(const int *d)
+static void kazzo_init(const struct reader_handle *h)
{
- device_write((usb_dev_handle *) d, REQUEST_PHI2_INIT, INDEX_IMPLIED, 0, 0, NULL);
+ device_write(h, REQUEST_PHI2_INIT, INDEX_IMPLIED, 0, 0, NULL);
}
-static void write_memory(const int *d, enum request r, long address, long length, const uint8_t *data)
+static void write_memory(const struct reader_handle *h, enum request r, long address, long length, const uint8_t *data)
{
while(length != 0){
long l = length >= FLASH_PACKET_SIZE ? FLASH_PACKET_SIZE : length;
- device_write((usb_dev_handle *) d, r, INDEX_IMPLIED, address, l, data);
+ device_write(h, r, INDEX_IMPLIED, address, l, data);
address += l;
data += l;
length -= l;
}
}
-static void kazzo_cpu_write_6502(const int *d, long address, long length, const uint8_t *data)
+static void kazzo_cpu_write_6502(const struct reader_handle *h, long address, long length, const uint8_t *data)
{
- write_memory(d, REQUEST_CPU_WRITE_6502, address, length, data);
+ write_memory(h, REQUEST_CPU_WRITE_6502, address, length, data);
}
-static void kazzo_ppu_write(const int *d, long address, long length, const uint8_t *data)
+static void kazzo_ppu_write(const struct reader_handle *h, long address, long length, const uint8_t *data)
{
- write_memory(d, REQUEST_PPU_WRITE, address, length, data);
+ write_memory(h, REQUEST_PPU_WRITE, address, length, data);
}
static inline void pack_short_le(long l, uint8_t *t)
t[0] = l & 0xff;
t[1] = (l >> 8) & 0xff;
}
-static void flash_config(const int *d, enum request r, enum index index, long c000x, long c2aaa, long c5555, long unit, bool retry)
+static void flash_config(const struct reader_handle *h, enum request r, enum index index, long c000x, long c2aaa, long c5555, long unit, bool retry)
{
const int size = 2 * 4 + 1;
uint8_t buf[size];
pack_short_le(unit, t);
t += sizeof(uint16_t);
*t = retry == true ? 1 : 0;
- device_write((usb_dev_handle *) d, r, index, 0, size, buf);
+ device_write(h, r, index, 0, size, buf);
}
-static void kazzo_cpu_flash_config(const int *d, long c000x, long c2aaa, long c5555, long unit, bool retry)
+static void kazzo_cpu_flash_config(const struct reader_handle *h, long c000x, long c2aaa, long c5555, long unit, bool retry)
{
- flash_config(d, REQUEST_FLASH_CONFIG_SET, INDEX_CPU, c000x, c2aaa, c5555, unit, retry);
+ flash_config(h, REQUEST_FLASH_CONFIG_SET, INDEX_CPU, c000x, c2aaa, c5555, unit, retry);
}
-static void kazzo_ppu_flash_config(const int *d, long c000x, long c2aaa, long c5555, long unit, bool retry)
+static void kazzo_ppu_flash_config(const struct reader_handle *h, long c000x, long c2aaa, long c5555, long unit, bool retry)
{
- flash_config(d, REQUEST_FLASH_CONFIG_SET, INDEX_PPU, c000x, c2aaa, c5555, unit, retry);
+ flash_config(h, REQUEST_FLASH_CONFIG_SET, INDEX_PPU, c000x, c2aaa, c5555, unit, retry);
}
-static inline void flash_execute(const int *d, enum request p, enum request s, enum index index, long address, const uint8_t *data, int size, bool dowait, bool skip)
+static inline void flash_execute(const struct reader_handle *h, enum request p, enum request s, enum index index, long address, const uint8_t *data, int size, bool dowait, bool skip)
{
uint8_t status;
int filled = 1;
Free(filldata);
}
if(filled != 0){
- device_write((usb_dev_handle *) d, p, index, address, size, data);
+ device_write(h, p, index, address, size, data);
}
if(dowait == true){
do{
wait(10);
- device_read((usb_dev_handle *) d, s, index, 0, 1, &status);
+ device_read(h, s, index, 0, 1, &status);
}while(status != KAZZO_TASK_FLASH_IDLE);
}
}
-static void kazzo_cpu_flash_erase(const int *d, long address, bool dowait)
+static void kazzo_cpu_flash_erase(const struct reader_handle *h, long address, bool dowait)
{
- flash_execute(d, REQUEST_FLASH_ERASE, REQUEST_FLASH_STATUS, INDEX_CPU, address, NULL, 0, dowait, false);
+ flash_execute(h, REQUEST_FLASH_ERASE, REQUEST_FLASH_STATUS, INDEX_CPU, address, NULL, 0, dowait, false);
}
-static void kazzo_ppu_flash_erase(const int *d, long address, bool dowait)
+static void kazzo_ppu_flash_erase(const struct reader_handle *h, long address, bool dowait)
{
- flash_execute(d, REQUEST_FLASH_ERASE, REQUEST_FLASH_STATUS, INDEX_PPU, address, NULL, 0, dowait, false);
+ flash_execute(h, REQUEST_FLASH_ERASE, REQUEST_FLASH_STATUS, INDEX_PPU, address, NULL, 0, dowait, false);
}
static void dump(const uint8_t *w, const uint8_t *r, long length)
length -= 0x10;
}
}
-static long flash_program(const int *h, const struct gauge *g, enum index index, long address, long length, const uint8_t *data, bool dowait, bool skip)
+static long flash_program(const struct reader_handle *h, const struct gauge *g, enum index index, long address, long length, const uint8_t *data, bool dowait, bool skip)
{
enum request p = REQUEST_FLASH_PROGRAM;
enum request s = REQUEST_FLASH_STATUS;
Free(d);
return count;
}
-static long kazzo_cpu_flash_program(const int *d, const struct gauge *g, long address, long length, const uint8_t *data, bool dowait, bool skip)
+static long kazzo_cpu_flash_program(const struct reader_handle *h, const struct gauge *g, long address, long length, const uint8_t *data, bool dowait, bool skip)
{
- return flash_program(d, g, INDEX_CPU, address, length, data, dowait, skip);
+ return flash_program(h, g, INDEX_CPU, address, length, data, dowait, skip);
}
-static long kazzo_ppu_flash_program(const int *d, const struct gauge *g, long address, long length, const uint8_t *data, bool dowait, bool skip)
+static long kazzo_ppu_flash_program(const struct reader_handle *h, const struct gauge *g, long address, long length, const uint8_t *data, bool dowait, bool skip)
{
- return flash_program(d, g, INDEX_PPU, address, length, data, dowait, skip);
+ return flash_program(h, g, INDEX_PPU, address, length, data, dowait, skip);
}
-static void kazzo_flash_status(const int *d, uint8_t s[2])
+static void kazzo_flash_status(const struct reader_handle *h, uint8_t s[2])
{
- read_main(d, &GAUGE_DUMMY, REQUEST_FLASH_STATUS, INDEX_BOTH, 0, 2, s);
+ read_main(h, &GAUGE_DUMMY, REQUEST_FLASH_STATUS, INDEX_BOTH, 0, 2, s);
}
-static void kazzo_cpu_flash_device_get(const int *d, uint8_t s[2])
+static void kazzo_cpu_flash_device_get(const struct reader_handle *h, uint8_t s[2])
{
- read_main(d, &GAUGE_DUMMY, REQUEST_FLASH_DEVICE, INDEX_CPU, 0, 2, s);
+ read_main(h, &GAUGE_DUMMY, REQUEST_FLASH_DEVICE, INDEX_CPU, 0, 2, s);
}
-static void kazzo_ppu_flash_device_get(const int *d, uint8_t s[2])
+static void kazzo_ppu_flash_device_get(const struct reader_handle *h, uint8_t s[2])
{
- read_main(d, &GAUGE_DUMMY, REQUEST_FLASH_DEVICE, INDEX_PPU, 0, 2, s);
+ read_main(h, &GAUGE_DUMMY, REQUEST_FLASH_DEVICE, INDEX_PPU, 0, 2, s);
}
-static uint8_t kazzo_vram_connection(const int *d)
+static uint8_t kazzo_vram_connection(const struct reader_handle *h)
{
uint8_t s;
- read_main(d, &GAUGE_DUMMY, REQUEST_VRAM_CONNECTION, INDEX_IMPLIED, 0, 1, &s);
+ read_main(h, &GAUGE_DUMMY, REQUEST_VRAM_CONNECTION, INDEX_IMPLIED, 0, 1, &s);
return s;
}
const struct reader_driver DRIVER_KAZZO = {
OSDN Git Service
