[bort-panel.git] / seg.h

#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <time.h>

#include <sys/types.h>
#include <sys/gpio.h>
#include <sys/ioctl.h>
#include <sys/time.h>

#define UP(N)   set_pin(N, 1)
#define DOWN(N) set_pin(N, 0)

#define DEL 100000

#define MEM_WR 0x40
#define ADDR_AUTO 0x44

#define DISP_ON  0x8f
#define DISP_OFF 0x80
#define DISP_1	0x88
#define DISP_2	0x89
#define DISP_3	0x8a
#define DISP_4	0x8b
#define DISP_5	0x8c
#define DISP_6	0x8d
#define DISP_7	0x8e
#define DISP_8	0x8f

volatile int g0, g1, g2;

const uint8_t d2seg[] = {
	  0x3F
	, 0x06
	, 0x5B
	, 0x4F
	, 0x66
	, 0x6D
	, 0x7D
	, 0x07
	, 0x7F
	, 0x6F
	, 0x77
	, 0x7C
	, 0x39
	, 0x5E
	, 0x79
	, 0x71
};

uint8_t dig(uint8_t d) {
	return d2seg[d];
}

/*void timer(long usec) {
    sigset_t sigs;
    int s;

    sigemptyset(&sigs);
    sigaddset(&sigs, SIGALRM);

    ualarm(usec, 0);
    sigwait(&sigs, &s);
}*/

/*void timer(long usec) {
	struct timespec t;
	t.tv_nsec = usec;
	t.tv_sec = 0;

	nanosleep(&t, NULL);
}*/

void kd() {

	asm("movs r0, #0");

	for(int i = 0; i < 10; i++) {
		asm("movs  r0, #10\n\t"  
		"1: subs  r0, r0, #1\n\t"
		"bne   1b");
	}

/*	volatile int t = 0;

	while(t != 80000)
	    t++; */
/*	struct timespec ts, rem;

	ts.tv_sec  = 0;
	ts.tv_nsec = DEL;

	rem.tv_sec = 0;
	rem.tv_nsec = 0;

	nanosleep(&ts, &rem); */
}

int name2dev(char *s) {
	if (! strncmp(s, "ser", GPIOPINMAXNAME))
		return g1;
	else if (! strncmp(s, "oe", GPIOPINMAXNAME))
		return g0;
	else if (! strncmp(s, "rclk", GPIOPINMAXNAME))
		return g1;
	else if (! strncmp(s, "srclk", GPIOPINMAXNAME))
		return g2;
	else if (! strncmp(s, "srclr", GPIOPINMAXNAME))
		return g1;
	else if (! strncmp(s, "dio", GPIOPINMAXNAME))
		return g2;
	else if (! strncmp(s, "clk", GPIOPINMAXNAME))
		return g2;
	else if (! strncmp(s, "ser2", GPIOPINMAXNAME))
	    	return g1;
	else if (! strncmp(s, "clk-sr", GPIOPINMAXNAME))
	    	return g1;
	else if (! strncmp(s, "shld", GPIOPINMAXNAME))
	    	return g1;
	else if (! strncmp(s, "clr", GPIOPINMAXNAME))
	    	return g0;


	else {
		printf("no gpio pin w/ name %s, exiting..\n", s);
		exit(2);
	}
}

void inth(int f) {
	close(g0);
	close(g1);
	close(g2);

	exit(9);
}

void ack_wait() {
	struct gpio_pin_set p;
	struct gpio_pin_op o;
	int read = 0;

	p.gp_pin = 6;
	o.gp_pin = 6;
	p.gp_flags = GPIO_PIN_INPUT | GPIO_PIN_PULLDOWN;
	o.gp_value = 0;

	ioctl(name2dev("dio"), GPIOPINWRITE, &o);
	ioctl(name2dev("dio"), GPIOPINSET, &p);

	while(!read) {
		printf("waiting..\n");
		ioctl(name2dev("dio"), GPIOPINREAD, &o);
		read = o.gp_value;
	}

	p.gp_flags = GPIO_PIN_OUTPUT;
	ioctl(name2dev("dio"), GPIOPINREAD, &o);
}

void set_pin(char *name, int state) {
	struct gpio_pin_op op;

	strlcpy(op.gp_name, name, GPIOPINMAXNAME);
	op.gp_value = state;

	ioctl(name2dev(name), GPIOPINWRITE, &op);
}

void config_pins() {
	struct gpio_pin_set *ser, *oe, *rclk, *srclk, *srclr, *dio, *clk;

	/* ??? XXX wtf */
	system("gpioctl gpio2 6 set out clk");
	system("gpioctl gpio2 8 set out dio");

	ser   = calloc(1, sizeof(struct gpio_pin_set));
	oe    = calloc(1, sizeof(struct gpio_pin_set));
	rclk  = calloc(1, sizeof(struct gpio_pin_set));
	srclk = calloc(1, sizeof(struct gpio_pin_set));
	srclr = calloc(1, sizeof(struct gpio_pin_set));
	dio   = calloc(1, sizeof(struct gpio_pin_set));
	clk   = calloc(1, sizeof(struct gpio_pin_set));

	ser->gp_pin = 12;
	ser->gp_flags = GPIO_PIN_OUTPUT;
	strlcpy(ser->gp_name2, "ser", GPIOPINMAXNAME);

	oe->gp_pin = 26;
	oe->gp_flags = GPIO_PIN_OUTPUT;
	strlcpy(oe->gp_name2, "oe", GPIOPINMAXNAME);

	rclk->gp_pin = 14;
	rclk->gp_flags = GPIO_PIN_OUTPUT;
	strlcpy(rclk->gp_name2, "rclk", GPIOPINMAXNAME);

	srclk->gp_pin = 1;
	srclk->gp_flags = GPIO_PIN_OUTPUT;
	strlcpy(srclk->gp_name2, "srclk", GPIOPINMAXNAME);

	srclr->gp_pin = 31;
	srclr->gp_flags = GPIO_PIN_OUTPUT;
	strlcpy(srclr->gp_name2, "srclr", GPIOPINMAXNAME);

	dio->gp_pin = 8;
	dio->gp_flags = GPIO_PIN_OUTPUT;
	strlcpy(dio->gp_name2, "dio", GPIOPINMAXNAME);

	clk->gp_pin = 6;
	clk->gp_flags = GPIO_PIN_OUTPUT;
	strlcpy(clk->gp_name2, "clk", GPIOPINMAXNAME);

	ioctl(name2dev("ser"), GPIOPINSET, ser);
	ioctl(name2dev("oe"), GPIOPINSET, oe);
	ioctl(name2dev("rclk"), GPIOPINSET, rclk);
	ioctl(name2dev("srclk"), GPIOPINSET, srclk);
	ioctl(name2dev("srclr"), GPIOPINSET, srclr);
	ioctl(name2dev("dio"), GPIOPINSET, dio);
	ioctl(name2dev("clk"), GPIOPINSET, clk);
	
	free(ser);
	free(oe);
	free(rclk);
	free(srclk);
	free(srclr);
	free(dio);
	free(clk);
}

void pincnt() {
	g0 = open("/dev/gpio0", O_RDWR);
	g1 = open("/dev/gpio1", O_RDWR);
	g2 = open("/dev/gpio2", O_RDWR);

	struct gpio_info *inf0, *inf1, *inf2;
	inf0 = calloc(1, sizeof(struct gpio_info));
	inf1 = calloc(1, sizeof(struct gpio_info));
	inf2 = calloc(1, sizeof(struct gpio_info));
	
	ioctl(g0, GPIOINFO, inf0);
	ioctl(g1, GPIOINFO, inf1);
	ioctl(g2, GPIOINFO, inf2);

	printf("gpio0: %d\ngpio1: %d\ngpio2: %d\n", inf0->gpio_npins, inf1->gpio_npins, inf2->gpio_npins);

	free(inf0);
	free(inf1);
	free(inf2);
}

void start() {
	DOWN("dio");
	kd();
}

void stop() {
	DOWN("dio");
	kd();
	UP("clk");
	kd();
	UP("dio");
	kd();
}

void byte(uint8_t b) {
	for(int i = 0; i < 8; i++) {
		DOWN("clk");
		kd();
		(b & 0x1) ? UP("dio") : DOWN("dio");
		kd();
		UP("clk");
		kd();
		b >>= 1;
	}

	DOWN("clk");
	UP("dio");
	kd();
	UP("clk");
	kd();
	DOWN("dio");
	kd();
	DOWN("clk");
	kd();
}

void blink(int c, int ms) {
	for(int i = 0; i < c; i++) {
		byte(DISP_ON);
		kd();
		byte(DISP_OFF);
		kd();
	}
}
Commit	Line	Data
9883c3e4 IS	1	#include <stdlib.h>
	2	#include <fcntl.h>
	3	#include <signal.h>
	4	#include <unistd.h>
	5	#include <string.h>
	6	#include <stdio.h>
3bacb654	7	#include <time.h>
9883c3e4 IS	8
	9	#include <sys/types.h>
	10	#include <sys/gpio.h>
	11	#include <sys/ioctl.h>
3bacb654	12	#include <sys/time.h>
9883c3e4 IS	13
	14	#define UP(N) set_pin(N, 1)
	15	#define DOWN(N) set_pin(N, 0)
	16
	17	#define DEL 100000
	18
	19	#define MEM_WR 0x40
	20	#define ADDR_AUTO 0x44
	21
	22	#define DISP_ON 0x8f
	23	#define DISP_OFF 0x80
	24	#define DISP_1 0x88
	25	#define DISP_2 0x89
	26	#define DISP_3 0x8a
	27	#define DISP_4 0x8b
	28	#define DISP_5 0x8c
	29	#define DISP_6 0x8d
	30	#define DISP_7 0x8e
	31	#define DISP_8 0x8f
	32
9883c3e4 IS	33	volatile int g0, g1, g2;
9883c3e4 IS	34
3bacb654 IS	35	const uint8_t d2seg[] = {
	36	0x3F
	37	, 0x06
	38	, 0x5B
	39	, 0x4F
	40	, 0x66
	41	, 0x6D
	42	, 0x7D
	43	, 0x07
	44	, 0x7F
	45	, 0x6F
	46	, 0x77
	47	, 0x7C
	48	, 0x39
	49	, 0x5E
	50	, 0x79
	51	, 0x71
	52	};
	53
	54	uint8_t dig(uint8_t d) {
	55	return d2seg[d];
	56	}
	57
	58	/*void timer(long usec) {
	59	sigset_t sigs;
	60	int s;
	61
	62	sigemptyset(&sigs);
	63	sigaddset(&sigs, SIGALRM);
	64
	65	ualarm(usec, 0);
	66	sigwait(&sigs, &s);
	67	}*/
	68
	69	/*void timer(long usec) {
	70	struct timespec t;
	71	t.tv_nsec = usec;
	72	t.tv_sec = 0;
	73
	74	nanosleep(&t, NULL);
	75	}*/
	76
9883c3e4	77	void kd() {
3bacb654 IS	78
	79	asm("movs r0, #0");
	80
	81	for(int i = 0; i < 10; i++) {
	82	asm("movs r0, #10\n\t"
	83	"1: subs r0, r0, #1\n\t"
	84	"bne 1b");
	85	}
	86
	87	/* volatile int t = 0;
	88
	89	while(t != 80000)
	90	t++; */
9883c3e4 IS	91	/* struct timespec ts, rem;
	92
	93	ts.tv_sec = 0;
	94	ts.tv_nsec = DEL;
	95
	96	rem.tv_sec = 0;
	97	rem.tv_nsec = 0;
	98
3bacb654	99	nanosleep(&ts, &rem); */
9883c3e4 IS	100	}
	101
	102	int name2dev(char *s) {
	103	if (! strncmp(s, "ser", GPIOPINMAXNAME))
	104	return g1;
	105	else if (! strncmp(s, "oe", GPIOPINMAXNAME))
	106	return g0;
	107	else if (! strncmp(s, "rclk", GPIOPINMAXNAME))
	108	return g1;
	109	else if (! strncmp(s, "srclk", GPIOPINMAXNAME))
	110	return g2;
	111	else if (! strncmp(s, "srclr", GPIOPINMAXNAME))
	112	return g1;
	113	else if (! strncmp(s, "dio", GPIOPINMAXNAME))
	114	return g2;
	115	else if (! strncmp(s, "clk", GPIOPINMAXNAME))
	116	return g2;
3bacb654 IS	117	else if (! strncmp(s, "ser2", GPIOPINMAXNAME))
	118	return g1;
	119	else if (! strncmp(s, "clk-sr", GPIOPINMAXNAME))
	120	return g1;
	121	else if (! strncmp(s, "shld", GPIOPINMAXNAME))
	122	return g1;
	123	else if (! strncmp(s, "clr", GPIOPINMAXNAME))
	124	return g0;
	125
	126
9883c3e4 IS	127	else {
	128	printf("no gpio pin w/ name %s, exiting..\n", s);
	129	exit(2);
	130	}
	131	}
	132
	133	void inth(int f) {
	134	close(g0);
	135	close(g1);
	136	close(g2);
	137
	138	exit(9);
	139	}
	140
	141	void ack_wait() {
	142	struct gpio_pin_set p;
	143	struct gpio_pin_op o;
	144	int read = 0;
	145
	146	p.gp_pin = 6;
	147	o.gp_pin = 6;
	148	p.gp_flags = GPIO_PIN_INPUT \| GPIO_PIN_PULLDOWN;
	149	o.gp_value = 0;
	150
	151	ioctl(name2dev("dio"), GPIOPINWRITE, &o);
	152	ioctl(name2dev("dio"), GPIOPINSET, &p);
	153
	154	while(!read) {
	155	printf("waiting..\n");
	156	ioctl(name2dev("dio"), GPIOPINREAD, &o);
	157	read = o.gp_value;
	158	}
	159
	160	p.gp_flags = GPIO_PIN_OUTPUT;
	161	ioctl(name2dev("dio"), GPIOPINREAD, &o);
	162	}
	163
	164	void set_pin(char *name, int state) {
	165	struct gpio_pin_op op;
	166
	167	strlcpy(op.gp_name, name, GPIOPINMAXNAME);
	168	op.gp_value = state;
	169
	170	ioctl(name2dev(name), GPIOPINWRITE, &op);
	171	}
	172
	173	void config_pins() {
	174	struct gpio_pin_set ser, oe, rclk, srclk, srclr, dio, *clk;
	175
9f65bf39 IS	176	/* ??? XXX wtf */
	177	system("gpioctl gpio2 6 set out clk");
	178	system("gpioctl gpio2 8 set out dio");
	179
9883c3e4 IS	180	ser = calloc(1, sizeof(struct gpio_pin_set));
	181	oe = calloc(1, sizeof(struct gpio_pin_set));
	182	rclk = calloc(1, sizeof(struct gpio_pin_set));
	183	srclk = calloc(1, sizeof(struct gpio_pin_set));
	184	srclr = calloc(1, sizeof(struct gpio_pin_set));
	185	dio = calloc(1, sizeof(struct gpio_pin_set));
	186	clk = calloc(1, sizeof(struct gpio_pin_set));
	187
	188	ser->gp_pin = 12;
	189	ser->gp_flags = GPIO_PIN_OUTPUT;
	190	strlcpy(ser->gp_name2, "ser", GPIOPINMAXNAME);
	191
	192	oe->gp_pin = 26;
	193	oe->gp_flags = GPIO_PIN_OUTPUT;
	194	strlcpy(oe->gp_name2, "oe", GPIOPINMAXNAME);
	195
	196	rclk->gp_pin = 14;
	197	rclk->gp_flags = GPIO_PIN_OUTPUT;
	198	strlcpy(rclk->gp_name2, "rclk", GPIOPINMAXNAME);
	199
	200	srclk->gp_pin = 1;
	201	srclk->gp_flags = GPIO_PIN_OUTPUT;
	202	strlcpy(srclk->gp_name2, "srclk", GPIOPINMAXNAME);
	203
	204	srclr->gp_pin = 31;
	205	srclr->gp_flags = GPIO_PIN_OUTPUT;
	206	strlcpy(srclr->gp_name2, "srclr", GPIOPINMAXNAME);
	207
	208	dio->gp_pin = 8;
	209	dio->gp_flags = GPIO_PIN_OUTPUT;
	210	strlcpy(dio->gp_name2, "dio", GPIOPINMAXNAME);
	211
	212	clk->gp_pin = 6;
	213	clk->gp_flags = GPIO_PIN_OUTPUT;
	214	strlcpy(clk->gp_name2, "clk", GPIOPINMAXNAME);
	215
	216	ioctl(name2dev("ser"), GPIOPINSET, ser);
	217	ioctl(name2dev("oe"), GPIOPINSET, oe);
	218	ioctl(name2dev("rclk"), GPIOPINSET, rclk);
	219	ioctl(name2dev("srclk"), GPIOPINSET, srclk);
	220	ioctl(name2dev("srclr"), GPIOPINSET, srclr);
	221	ioctl(name2dev("dio"), GPIOPINSET, dio);
	222	ioctl(name2dev("clk"), GPIOPINSET, clk);
	223
	224	free(ser);
	225	free(oe);
	226	free(rclk);
	227	free(srclk);
	228	free(srclr);
	229	free(dio);
	230	free(clk);
	231	}
	232
	233	void pincnt() {
	234	g0 = open("/dev/gpio0", O_RDWR);
	235	g1 = open("/dev/gpio1", O_RDWR);
	236	g2 = open("/dev/gpio2", O_RDWR);
	237
	238	struct gpio_info inf0, inf1, *inf2;
	239	inf0 = calloc(1, sizeof(struct gpio_info));
	240	inf1 = calloc(1, sizeof(struct gpio_info));
	241	inf2 = calloc(1, sizeof(struct gpio_info));
	242
	243	ioctl(g0, GPIOINFO, inf0);
244	ioctl(g1, GPIOINFO, inf1);
245	ioctl(g2, GPIOINFO, inf2);
246
247	printf("gpio0: %d\ngpio1: %d\ngpio2: %d\n", inf0->gpio_npins, inf1->gpio_npins, inf2->gpio_npins);
248
249	free(inf0);
250	free(inf1);
251	free(inf2);
252	}
253
254	void start() {
255	DOWN("dio");
256	kd();
257	}
258
259	void stop() {
260	DOWN("dio");
261	kd();
262	UP("clk");
263	kd();
264	UP("dio");
265	kd();
266	}
267
268	void byte(uint8_t b) {
269	for(int i = 0; i < 8; i++) {
270	DOWN("clk");
271	kd();
272	(b & 0x1) ? UP("dio") : DOWN("dio");
273	kd();
274	UP("clk");
275	kd();
276	b >>= 1;
277	}
278
279	DOWN("clk");
280	UP("dio");
281	kd();
282	UP("clk");
283	kd();
284	DOWN("dio");
285	kd();
286	DOWN("clk");
287	kd();
288	}
289
290	void blink(int c, int ms) {
291	for(int i = 0; i < c; i++) {
292	byte(DISP_ON);
293	kd();
294	byte(DISP_OFF);
295	kd();
296	}
297	}
298