]> git.pld-linux.org Git - packages/qemu.git/blame - qemu-parallel.patch
projects / packages / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- allow building without up
[packages/qemu.git] / qemu-parallel.patch
CommitLineData
94ccff7d 1diff --exclude=CVS -upr qemu/hw/parallel.c qemu-sandbox/hw/parallel.c
2--- qemu/hw/parallel.c 2005-01-23 13:42:59.000000000 -0700
3+++ qemu-sandbox/hw/parallel.c 2005-03-12 19:00:37.000000000 -0700
4@@ -22,6 +22,9 @@
5 * THE SOFTWARE.
6 */
7 #include "vl.h"
8+#include <sys/ioctl.h>
9+#include <linux/parport.h>
10+#include <linux/ppdev.h>
11
12 //#define DEBUG_PARALLEL
13
14@@ -43,15 +46,6 @@
15 #define PARA_CTR_AUTOLF 0x02 /* Auto linefeed complement */
16 #define PARA_CTR_STROBE 0x01 /* Strobe complement */
17
18-struct ParallelState {
19- uint8_t data;
20- uint8_t status; /* read only register */
21- uint8_t control;
22- int irq;
23- int irq_pending;
24- CharDriverState *chr;
25-};
26-
27 static void parallel_update_irq(ParallelState *s)
28 {
29 if (s->irq_pending)
30@@ -70,29 +64,29 @@ static void parallel_ioport_write(void *
31 #endif
32 switch(addr) {
33 case 0:
34- s->data = val;
35+ qemu_pp_write_data(s, (uint8_t)val);
36 parallel_update_irq(s);
37 break;
38 case 2:
39+ qemu_pp_write_control(s, (uint8_t)val);
40 if ((val & PARA_CTR_INIT) == 0 ) {
41- s->status = PARA_STS_BUSY;
42- s->status |= PARA_STS_ACK;
43- s->status |= PARA_STS_ONLINE;
44- s->status |= PARA_STS_ERROR;
45+ s->status = PARA_STS_BUSY;
46+ s->status |= PARA_STS_ACK;
47+ s->status |= PARA_STS_ONLINE;
48+ s->status |= PARA_STS_ERROR;
49 }
50 else if (val & PARA_CTR_SELECT) {
51- if (val & PARA_CTR_STROBE) {
52- s->status &= ~PARA_STS_BUSY;
53- if ((s->control & PARA_CTR_STROBE) == 0)
54- qemu_chr_write(s->chr, &s->data, 1);
55- } else {
56- if (s->control & PARA_CTR_INTEN) {
57- s->irq_pending = 1;
58- }
59- }
60+ if (val & PARA_CTR_STROBE) {
61+ s->status &= ~PARA_STS_BUSY;
62+ if ((s->control & PARA_CTR_STROBE) == 0)
63+ qemu_chr_write(s->chr, &s->data, 1);
64+ } else {
65+ if (s->control & PARA_CTR_INTEN) {
66+ s->irq_pending = 1;
67+ }
68+ }
69 }
70 parallel_update_irq(s);
71- s->control = val;
72 break;
73 }
74 }
75@@ -105,25 +99,25 @@ static uint32_t parallel_ioport_read(voi
76 addr &= 7;
77 switch(addr) {
78 case 0:
79- ret = s->data;
80+ ret = qemu_pp_read_data(s);
81 break;
82 case 1:
83- ret = s->status;
84+ ret = qemu_pp_read_status(s);
85 s->irq_pending = 0;
86 if ((s->status & PARA_STS_BUSY) == 0 && (s->control & PARA_CTR_STROBE) == 0) {
87- /* XXX Fixme: wait 5 microseconds */
88- if (s->status & PARA_STS_ACK)
89- s->status &= ~PARA_STS_ACK;
90- else {
91- /* XXX Fixme: wait 5 microseconds */
92- s->status |= PARA_STS_ACK;
93- s->status |= PARA_STS_BUSY;
94- }
95+ /* XXX Fixme: wait 5 microseconds */
96+ if (s->status & PARA_STS_ACK)
97+ s->status &= ~PARA_STS_ACK;
98+ else {
99+ /* XXX Fixme: wait 5 microseconds */
100+ s->status |= PARA_STS_ACK;
101+ s->status |= PARA_STS_BUSY;
102+ }
103 }
104 parallel_update_irq(s);
105 break;
106 case 2:
107- ret = s->control;
108+ ret = qemu_pp_read_control(s);
109 break;
110 }
111 #ifdef DEBUG_PARALLEL
112Only in qemu-sandbox: kqemu
113Only in qemu-sandbox: qemu-doc.html
114Only in qemu-sandbox: qemu-img.1
115Only in qemu-sandbox: qemu-tech.html
116Only in qemu-sandbox: qemu.1
117diff --exclude=CVS -upr qemu/vl.c qemu-sandbox/vl.c
118--- qemu/vl.c 2005-03-13 02:43:36.000000000 -0700
119+++ qemu-sandbox/vl.c 2005-03-13 07:16:54.000000000 -0700
120@@ -46,6 +46,8 @@
121 #include <libutil.h>
122 #endif
123 #else
124+#include <linux/parport.h>
125+#include <linux/ppdev.h>
126 #include <linux/if.h>
127 #include <linux/if_tun.h>
128 #include <pty.h>
129@@ -1028,10 +1030,14 @@ CharDriverState *qemu_chr_open_null(void
130 return chr;
131 }
132
133+
134+
135+
136 #ifndef _WIN32
137
138 typedef struct {
139 int fd_in, fd_out;
140+ int parport_device;
141 /* for nographic stdio only */
142 IOCanRWHandler *fd_can_read;
143 IOReadHandler *fd_read;
144@@ -1084,6 +1090,76 @@ static void fd_chr_add_read_handler(Char
145 }
146 }
147
148+uint8_t qemu_pp_read_status(ParallelState *s)
149+{
150+ uint8_t ret, status;
151+ FDCharDriver *fd = s->chr->opaque;
152+
153+ if (fd->parport_device) {
154+ ioctl(fd->fd_out, PPRSTATUS, &status);
155+ ret = status;
156+ } else {
157+ ret = s->status;
158+ }
159+
160+ return ret;
161+}
162+
163+
164+uint8_t qemu_pp_read_control(ParallelState *s)
165+{
166+ uint8_t ret, control;
167+ FDCharDriver *fd = s->chr->opaque;
168+
169+ if (fd->parport_device) {
170+ ioctl(fd->fd_out, PPRCONTROL, &control);
171+ ret = control;
172+ } else {
173+ ret = s->control;
174+ }
175+
176+ return ret;
177+
178+}
179+uint8_t qemu_pp_read_data(ParallelState *s)
180+{
181+ uint8_t ret, data;
182+ FDCharDriver *fd = s->chr->opaque;
183+
184+ if (fd->parport_device) {
185+ ioctl(fd->fd_out, PPRDATA, &data);
186+ ret = data;
187+ } else {
188+ ret = s->data;
189+ }
190+
191+ return ret;
192+}
193+void qemu_pp_write_data(ParallelState *s, uint8_t val)
194+{
195+ uint8_t data;
196+ FDCharDriver *fd = s->chr->opaque;
197+
198+ if (fd->parport_device) {
199+ data = (uint8_t)val;
200+ ioctl(fd->fd_out, PPWDATA, &data);
201+ } else {
202+ s->data = val;
203+ }
204+}
205+
206+void qemu_pp_write_control(ParallelState *s, uint8_t val)
207+{
208+ uint8_t control;
209+ FDCharDriver *fd = s->chr->opaque;
210+
211+ if (fd->parport_device) {
212+ control = (uint8_t)val;
213+ ioctl(fd->fd_out, PPWCONTROL, &control);
214+ } else {
215+ s->control = val;
216+ }
217+}
218 /* open a character device to a unix fd */
219 CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
220 {
221@@ -1263,6 +1339,24 @@ CharDriverState *qemu_chr_open_stdio(voi
222 return chr;
223 }
224
225+CharDriverState *qemu_chr_open_dev(const char *filename)
226+{
227+ int fd = 0;
228+
229+ fd = open(filename, O_RDWR);
230+ CharDriverState *s = qemu_chr_open_fd(fd, fd);
231+
232+ if (strstr(filename, "parport") != NULL) {
233+ if (ioctl(((FDCharDriver *)s->opaque)->fd_in, PPCLAIM) == 0) {
234+ ((FDCharDriver *)s->opaque)->parport_device = 1;
235+ } else {
236+ ((FDCharDriver *)s->opaque)->parport_device = 0;
237+ }
238+ }
239+
240+ return s;
241+}
242+
243 #if defined(__linux__)
244 CharDriverState *qemu_chr_open_pty(void)
245 {
246@@ -1297,11 +1391,14 @@ CharDriverState *qemu_chr_open(const cha
247 return qemu_chr_open_pty();
248 } else if (!strcmp(filename, "stdio")) {
249 return qemu_chr_open_stdio();
250- } else
251-#endif
252+ } else {
253+ return qemu_chr_open_dev(filename);
254+ }
255+#else
256 {
257 return NULL;
258 }
259+#endif
260 }
261
262 /***********************************************************/
263diff --exclude=CVS -upr qemu/vl.h qemu-sandbox/vl.h
264--- qemu/vl.h 2005-03-13 02:43:36.000000000 -0700
265+++ qemu-sandbox/vl.h 2005-03-13 07:16:54.000000000 -0700
266@@ -199,6 +199,17 @@ typedef struct CharDriverState {
267 void *opaque;
268 } CharDriverState;
269
270+
271+typedef struct ParallelState {
272+ uint8_t data;
273+ uint8_t status; /* read only register */
274+ uint8_t control;
275+ int irq;
276+ int irq_pending;
277+ CharDriverState *chr;
278+} ParallelState;
279+
280+
281 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...);
282 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len);
283 void qemu_chr_send_event(CharDriverState *s, int event);
284@@ -206,6 +217,13 @@ void qemu_chr_add_read_handler(CharDrive
285 IOCanRWHandler *fd_can_read,
286 IOReadHandler *fd_read, void *opaque);
287 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event);
288+
289+
290+uint8_t qemu_pp_read_status(ParallelState *s);
291+uint8_t qemu_pp_read_control(ParallelState *s);
292+uint8_t qemu_pp_read_data(ParallelState *s);
293+void qemu_pp_write_data(ParallelState *s, uint8_t data);
294+void qemu_pp_write_control(ParallelState *s, uint8_t control);
295
296 /* consoles */
297
298@@ -643,8 +661,6 @@ typedef struct SerialState SerialState;
299 SerialState *serial_init(int base, int irq, CharDriverState *chr);
300
301 /* parallel.c */
302-
303-typedef struct ParallelState ParallelState;
304 ParallelState *parallel_init(int base, int irq, CharDriverState *chr);
305
306 /* i8259.c */
QEMU CPU Emulator
This page took 0.115304 seconds and 4 git commands to generate.