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

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