URL https://opencores.org/ocsvn/igor/igor/trunk

Subversion Repositories igor

[/] [igor/] [trunk/] [avr/] [eth-test/] [testbus.c] - Blame information for rev 4

Details | Compare with Previous | View Log


#include <pthread.h>
#include <unistd.h>
 
#include <stdlib.h>
#include <stdio.h>
 
#include "testbus.h"
#include "dispatch.h"
#include "encdec.h"
#include "device.h"
 
void * fpga_intr(void *);
 
#define MAXSLEEP 4
 
/* Our "interrupt" thread requireing reads and writes. */
pthread_t intrthr;
 
void init_fpgabus(void)
{
        srandom(time(0));
        printf("Init fpga\n");
        pthread_create(&intrthr, NULL, fpga_intr, NULL);
}
 
uint32_t writedata;
int wait_read = 0;
int wait_write = 0;
 
void *
fpga_intr(void *arg)
{
        uint32_t lval, data;
        uint32_t dataaddr;
        long rval;
        uint8_t addr;
        int error;
 
        /* XXX: for now. */
        addr = 0;
        dataaddr = 0;
 
        printf("Starting thread\n");
 
        while (1) {
                rval = (random() % MAXSLEEP) + 1;
                printf("Sleeping for %ld micro-seconds\n", rval);
                sleep(rval);
                rval = (random() % 9);
 
                // Silly way of doing it, but i'm lazy
                switch (rval) {
                case 0:
                        // Do a object read
                        /* Set address. */
                        addr = ADDR_L;
                        wait_write = 1;
                        error = dispatch_request_write(addr, dataaddr);
                        if (error) {
                                printf("Have to wait for request\n");
                                while (wait_write);
                        } else
                                printf("Successful setting address\n");
 
                        /* Doing a read from curdev. */
                        addr = OBJECT;
                        printf("Requesting a read from a device.\n");
                        wait_read = 1;
                        error = dispatch_request_read(addr, &data);
                        if (error) {
                                printf("Have to wait for request\n");
                                while (wait_read);
                        } else
                                printf("Got value 0x%x from dispatch\n", data);
                        dataaddr++;
                        break;
                case 1:
                        // Do a object write
                        addr = ADDR_L;
                        wait_write = 1;
                        error = dispatch_request_write(addr, dataaddr);
                        if (error) {
                                printf("Have to wait for request\n");
                                while (wait_write);
                        } else
                                printf("Successful setting address\n");
 
                        lval = (random() % 26) + 'a';
                        printf("Requesting a write to a device.\n");
                        wait_write = 1;
                        writedata = lval;
                        error = dispatch_request_write(addr, lval);
                        if (error) {
                                printf("Unable to perform the write at this "
                                    "time, waiting\n");
                                while (wait_write);
                        }
                        else
                                printf("Wrote value 0x%x\n", lval);
                        break;
                case 2:
                        // Request to read number of devices.
                        addr = DEVICES;
                        printf("Requesting number of devices\n");
                        error = dispatch_request_read(addr, &data);
                        if (error)
                                printf("Got error response\n");
                        else
                                printf("Number of devices: 0x%x\n", data);
                        break;
                case 3:
                        // Request to read current device
                        addr = CURDEV;
                        printf("Requesting curdev\n");
                        error = dispatch_request_read(addr, &data);
                        if (error)
                                printf("Got error response on curdev\n");
                        else
                                printf("Curdev: 0x%x\n", data);
                        break;
                case 4:
                        // Request to know what device performed last interrupt
                        addr = INTRDEV;
                        printf("Requesting interrupt device\n");
                        error = dispatch_request_read(addr, &data);
                        if (error)
                                printf("Got error response on INTRDEV\n");
                        else
                                printf("INTRDEV: 0x%x\n", data);
                        break;
                case 5:
                        // Per device stuff reading
                        addr = SIZE_L;
                        printf("Requesting device size\n");
                        error = dispatch_request_read(addr, &data);
                        if (error)
                                printf("Got error response on SIZE_L\n");
                        else
                                printf("SIZE_L: 0x%x\n", data);
                        break;
                case 6:
                        addr = STATUS;
                        printf("Requesting STATUS\n");
                        error = dispatch_request_read(addr, &data);
                        if (error)
                                printf("Got error response on STATUS\n");
                        else
                                printf("STATUS: 0x%x\n", data);
                        break;
                case 7:
                        addr = IRQENABLE;
                        printf("Requesting IRQENABLE\n");
                        error = dispatch_request_read(addr, &data);
                        if (error)
                                printf("Got error response on IRQENABLE\n");
                        else
                                printf("IRQENABLE: 0x%x\n", data);
                        break;
                // Write stuff
                case 8:
                        addr = IRQENABLE;
                        data = 0x10000001;
                        printf("Requesting IRQENABLE write\n");
                        error = dispatch_request_write(addr, data);
                        if (error)
                                printf("Got error response on IRQENABLE\n");
                        else
                                printf("IRQENABLE set!");
                        break;
                }
        }
}
 
void fpga_finish_read(uint32_t data)
{
        printf("Finished a read, value: 0x%x\n", data);
        wait_read = 0;
}
 
uint32_t fpga_delayed_write(void)
{
        wait_write = 0;
        printf("Finished a write, value 0x%x returned\n", writedata);
        return (writedata);
}

Line No.	Rev	Author	Line
1	4	atypic	`#include <pthread.h>`
2			`#include <unistd.h>`
3
4			`#include <stdlib.h>`
5			`#include <stdio.h>`
6
7			`#include "testbus.h"`
8			`#include "dispatch.h"`
9			`#include "encdec.h"`
10			`#include "device.h"`
11
12			`void * fpga_intr(void *);`
13
14			`#define MAXSLEEP 4`
15
16			`/* Our "interrupt" thread requireing reads and writes. */`
17			`pthread_t intrthr;`
18
19			`void init_fpgabus(void)`
20			`{`
21			`srandom(time(0));`
22			`printf("Init fpga\n");`
23			`pthread_create(&intrthr, NULL, fpga_intr, NULL);`
24			`}`
25
26			`uint32_t writedata;`
27			`int wait_read = 0;`
28			`int wait_write = 0;`
29
30			`void *`
31			`fpga_intr(void *arg)`
32			`{`
33			`uint32_t lval, data;`
34			`uint32_t dataaddr;`
35			`long rval;`
36			`uint8_t addr;`
37			`int error;`
38
39			`/* XXX: for now. */`
40			`addr = 0;`
41			`dataaddr = 0;`
42
43			`printf("Starting thread\n");`
44
45			`while (1) {`
46			`rval = (random() % MAXSLEEP) + 1;`
47			`printf("Sleeping for %ld micro-seconds\n", rval);`
48			`sleep(rval);`
49			`rval = (random() % 9);`
50
51			`// Silly way of doing it, but i'm lazy`
52			`switch (rval) {`
53			`case 0:`
54			`// Do a object read`
55			`/* Set address. */`
56			`addr = ADDR_L;`
57			`wait_write = 1;`
58			`error = dispatch_request_write(addr, dataaddr);`
59			`if (error) {`
60			`printf("Have to wait for request\n");`
61			`while (wait_write);`
62			`} else`
63			`printf("Successful setting address\n");`
64
65			`/* Doing a read from curdev. */`
66			`addr = OBJECT;`
67			`printf("Requesting a read from a device.\n");`
68			`wait_read = 1;`
69			`error = dispatch_request_read(addr, &data);`
70			`if (error) {`
71			`printf("Have to wait for request\n");`
72			`while (wait_read);`
73			`} else`
74			`printf("Got value 0x%x from dispatch\n", data);`
75			`dataaddr++;`
76			`break;`
77			`case 1:`
78			`// Do a object write`
79			`addr = ADDR_L;`
80			`wait_write = 1;`
81			`error = dispatch_request_write(addr, dataaddr);`
82			`if (error) {`
83			`printf("Have to wait for request\n");`
84			`while (wait_write);`
85			`} else`
86			`printf("Successful setting address\n");`
87
88			`lval = (random() % 26) + 'a';`
89			`printf("Requesting a write to a device.\n");`
90			`wait_write = 1;`
91			`writedata = lval;`
92			`error = dispatch_request_write(addr, lval);`
93			`if (error) {`
94			`printf("Unable to perform the write at this "`
95			`"time, waiting\n");`
96			`while (wait_write);`
97			`}`
98			`else`
99			`printf("Wrote value 0x%x\n", lval);`
100			`break;`
101			`case 2:`
102			`// Request to read number of devices.`
103			`addr = DEVICES;`
104			`printf("Requesting number of devices\n");`
105			`error = dispatch_request_read(addr, &data);`
106			`if (error)`
107			`printf("Got error response\n");`
108			`else`
109			`printf("Number of devices: 0x%x\n", data);`
110			`break;`
111			`case 3:`
112			`// Request to read current device`
113			`addr = CURDEV;`
114			`printf("Requesting curdev\n");`
115			`error = dispatch_request_read(addr, &data);`
116			`if (error)`
117			`printf("Got error response on curdev\n");`
118			`else`
119			`printf("Curdev: 0x%x\n", data);`
120			`break;`
121			`case 4:`
122			`// Request to know what device performed last interrupt`
123			`addr = INTRDEV;`
124			`printf("Requesting interrupt device\n");`
125			`error = dispatch_request_read(addr, &data);`
126			`if (error)`
127			`printf("Got error response on INTRDEV\n");`
128			`else`
129			`printf("INTRDEV: 0x%x\n", data);`
130			`break;`
131			`case 5:`
132			`// Per device stuff reading`
133			`addr = SIZE_L;`
134			`printf("Requesting device size\n");`
135			`error = dispatch_request_read(addr, &data);`
136			`if (error)`
137			`printf("Got error response on SIZE_L\n");`
138			`else`
139			`printf("SIZE_L: 0x%x\n", data);`
140			`break;`
141			`case 6:`
142			`addr = STATUS;`
143			`printf("Requesting STATUS\n");`
144			`error = dispatch_request_read(addr, &data);`
145			`if (error)`
146			`printf("Got error response on STATUS\n");`
147			`else`
148			`printf("STATUS: 0x%x\n", data);`
149			`break;`
150			`case 7:`
151			`addr = IRQENABLE;`
152			`printf("Requesting IRQENABLE\n");`
153			`error = dispatch_request_read(addr, &data);`
154			`if (error)`
155			`printf("Got error response on IRQENABLE\n");`
156			`else`
157			`printf("IRQENABLE: 0x%x\n", data);`
158			`break;`
159			`// Write stuff`
160			`case 8:`
161			`addr = IRQENABLE;`
162			`data = 0x10000001;`
163			`printf("Requesting IRQENABLE write\n");`
164			`error = dispatch_request_write(addr, data);`
165			`if (error)`
166			`printf("Got error response on IRQENABLE\n");`
167			`else`
168			`printf("IRQENABLE set!");`
169			`break;`
170			`}`
171			`}`
172			`}`
173
174			`void fpga_finish_read(uint32_t data)`
175			`{`
176			`printf("Finished a read, value: 0x%x\n", data);`
177			`wait_read = 0;`
178			`}`
179
180			`uint32_t fpga_delayed_write(void)`
181			`{`
182			`wait_write = 0;`
183			`printf("Finished a write, value 0x%x returned\n", writedata);`
184			`return (writedata);`
185			`}`

Browse

Tools

Subversion Repositories igor

[/] [igor/] [trunk/] [avr/] [eth-test/] [testbus.c] - Blame information for rev 4