libogc/usbgecko.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 #include <machine/processor.h>
   8
   9 #include "usbgecko.h"
  10
  11 #define _SHIFTL(v, s, w)        \
  12         ((u32) (((u32)(v) & ((0x01 << (w)) - 1)) << (s)))
  13 #define _SHIFTR(v, s, w)        \
  14         ((u32)(((u32)(v) >> (s)) & ((0x01 << (w)) - 1)))
  15
  16
  17 static u32 usbgecko_inited = 0;
  18 static lwpq_t wait_exi_queue[2];
  19
  20 static s32 __usbgecko_exi_unlock(s32 chan,s32 dev)
  21 {
  22         LWP_ThreadBroadcast(wait_exi_queue[chan]);
  23         return 1;
  24 }
  25
  26 static void __usbgecko_init()
  27 {
  28         u32 i;
  29
  30         for(i=0;i<EXI_CHANNEL_2;i++) {
  31                 LWP_InitQueue(&wait_exi_queue[i]);
  32         }
  33         usbgecko_inited = 1;
  34 }
  35
  36 static __inline__ void __usbgecko_exi_wait(s32 chn)
  37 {
  38         u32 level;
  39
  40         _CPU_ISR_Disable(level);
  41         if(!usbgecko_inited) __usbgecko_init();
  42         while(EXI_Lock(chn,EXI_DEVICE_0,__usbgecko_exi_unlock)==0) {
  43                 LWP_ThreadSleep(wait_exi_queue[chn]);
  44         }
  45         _CPU_ISR_Restore(level);
  46 }
  47
  48 static __inline__ int __send_command(s32 chn,u16 *cmd)
  49 {
  50         s32 ret = 0;
  51
  52         if(!EXI_Select(chn,EXI_DEVICE_0,EXI_SPEED32MHZ)) ret |= 0x01;
  53         if(!EXI_Imm(chn,cmd,sizeof(u16),EXI_READWRITE,NULL)) ret |= 0x02;
  54         if(!EXI_Sync(chn)) ret |= 0x04;
  55         if(!EXI_Deselect(chn)) ret |= 0x08;
  56
  57         if(ret) return 0;
  58         return 1;
  59 }
  60
  61 static int __usb_sendbyte(s32 chn,char ch)
  62 {
  63         s32 ret;
  64         u16 val;
  65
  66         val = (0xB000|_SHIFTL(ch,4,8));
  67         ret = __send_command(chn,&val);
  68         if(ret==1 && !(val&0x0400)) ret = 0;
  69
  70         return ret;
  71 }
  72
  73 static int __usb_recvbyte(s32 chn,char *ch)
  74 {
  75         s32 ret;
  76         u16 val;
  77
  78         *ch = 0;
  79         val = 0xA000;
  80         ret = __send_command(chn,&val);
  81         if(ret==1 && !(val&0x0800)) ret = 0;
  82         else if(ret==1) *ch = (val&0xff);
  83
  84         return ret;
  85 }
  86
  87 int __usb_checksend(s32 chn)
  88 {
  89         s32 ret;
  90         u16 val;
  91
  92         val = 0xC000;
  93         ret = __send_command(chn,&val);
  94         if(ret==1 && !(val&0x0400)) ret = 0;
  95
  96         return ret;
  97 }
  98
  99 int __usb_checkrecv(s32 chn)
 100 {
 101         s32 ret;
 102         u16 val;
 103
 104         val = 0xD000;
 105         ret = __send_command(chn,&val);
 106         if(ret==1 && !(val&0x0400)) ret = 0;
 107
 108         return ret;
 109 }
 110
 111 void usb_flush(s32 chn)
 112 {
 113         char tmp;
 114
 115         __usbgecko_exi_wait(chn);
 116         while(__usb_recvbyte(chn,&tmp));
 117         EXI_Unlock(chn);
 118 }
 119
 120 int usb_isgeckoalive(s32 chn)
 121 {
 122         s32 ret;
 123         u16 val;
 124         u32 id = 0;
 125
 126         if(EXI_GetID(chn,EXI_DEVICE_0,&id)==0) return 0;
 127         if(id!=0) return 0;
 128
 129         __usbgecko_exi_wait(chn);
 130
 131         val = 0x9000;
 132         ret = __send_command(chn,&val);
 133         if(ret==1 && !(val&0x0470)) ret = 0;
 134
 135         EXI_Unlock(chn);
 136
 137         return ret;
 138 }
 139
 140 int usb_recvbuffer(s32 chn,void *buffer,int size)
 141 {
 142         s32 ret;
 143         s32 left = size;
 144         char *ptr = (char*)buffer;
 145
 146         __usbgecko_exi_wait(chn);
 147         while(left>0) {
 148                 ret = __usb_recvbyte(chn,ptr);
 149                 if(ret==0) break;
 150
 151                 ptr++;
 152                 left--;
 153         }
 154         EXI_Unlock(chn);
 155
 156         return (size - left);
 157 }
 158
 159 int usb_sendbuffer(s32 chn,const void *buffer,int size)
 160 {
 161         s32 ret;
 162         s32 left = size;
 163         char *ptr = (char*)buffer;
 164
 165         __usbgecko_exi_wait(chn);
 166         while(left>0) {
 167                 ret = __usb_sendbyte(chn,*ptr);
 168                 if(ret==0) break;
 169
 170                 ptr++;
 171                 left--;
 172         }
 173         EXI_Unlock(chn);
 174
 175         return (size - left);
 176 }
 177
 178 int usb_recvbuffer_safe(s32 chn,void *buffer,int size)
 179 {
 180         s32 ret;
 181         s32 left = size;
 182         char *ptr = (char*)buffer;
 183
 184         __usbgecko_exi_wait(chn);
 185         while(left>0) {
 186                 if(__usb_checkrecv(chn)) {
 187                         ret = __usb_recvbyte(chn,ptr);
 188                         if(ret==0) break;
 189
 190                         ptr++;
 191                         left--;
 192                 }
 193         }
 194         EXI_Unlock(chn);
 195
 196         return (size - left);
 197 }
 198
 199 int usb_sendbuffer_safe(s32 chn,const void *buffer,int size)
 200 {
 201         s32 ret;
 202         s32 left = size;
 203         char *ptr = (char*)buffer;
 204
 205         __usbgecko_exi_wait(chn);
 206         while(left>0) {
 207                 if(__usb_checksend(chn)) {
 208                         ret = __usb_sendbyte(chn,*ptr);
 209                         if(ret==0) break;
 210
 211                         ptr++;
 212                         left--;
 213                 }
 214         }
 215         EXI_Unlock(chn);
 216
 217         return (size - left);
 218 }