libdb/geckousb.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include <stdio.h>
   4 #include <errno.h>
   5 #include <signal.h>
   6 #include <gccore.h>
   7
   8 #include "geckousb.h"
   9
  10 #define _SHIFTL(v, s, w)        \
  11         ((u32) (((u32)(v) & ((0x01 << (w)) - 1)) << (s)))
  12 #define _SHIFTR(v, s, w)        \
  13         ((u32)(((u32)(v) >> (s)) & ((0x01 << (w)) - 1)))
  14
  15 static struct dbginterface usb_device;
  16
  17 static __inline__ int __send_command(s32 chn,u16 *cmd)
  18 {
  19         s32 ret;
  20
  21         ret = 0;
  22         if(!EXI_Select(chn,EXI_DEVICE_0,EXI_SPEED32MHZ)) ret |= 0x01;
  23         if(!EXI_Imm(chn,cmd,sizeof(u16),EXI_READWRITE,NULL)) ret |= 0x02;
  24         if(!EXI_Sync(chn)) ret |= 0x04;
  25         if(!EXI_Deselect(chn)) ret |= 0x08;
  26
  27         if(ret) return 0;
  28         return 1;
  29 }
  30
  31 static int __usb_sendbyte(s32 chn,char ch)
  32 {
  33         s32 ret;
  34         u16 val;
  35
  36         val = (0xB000|_SHIFTL(ch,4,8));
  37         ret = __send_command(chn,&val);
  38         if(ret==1 && !(val&0x0400)) ret = 0;
  39
  40         return ret;
  41 }
  42
  43 static int __usb_recvbyte(s32 chn,char *ch)
  44 {
  45         s32 ret;
  46         u16 val;
  47
  48         *ch = 0;
  49         val = 0xA000;
  50         ret = __send_command(chn,&val);
  51         if(ret==1 && !(val&0x0800)) ret = 0;
  52         else if(ret==1) *ch = (val&0xff);
  53
  54         return ret;
  55 }
  56
  57 static int __usb_checksend(s32 chn)
  58 {
  59         s32 ret;
  60         u16 val;
  61
  62         val = 0xC000;
  63         ret = __send_command(chn,&val);
  64         if(ret==1 && !(val&0x0400)) ret = 0;
  65
  66         return ret;
  67 }
  68
  69 static int __usb_checkrecv(s32 chn)
  70 {
  71         s32 ret;
  72         u16 val;
  73
  74         val = 0xD000;
  75         ret = __send_command(chn,&val);
  76         if(ret==1 && !(val&0x0400)) ret = 0;
  77
  78         return ret;
  79 }
  80
  81 static void __usb_flush(s32 chn)
  82 {
  83         char tmp;
  84
  85         if(!EXI_Lock(chn,EXI_DEVICE_0,NULL)) return;
  86
  87         while(__usb_recvbyte(chn,&tmp));
  88
  89         EXI_Unlock(chn);
  90 }
  91
  92
  93 static int __usb_isgeckoalive(s32 chn)
  94 {
  95         s32 ret;
  96         u16 val;
  97
  98         if(!EXI_Lock(chn,EXI_DEVICE_0,NULL)) return 0;
  99
 100         val = 0x9000;
 101         ret = __send_command(chn,&val);
 102         if(ret==1 && !(val&0x0470)) ret = 0;
 103
 104         EXI_Unlock(chn);
 105         return ret;
 106 }
 107
 108 static int __usb_recvbuffer(s32 chn,void *buffer,int size)
 109 {
 110         s32 ret;
 111         s32 left = size;
 112         char *ptr = (char*)buffer;
 113
 114         if(!EXI_Lock(chn,EXI_DEVICE_0,NULL)) return 0;
 115
 116         while(left>0) {
 117                 if(__usb_checkrecv(chn)) {
 118                         ret = __usb_recvbyte(chn,ptr);
 119                         if(ret==0) break;
 120
 121                         ptr++;
 122                         left--;
 123                 }
 124         }
 125
 126         EXI_Unlock(chn);
 127         return (size - left);
 128 }
 129
 130 static int __usb_sendbuffer(s32 chn,const void *buffer,int size)
 131 {
 132         s32 ret;
 133         s32 left = size;
 134         char *ptr = (char*)buffer;
 135
 136         if(!EXI_Lock(chn,EXI_DEVICE_0,NULL)) return 0;
 137
 138         while(left>0) {
 139                 if(__usb_checksend(chn)) {
 140                         ret = __usb_sendbyte(chn,*ptr);
 141                         if(ret==0) break;
 142
 143                         ptr++;
 144                         left--;
 145                 }
 146         }
 147
 148         EXI_Unlock(chn);
 149         return (size - left);
 150 }
 151
 152 static int usbopen(struct dbginterface *device)
 153 {
 154         if(!__usb_isgeckoalive(device->fhndl)) {
 155                 return -1;
 156         }
 157
 158         return 0;
 159 }
 160
 161 static int usbclose(struct dbginterface *device)
 162 {
 163         return 0;
 164 }
 165
 166 static int usbwait(struct dbginterface *device)
 167 {
 168         return 0;
 169 }
 170
 171 static int usbread(struct dbginterface *device,void *buffer,int size)
 172 {
 173         int ret;
 174         ret = __usb_recvbuffer(device->fhndl,buffer,size);
 175         return ret;
 176 }
 177
 178 static int usbwrite(struct dbginterface *device,const void *buffer,int size)
 179 {
 180         int ret;
 181         ret = __usb_sendbuffer(device->fhndl,buffer,size);
 182         return ret;
 183 }
 184
 185 struct dbginterface* usb_init(s32 channel)
 186 {
 187         usb_device.fhndl = channel;
 188         if(__usb_isgeckoalive(channel))
 189                 __usb_flush(channel);
 190
 191         usb_device.open = usbopen;
 192         usb_device.close = usbclose;
 193         usb_device.wait = usbwait;
 194         usb_device.read = usbread;
 195         usb_device.write = usbwrite;
 196
 197         return &usb_device;
 198 }