src/edu/berkeley/slipway/FtdiBoard.java

   1 package edu.berkeley.slipway;
   2
   3 import com.ftdi.usb.*;
   4 import com.atmel.fpslic.*;
   5 import edu.berkeley.obits.*;
   6 import org.ibex.util.*;
   7 import java.io.*;
   8 import java.util.*;
   9 import gnu.io.*;
  10
  11 public class FtdiBoard extends Fpslic implements Board {
  12
  13     static {
  14         System.load(new File("build/"+System.mapLibraryName("FtdiUartNative")).getAbsolutePath());
  15     }
  16
  17     private final FpslicBoot chip;
  18     private final DataInputStream in;
  19     private final DataOutputStream out;
  20
  21     public InputStream getInputStream() { return in; }
  22     public OutputStream getOutputStream() { return out; }
  23
  24     public FtdiBoard() throws Exception {
  25         super(24, 24);
  26         chip = new FpslicBoot(new FpslicBootPinsUsb(new FtdiUart(0x6666, 0x3133, 1500 * 1000)));
  27         String bstFile = this.getClass().getName();
  28         bstFile = bstFile.substring(0, bstFile.lastIndexOf('.'));
  29         bstFile = bstFile.replace('.', '/')+"/slipway_drone.bst";
  30         boot(new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream(bstFile)));
  31         in = new DataInputStream(chip.getInputStream());
  32         out = new DataOutputStream(chip.getOutputStream());
  33         for(int i=0; i<255; i++) out.write(0);
  34         out.flush();
  35         init();
  36     }
  37
  38     public void reset() throws IOException { chip.reset(); }
  39
  40     public void boot(Reader r) throws Exception {
  41         chip.selfTest();
  42
  43         int total = 75090/9;
  44         OutputStream os = new ProgressOutputStream("bootstrap bitstream:", chip.getConfigStream(), total);
  45         BufferedReader br = new BufferedReader(r);
  46
  47         int bytes = 0;
  48         while(true) {
  49             String s = br.readLine();
  50             if (s==null) break;
  51             bytes++;
  52             os.write((byte)Integer.parseInt(s, 2));
  53             if ((bytes % 1000)==0) os.flush();
  54         }
  55         os.close();
  56     }
  57
  58
  59     // AvrDrone leftovers //////////////////////////////////////////////////////////////////////////////
  60
  61     private void init() throws IOException {
  62         byte[] bytes = new byte[6];
  63         int i=0;
  64
  65         out.write(0);
  66         out.flush();
  67
  68         // read any crap that might be left in the buffer
  69         while(true) {
  70             System.arraycopy(bytes, 1, bytes, 0, 5);
  71             bytes[5] = in.readByte();
  72             i++;
  73             System.out.print("\rsignature: read \"" + new String(bytes) + "\"                   ");
  74             if (bytes[0] == (byte)'O' &&
  75                 bytes[1] == (byte)'B' &&
  76                 bytes[2] == (byte)'I' &&
  77                 bytes[3] == (byte)'T' &&
  78                 bytes[4] == (byte)'S') {
  79                 System.out.println("\rsignature: got proper signature                  ");
  80                 break;
  81             }
  82         }
  83
  84         // FIXME: what if init() is called twice?
  85         new Thread() {
  86             public void run() {
  87                 while(true) {
  88                     try {
  89                         while(callbacks.size() == 0) Thread.sleep(500);
  90                         byte b = in.readByte();
  91                         ByteCallback bc = (ByteCallback)callbacks.remove(0);
  92                         bc.call(b);
  93                         synchronized(lock) {
  94                             lock.notifyAll();
  95                         }
  96                     } catch (Exception e) {
  97                         e.printStackTrace();
  98                     }
  99                 }
 100             }
 101         }.start();
 102     }
 103
 104
 105     // Programming ///////////////////////////////////////////////////////////////////////////////
 106
 107     private byte[][][] cache = new byte[24][][];
 108     public byte mode4(int z, int y, int x) {
 109         if (cache[x]==null) return 0;
 110         if (cache[x][y]==null) return 0;
 111         return cache[x][y][z];
 112     }
 113
 114     public void mode4(int z, int y, int x, int d) {
 115         try {
 116             if (cache[x & 0xff]==null) cache[x & 0xff] = new byte[24][];
 117             if (cache[x & 0xff][y & 0xff]==null) cache[x & 0xff][y & 0xff] = new byte[256];
 118             cache[x & 0xff][y & 0xff][z & 0xff] = (byte)(d & 0xff);
 119
 120             out.writeByte(1);
 121             out.writeByte(z);
 122             out.writeByte(y);
 123             out.writeByte(x);
 124             out.writeByte(d);
 125         } catch (IOException e) {
 126             throw new RuntimeException(e);
 127         }
 128     }
 129
 130     public void flush() { try { out.flush(); } catch (IOException e) { throw new RuntimeException(e); } }
 131
 132
 133     // Callbacks //////////////////////////////////////////////////////////////////////////////
 134
 135     private Vector callbacks = new Vector();
 136
 137     private Object lock = new Object();
 138     private static final int limit = 40;
 139
 140     private void enqueue(ByteCallback bcb) {
 141         synchronized(lock) {
 142             try {
 143                 while (callbacks.size() >= limit) {
 144                     System.out.println("block");
 145                     lock.wait(100);
 146                     System.out.println("unblock => " + callbacks.size());
 147                 }
 148             } catch (Exception e) {
 149                 throw new RuntimeException(e);
 150             }
 151         }
 152         callbacks.add(bcb);
 153     }
 154
 155     public static abstract class ByteCallback {
 156         public int result;
 157         public abstract void call(byte b) throws Exception;
 158     }
 159
 160     public synchronized int readCount() {
 161         try {
 162             ByteCallback bc = new ByteCallback() {
 163                     public synchronized void call(byte b) throws Exception {
 164                         result =
 165                             ((b & 0xff) << 24) |
 166                             ((in.read() & 0xff) << 16) |
 167                             ((in.read() & 0xff) << 8) |
 168                             ((in.read() & 0xff) << 0);
 169                         this.notify();
 170                     }
 171                 };
 172             synchronized(bc) {
 173                 enqueue(bc);
 174                 out.writeByte(3);
 175                 out.flush();
 176                 bc.wait();
 177             }
 178             return bc.result;
 179         } catch (Exception e) { throw new RuntimeException(e); }
 180     }
 181
 182     public synchronized void readBus(ByteCallback bc) throws IOException {
 183         enqueue(bc);
 184         out.writeByte(2);
 185         out.flush();
 186     }
 187
 188     public synchronized void readInterrupts(ByteCallback bc) throws IOException {
 189         enqueue(bc);
 190         out.writeByte(3);
 191         out.flush();
 192     }
 193
 194
 195     // Util //////////////////////////////////////////////////////////////////////////////
 196
 197     private String pad(int i, String s) { if (s.length()>i) return s; return "0"+pad((i-1),s); }
 198     public static String pad(String s, int i) {
 199         if (s.length() >= i) return s;
 200         return "0"+pad(s, i-1);
 201     }
 202
 203 }