src/edu/berkeley/cs/obits/device/atmel/AtmelDevice.java

   1 package edu.berkeley.cs.obits.device.atmel;
   2
   3 import edu.berkeley.cs.obits.*;
   4 //import static edu.berkeley.cs.obits.device.atmel.Wires.*;
   5 import java.util.*;
   6
   7 public abstract class AtmelDevice extends Bits implements Device {
   8
   9     /** issue a command to the device in Mode4 format; see Gosset's documentation for further details */
  10     public abstract void mode4(int z, int y, int x, int d) throws DeviceException;
  11     /*
  12     public Sector sector(int col, int row) { return new Sector(col, row); }
  13     public final class Sector {
  14         public final int col;
  15         public final int row;
  16         public Sector(int col, int row) {
  17             if (row % 4 != 0) throw new Error("Sector must be created with a multiple-of-4 row");
  18             if (col % 4 != 0) throw new Error("Sector must be created with a multiple-of-4 col");
  19             this.row = row;
  20             this.col = col;
  21         }
  22     }
  23
  24     public static interface Driver { }
  25
  26     public static interface HasPlane { public int getPlane(); }
  27
  28     public static interface XI extends Driver { }
  29     public static interface YI extends Driver { }
  30     */
  31     /*
  32     public static void foo(Direction f) { }
  33     public static enum Direction implements Drives<Y> { N, S, E, W; }
  34     public static enum Bar { A, B, C; }
  35     public static Object B = new Object();
  36     public static Direction foo = null;
  37     static {
  38         switch(foo) {
  39             case N:
  40             case S:
  41             case W:
  42         }
  43     }
  44
  45     public class Drives<E extends EPR<E>> { }
  46     public class EPR<E extends EPR<E>> {
  47         public abstract Drives<E> driver();
  48         public abstract void      driver(Drives<E>);
  49     }
  50
  51     public class Joins<B extends Bus<B>> { }
  52     public abstract class Bus<B extends Bus<B>> {
  53         public Set<Joins<E>> drivers();
  54     }
  55     public interface Drives<E extends EPR> { }
  56
  57
  58     public static interface EPR {
  59     }
  60     public static interface Drives<E extends EPR> { }
  61     public static interface Bus extends EPR { }
  62     public static interface Joins<J extends Joins, B extends Bus & Joins<B,J>> extends Bus { }
  63     //public static interface Joins<B extends Bus> extends Bus { }
  64     public static interface Has<E extends EPR> {
  65         public Drives<E> getDriver(E e);
  66         public void      setDriver(E e, Drives<E> driver);
  67     }
  68     //public static interface HasBus<B extends Bus> { public Set<OnBus<B>> on(B b); }
  69     public interface Input { }
  70     public interface Output { }
  71     public interface InOut { }
  72
  73     public static abstract class LUT<A extends EPR, B extends EPR, C extends EPR> implements EPR { }
  74     public static abstract class And<A extends EPR, B extends EPR> implements EPR { }
  75     public static abstract class Reg<A extends EPR> { }
  76     public static abstract class Mux<Sel extends EPR, Zero extends EPR, One extends EPR> { }
  77     public static abstract class Buf<Sel extends EPR> { }
  78
  79     public enum DiagonalInputs   implements Input, Drives<X> { NW, SW, NE, SE; }
  80     public enum OrthogonalInputs implements Input, Drives<Y> { N,  S,  E,  W;  }
  81
  82     public <X extends Drives<Y>, Y extends EPR> void connect(X x, Y y) { }
  83
  84     public static enum Plane { P0, P1, P2, P3, P4; }
  85     public static class L<P extends Plane> implements Bus, Drives<X>, Drives<Y>, Drives<Z>, Drives<W> { }
  86
  87     public final class Cell {
  88       public class X                         implements EPR, Drives<XLUT>, Drives<YLUT> { }
  89       public class Y                         implements EPR, Drives<XLUT>, Drives<YLUT> { }
  90       public class Z                         implements EPR, Drives<A>, Drives<WZ> { }
  91       public class F                         implements EPR, Drives<A>, Drives<WF>, Drives<OB> { }
  92       public class W                         implements EPR, Drives<A>, Drives<WZ>, Drives<WF> { }
  93       public class A                         implements EPR { }
  94       public class WZ   extends And<W, Z>    implements EPR, Drives<XLUT>, Drives<YLUT> { }
  95       public class WF   extends And<W, F>    implements EPR, Drives<XLUT>, Drives<YLUT> { }
  96       public class CM   extends Mux<Z, Y, X> implements EPR, Drives<C> { }
  97       public class XLUT extends LUT<X, Y, A> implements EPR, Drives<CM>, Drives<XO> { }
  98       public class YLUT extends LUT<A, X, Y> implements EPR, Drives<CM>, Drives<YO> { }
  99       public class C                         implements EPR, Drives<R>, Drives<F> { }
 100       public class R    extends Reg<C>       implements EPR, Drives<F>, Drives<XO>, Drives<YO>{ }
 101       public class XO                        implements EPR, Output { }
 102       public class YO                        implements EPR, Output { }
 103       public static class OB   extends Buf<F>>       implements EPR, Drives<L0>, Drives<L1>, Drives<L2>, Drives<L3>, Drives<L4> { }
 104
 105     */
 106     //public static L1 L1 = new L1();
 107     /*
 108     public static class CellImpl implements
 109                                  Has<X>,
 110                                      Has<Y> {
 111         public void           setDriver(X x, Drives<X> d) { }
 112         public void           setDriver(Y y, Drives<Y> d) { }
 113         public void           setDriver(Z z, Drives<Z> d) { }
 114         public void           setDriver(W w, Drives<W> d) { }
 115         public Drives<X>      getDriver(X x)            { return null; }
 116         public Drives<Y>      getDriver(Y y)            { return null; }
 117         public Drives<Z>      getDriver(Z z)            { return null; }
 118         public Drives<W>      getDriver(W w)            { return null; }
 119
 120         public Set<OnBus<L1>> on(L1 l1)                 { return null; }
 121         public Drives<Y>      getDriver(Y y)            { return null; }
 122         public void           setDriver(Y y, Drives<Y> d) { }
 123     }
 124     */
 125         /*
 126     public static abstract class L<D extends C> implements HasPlane, EPR<C> {
 127         private final int plane;
 128         L(int plane) { this.plane = plane; }
 129         public int getPlane() { return plane; }
 130         public boolean h();
 131         public void    h(boolean connected);
 132         public boolean v();
 133         public void    v(boolean connected);
 134         public boolean f();
 135         public void    f(boolean connected);
 136     }
 137
 138     L0 = new L<L0>(0);
 139     L1 = new L<L1>(1);
 140     L2 = new L<L2>(2);
 141     L3 = new L<L3>(3);
 142     L4 = new L<L4>(4);
 143
 144
 145
 146     public static enum L implements XI, YI {
 147         L0(0), L1(1), L2(2), L3(3) { public int foo() { return 2; } }, L4(4);
 148
 149         public final int plane;
 150         public L(int plane) { this.plane = plane; }
 151
 152     }
 153         */
 154
 155     //public static interface L0 extends XI, YI { } public static L0 L0 = new L0() { };
 156
 157     /*
 158
 159     public static enum Xi { NONE, L0, L1, L2, L3, NW, SW, NE, SE, L4; }
 160     public static enum Yi { NONE, L0, L1, L2, L3, E,  W,  S,  N,  L4; }
 161     public static enum Wi { NONE, L0, L1, L4, L3, L2; }
 162     public static enum Zi { NONE, L0, L1, L2, L3, L4; }
 163     public static enum Ti { W,  Z,  F,  WZ, WF, ONE; }
 164     public static enum Ci { X, Y, CMux; }
 165     public static enum Fi { R, C; }
 166     public static enum Bi { R, C; }
 167     public static enum Xo { X, B; }
 168     public static enum Yo { Y, B; }
 169     public static enum Oe { ONE, H4, V4; }
 170
 171     public Cell cell(int col, int row) { return new Cell(col, row); }
 172     public final class Cell {
 173         public final int col;
 174         public final int row;
 175     */
 176         /** assumes LITTLE endian */
 177     /*
 178         protected int onehot(int val) {
 179             int ret = -1;
 180             for(int i=0; i<32; i++) {
 181                 if ((val & (1 << i)) != 0) {
 182                     if (ret != -1) throw new Error("two bits set in a one-hot encoded value");
 183                     ret = i;
 184                 }
 185             }
 186             return ret+1;
 187         }
 188         protected int bits(int octet, int bit, int count) {
 189             return AtmelDevice.this.bits.get(offset, count);
 190         }
 191
 192         public void set(Xi xi) { }
 193         public void set(Yi xi) { }
 194         public void set(Ti xi) { }
 195         public void set(Ci xi) { }
 196         public void set(Fi xi) { }
 197         public void set(Bi xi) { }
 198         public void set(Xo xo) { }
 199         public void set(Yo yo) { }
 200         public void set(Oe oe) { }
 201
 202         public Xi xi() { return Xi.values()[onehot((bits(3,3,1)<<8)|bits(5,0,8))]; }
 203         public Yi yi() { return Yi.values()[onehot((bits(2,1,1)<<8)|bits(4,0,8))]; }
 204         public Wi wi() { return Wi.values()[onehot((bits(3,0,3)<<2)|bits(3,4,2))]; }
 205         public Zi zi() { return Zi.values()[onehot((bits(2,0,1)<<4)|bits(2,2,4))]; }
 206         public Ti ti() { return null; }
 207         public Ci ci() { return null; }
 208         public Fi fi() { return null; }
 209         public Bi bi() { return null; }
 210         public Xo xo() { return Xo.values()[onehot(bits(1,6,1))]; }
 211         public Yo yo() { return Yo.values()[onehot(bits(1,7,1))]; }
 212         public Oe oe() { return Oe.values()[onehot(bits(3,6,2))]; }
 213
 214         public Sector getSector() { return sector(col - (col % 4), row - (row % 4)); }
 215         public Cell(int col, int row) {
 216             this.row = row;
 217             this.col = col;
 218         }
 219
 220
 221
 222
 223         public static enum EPR { L0, L1, L2, L3, L4 }
 224         public static enum XInputDriver extends InputDriver {
 225         public static enum YInputDriver extends InputDriver { N, S, E, W }
 226         public XInputDriver xi() { }
 227         public void         xi(XInputDriver) { }
 228         public YInputDriver yi() { }
 229         public void         yi(YInputDriver) { }
 230         public InputDriver  zi() { }
 231         public void         zi(InputDriver) { }
 232         public InputDriver  wi() { }
 233         public void         wi(InputDriver) { }
 234
 235         public byte         xlut() { }
 236         public              xlut(byte) { }
 237         public byte         ylut() { }
 238         public              ylut(byte) { }
 239
 240         public static enum CInputDriver { XL, YL, C }
 241         public static enum FDriver      { R, C }
 242
 243         public boolean      cRegistered() { }
 244
 245     }
 246     */
 247 }