seg.h

   1 #include <stdlib.h>
   2 #include <fcntl.h>
   3 #include <signal.h>
   4 #include <unistd.h>
   5 #include <string.h>
   6 #include <stdio.h>
   7
   8 #include <sys/types.h>
   9 #include <sys/gpio.h>
  10 #include <sys/ioctl.h>
  11
  12 #define UP(N)   set_pin(N, 1)
  13 #define DOWN(N) set_pin(N, 0)
  14
  15 #define DEL 100000
  16
  17 #define MEM_WR 0x40
  18 #define ADDR_AUTO 0x44
  19
  20 #define DISP_ON  0x8f
  21 #define DISP_OFF 0x80
  22 #define DISP_1  0x88
  23 #define DISP_2  0x89
  24 #define DISP_3  0x8a
  25 #define DISP_4  0x8b
  26 #define DISP_5  0x8c
  27 #define DISP_6  0x8d
  28 #define DISP_7  0x8e
  29 #define DISP_8  0x8f
  30
  31
  32 volatile int g0, g1, g2;
  33
  34 void kd() {
  35 /*      struct timespec ts, rem;
  36
  37         ts.tv_sec  = 0;
  38         ts.tv_nsec = DEL;
  39
  40         rem.tv_sec = 0;
  41         rem.tv_nsec = 0;
  42
  43         nanosleep(&ts, &rem);
  44         */
  45 }
  46
  47 int name2dev(char *s) {
  48         if (! strncmp(s, "ser", GPIOPINMAXNAME))
  49                 return g1;
  50         else if (! strncmp(s, "oe", GPIOPINMAXNAME))
  51                 return g0;
  52         else if (! strncmp(s, "rclk", GPIOPINMAXNAME))
  53                 return g1;
  54         else if (! strncmp(s, "srclk", GPIOPINMAXNAME))
  55                 return g2;
  56         else if (! strncmp(s, "srclr", GPIOPINMAXNAME))
  57                 return g1;
  58         else if (! strncmp(s, "dio", GPIOPINMAXNAME))
  59                 return g2;
  60         else if (! strncmp(s, "clk", GPIOPINMAXNAME))
  61                 return g2;
  62         else {
  63                 printf("no gpio pin w/ name %s, exiting..\n", s);
  64                 exit(2);
  65         }
  66 }
  67
  68 void inth(int f) {
  69         close(g0);
  70         close(g1);
  71         close(g2);
  72
  73         exit(9);
  74 }
  75
  76 void ack_wait() {
  77         struct gpio_pin_set p;
  78         struct gpio_pin_op o;
  79         int read = 0;
  80
  81         p.gp_pin = 6;
  82         o.gp_pin = 6;
  83         p.gp_flags = GPIO_PIN_INPUT | GPIO_PIN_PULLDOWN;
  84         o.gp_value = 0;
  85
  86         ioctl(name2dev("dio"), GPIOPINWRITE, &o);
  87         ioctl(name2dev("dio"), GPIOPINSET, &p);
  88
  89         while(!read) {
  90                 printf("waiting..\n");
  91                 ioctl(name2dev("dio"), GPIOPINREAD, &o);
  92                 read = o.gp_value;
  93         }
  94
  95         p.gp_flags = GPIO_PIN_OUTPUT;
  96         ioctl(name2dev("dio"), GPIOPINREAD, &o);
  97 }
  98
  99 void set_pin(char *name, int state) {
 100         struct gpio_pin_op op;
 101
 102         strlcpy(op.gp_name, name, GPIOPINMAXNAME);
 103         op.gp_value = state;
 104
 105         ioctl(name2dev(name), GPIOPINWRITE, &op);
 106 }
 107
 108 void config_pins() {
 109         struct gpio_pin_set *ser, *oe, *rclk, *srclk, *srclr, *dio, *clk;
 110
 111         /* ??? XXX wtf */
 112         system("gpioctl gpio2 6 set out clk");
 113         system("gpioctl gpio2 8 set out dio");
 114
 115         ser   = calloc(1, sizeof(struct gpio_pin_set));
 116         oe    = calloc(1, sizeof(struct gpio_pin_set));
 117         rclk  = calloc(1, sizeof(struct gpio_pin_set));
 118         srclk = calloc(1, sizeof(struct gpio_pin_set));
 119         srclr = calloc(1, sizeof(struct gpio_pin_set));
 120         dio   = calloc(1, sizeof(struct gpio_pin_set));
 121         clk   = calloc(1, sizeof(struct gpio_pin_set));
 122
 123         ser->gp_pin = 12;
 124         ser->gp_flags = GPIO_PIN_OUTPUT;
 125         strlcpy(ser->gp_name2, "ser", GPIOPINMAXNAME);
 126
 127         oe->gp_pin = 26;
 128         oe->gp_flags = GPIO_PIN_OUTPUT;
 129         strlcpy(oe->gp_name2, "oe", GPIOPINMAXNAME);
 130
 131         rclk->gp_pin = 14;
 132         rclk->gp_flags = GPIO_PIN_OUTPUT;
 133         strlcpy(rclk->gp_name2, "rclk", GPIOPINMAXNAME);
 134
 135         srclk->gp_pin = 1;
 136         srclk->gp_flags = GPIO_PIN_OUTPUT;
 137         strlcpy(srclk->gp_name2, "srclk", GPIOPINMAXNAME);
 138
 139         srclr->gp_pin = 31;
 140         srclr->gp_flags = GPIO_PIN_OUTPUT;
 141         strlcpy(srclr->gp_name2, "srclr", GPIOPINMAXNAME);
 142
 143         dio->gp_pin = 8;
 144         dio->gp_flags = GPIO_PIN_OUTPUT;
 145         strlcpy(dio->gp_name2, "dio", GPIOPINMAXNAME);
 146
 147         clk->gp_pin = 6;
 148         clk->gp_flags = GPIO_PIN_OUTPUT;
 149         strlcpy(clk->gp_name2, "clk", GPIOPINMAXNAME);
 150
 151         ioctl(name2dev("ser"), GPIOPINSET, ser);
 152         ioctl(name2dev("oe"), GPIOPINSET, oe);
 153         ioctl(name2dev("rclk"), GPIOPINSET, rclk);
 154         ioctl(name2dev("srclk"), GPIOPINSET, srclk);
 155         ioctl(name2dev("srclr"), GPIOPINSET, srclr);
 156         ioctl(name2dev("dio"), GPIOPINSET, dio);
 157         ioctl(name2dev("clk"), GPIOPINSET, clk);
 158
 159         free(ser);
 160         free(oe);
 161         free(rclk);
 162         free(srclk);
 163         free(srclr);
 164         free(dio);
 165         free(clk);
 166 }
 167
 168 void pincnt() {
 169         g0 = open("/dev/gpio0", O_RDWR);
 170         g1 = open("/dev/gpio1", O_RDWR);
 171         g2 = open("/dev/gpio2", O_RDWR);
 172
 173         struct gpio_info *inf0, *inf1, *inf2;
 174         inf0 = calloc(1, sizeof(struct gpio_info));
 175         inf1 = calloc(1, sizeof(struct gpio_info));
 176         inf2 = calloc(1, sizeof(struct gpio_info));
 177
 178         ioctl(g0, GPIOINFO, inf0);
 179         ioctl(g1, GPIOINFO, inf1);
 180         ioctl(g2, GPIOINFO, inf2);
 181
 182         printf("gpio0: %d\ngpio1: %d\ngpio2: %d\n", inf0->gpio_npins, inf1->gpio_npins, inf2->gpio_npins);
 183
 184         free(inf0);
 185         free(inf1);
 186         free(inf2);
 187 }
 188
 189 void start() {
 190         DOWN("dio");
 191         kd();
 192 }
 193
 194 void stop() {
 195         DOWN("dio");
 196         kd();
 197         UP("clk");
 198         kd();
 199         UP("dio");
 200         kd();
 201 }
 202
 203 void byte(uint8_t b) {
 204         for(int i = 0; i < 8; i++) {
 205                 DOWN("clk");
 206                 kd();
 207                 (b & 0x1) ? UP("dio") : DOWN("dio");
 208                 kd();
 209                 UP("clk");
 210                 kd();
 211                 b >>= 1;
 212         }
 213
 214         DOWN("clk");
 215         UP("dio");
 216         kd();
 217         UP("clk");
 218         kd();
 219         DOWN("dio");
 220         kd();
 221         DOWN("clk");
 222         kd();
 223 }
 224
 225 void blink(int c, int ms) {
 226         for(int i = 0; i < c; i++) {
 227                 byte(DISP_ON);
 228                 kd();
 229                 byte(DISP_OFF);
 230                 kd();
 231         }
 232 }
 233
 234