client/trunk/reader_kazzo.c

   1 #include <assert.h>
   2 #include <stdlib.h>
   3 #include <usb.h>
   4 #include <kazzo_request.h>
   5 #include <kazzo_task.h>
   6 #include "memory_manage.h"
   7 #include "reader_master.h"
   8 #include "usb_device.h"
   9 #include "reader_kazzo.h"
  10
  11 static usb_dev_handle *device_open(void)
  12 {
  13         usb_dev_handle *handle = NULL;
  14         const unsigned char rawVid[2] = {USB_CFG_VENDOR_ID};
  15         const unsigned char rawPid[2] = {USB_CFG_DEVICE_ID};
  16         char vendor[] = {USB_CFG_VENDOR_NAME, 0};
  17         char product[] = {USB_CFG_DEVICE_NAME, 0};
  18         int vid, pid;
  19
  20         /* compute VID/PID from usbconfig.h so that there is a central source of information */
  21         vid = (rawVid[1] << 8) | rawVid[0];
  22         pid = (rawPid[1] << 8) | rawPid[0];
  23
  24         if(usbOpenDevice(&handle, vid, vendor, pid, product, NULL, NULL, NULL) == 0){
  25                 return handle;
  26         }
  27         fprintf(stderr, "Could not find USB device \"%s\" with vid=0x%x pid=0x%x\n", product, vid, pid);
  28         return NULL;
  29 }
  30 static usb_dev_handle *handle = NULL;
  31 static int kazzo_open_close(enum reader_control oc)
  32 {
  33         switch(oc){
  34         case READER_OPEN:
  35                 handle = device_open();
  36                 return handle == NULL ? NG : OK;
  37         case READER_CLOSE:
  38                 usb_close(handle);
  39                 handle = NULL;
  40                 return OK;
  41         }
  42         return NG;
  43 }
  44 enum{
  45         TIMEOUT = 4000
  46 };
  47 //-------- read sequence --------
  48 static void device_read(usb_dev_handle *handle, enum request r, long address, long length, uint8_t *data)
  49 {
  50         int cnt = usb_control_msg(
  51                 handle,
  52                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
  53                 r, address,
  54                 0, data, length, TIMEOUT
  55         );
  56         if(cnt != length){
  57                 puts(__FUNCTION__);
  58                 puts(usb_strerror());
  59                 exit(1);
  60         }
  61 }
  62 static void read_main(const enum request r, long address, long length, uint8_t *data)
  63 {
  64         const int packet = READ_PACKET_SIZE;
  65         while(length >= packet){
  66                 device_read(handle, r, address, packet, data);
  67                 data += packet;
  68                 address += packet;
  69                 length -= packet;
  70         }
  71         if(length != 0){
  72                 device_read(handle, r, address, length, data);
  73         }
  74 }
  75 static void kazzo_cpu_read(long address, long length, uint8_t *data)
  76 {
  77         read_main(REQUEST_CPU_READ, address, length, data);
  78 //      read_main(REQUEST_CPU_READ_6502, address, length, data);
  79 }
  80 static void kazzo_ppu_read(long address, long length, uint8_t *data)
  81 {
  82         read_main(REQUEST_PPU_READ, address, length, data);
  83 }
  84 //-------- write sequence --------
  85 static void device_write(usb_dev_handle *handle, enum request w, long address, long length, const uint8_t *data)
  86 {
  87         //Removing const attribute is not good method....
  88         uint8_t *d = Malloc(length);
  89         memcpy(d, data, length);
  90         int cnt = usb_control_msg(
  91                 handle,
  92                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
  93                 w, address,
  94                 0, d, length, TIMEOUT
  95         );
  96         if(cnt != length){
  97                 puts(__FUNCTION__);
  98                 puts(usb_strerror());
  99                 exit(1);
 100         }
 101         Free(d);
 102 }
 103
 104 static void kazzo_init(void)
 105 {
 106         device_write(handle, REQUEST_PHI2_INIT, 0, 0, NULL);
 107 }
 108
 109 static void kazzo_cpu_write_6502(long address, long length, const uint8_t *data)
 110 {
 111         device_write(handle, REQUEST_CPU_WRITE_6502, address, length, data);
 112 }
 113 /*static void kazzo_cpu_write_flash(long address, long data)
 114 {
 115         uint8_t d = (uint8_t) (data & 0xff);
 116         device_write(handle, REQUEST_CPU_WRITE_FLASH, address, 1, &d);
 117 }*/
 118 static void kazzo_ppu_write(long address, long length, const uint8_t *data)
 119 {
 120         device_write(handle, REQUEST_PPU_WRITE, address, length, data);
 121 }
 122
 123 static inline void pack_short_le(long l, uint8_t *t)
 124 {
 125         t[0] = l & 0xff;
 126         t[1] = (l >> 8) & 0xff;
 127 }
 128 static void flash_config(enum request r, long c000x, long c2aaa, long c5555, long unit)
 129 {
 130         const int size = 2 * 4;
 131         uint8_t t[size];
 132         assert(unit >= 1 && unit < 0x400);
 133         pack_short_le(c000x, t);
 134         pack_short_le(c2aaa, t + 2);
 135         pack_short_le(c5555, t + 4);
 136         pack_short_le(unit, t + 6);
 137         device_write(handle, r, 0, size, t);
 138 }
 139 static void kazzo_cpu_flash_config(long c000x, long c2aaa, long c5555, long unit)
 140 {
 141         flash_config(REQUEST_CPU_FLASH_CONFIG_SET, c000x, c2aaa, c5555, unit);
 142 }
 143 static void kazzo_ppu_flash_config(long c000x, long c2aaa, long c5555, long unit)
 144 {
 145         flash_config(REQUEST_PPU_FLASH_CONFIG_SET, c000x, c2aaa, c5555, unit);
 146 }
 147
 148 static inline void flash_execute(enum request p, enum request s, long address, const uint8_t *data, int size, bool dowait)
 149 {
 150         uint8_t status;
 151         device_write(handle, p, address, size, data);
 152         if(dowait == true){
 153                 do{
 154                         wait(10);
 155                         device_read(handle, s, 0, 1, &status);
 156                 }while(status != KAZZO_TASK_FLASH_IDLE);
 157         }
 158 }
 159 static void kazzo_cpu_flash_erase(long address, bool dowait)
 160 {
 161         flash_execute(REQUEST_CPU_FLASH_ERASE, REQUEST_CPU_FLASH_STATUS, address, NULL, 0, dowait);
 162 }
 163 static void kazzo_ppu_flash_erase(long address, bool dowait)
 164 {
 165         flash_execute(REQUEST_PPU_FLASH_ERASE, REQUEST_PPU_FLASH_STATUS, address, NULL, 0, dowait);
 166 }
 167
 168 static long flash_program(enum request p, enum request s, long address, long length, const uint8_t *data, bool dowait)
 169 {
 170         if(dowait == false){
 171                 flash_execute(p, s, address, data, FLASH_PACKET_SIZE, dowait);
 172                 return FLASH_PACKET_SIZE;
 173         }
 174         long count = 0;
 175         uint8_t *d = Malloc(FLASH_PACKET_SIZE);
 176         while(length >= FLASH_PACKET_SIZE){
 177                 flash_execute(p, s, address, data, FLASH_PACKET_SIZE, dowait);
 178                 device_read(handle, REQUEST_PPU_FLASH_BUFFER_GET, 0, FLASH_PACKET_SIZE, d);
 179                 if(memcmp(d, data, FLASH_PACKET_SIZE) != 0){
 180                         puts("packet send error");
 181                 }
 182                 address += FLASH_PACKET_SIZE;
 183                 data += FLASH_PACKET_SIZE;
 184                 count += FLASH_PACKET_SIZE;
 185                 length -= FLASH_PACKET_SIZE;
 186         }
 187         Free(d);
 188         return count;
 189 }
 190 static long kazzo_cpu_flash_program(long address, long length, const uint8_t *data, bool dowait)
 191 {
 192         enum request p = REQUEST_CPU_FLASH_PROGRAM;
 193         enum request s = REQUEST_CPU_FLASH_STATUS;
 194         return flash_program(p, s, address, length, data, dowait);
 195 }
 196 static long kazzo_ppu_flash_program(long address, long length, const uint8_t *data, bool dowait)
 197 {
 198         return flash_program(REQUEST_PPU_FLASH_PROGRAM, REQUEST_PPU_FLASH_STATUS, address, length, data, dowait);
 199 }
 200
 201 static void kazzo_flash_status(uint8_t s[2])
 202 {
 203         read_main(REQUEST_BOTH_FLASH_STATUS, 0, 2, s);
 204 }
 205 static void kazzo_cpu_flash_device_get(uint8_t s[2])
 206 {
 207         read_main(REQUEST_CPU_FLASH_DEVICE, 0, 2, s);
 208 }
 209 static void kazzo_ppu_flash_device_get(uint8_t s[2])
 210 {
 211         read_main(REQUEST_PPU_FLASH_DEVICE, 0, 2, s);
 212 }
 213 static uint8_t kazzo_vram_connection(void)
 214 {
 215         uint8_t s;
 216         read_main(REQUEST_VRAM_CONNECTION, 0, 1, &s);
 217         return s;
 218 }
 219 const struct reader_driver DRIVER_KAZZO = {
 220         .name = "kazzo",
 221         .open_or_close = kazzo_open_close,
 222         .init = kazzo_init,
 223         .cpu_read = kazzo_cpu_read, .ppu_read = kazzo_ppu_read,
 224         .cpu_write_6502 = kazzo_cpu_write_6502,
 225         .flash_support = true,
 226         .ppu_write = kazzo_ppu_write,
 227         .cpu_flash_config = kazzo_cpu_flash_config,
 228         .cpu_flash_erase = kazzo_cpu_flash_erase,
 229         .cpu_flash_program = kazzo_cpu_flash_program,
 230         .cpu_flash_device_get = kazzo_cpu_flash_device_get,
 231         .ppu_flash_config = kazzo_ppu_flash_config,
 232         .ppu_flash_erase = kazzo_ppu_flash_erase,
 233         .ppu_flash_program = kazzo_ppu_flash_program,
 234         .ppu_flash_device_get = kazzo_ppu_flash_device_get,
 235         .flash_status = kazzo_flash_status,
 236         .vram_connection = kazzo_vram_connection
 237 };