xref: /openbmc/qemu/chardev/char-parallel.c (revision 2038f8c8) 
1 /*
2  * QEMU System Emulator
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 
25 #include "qemu/osdep.h"
26 #include "chardev/char.h"
27 #include "qapi/error.h"
28 #include "qemu/module.h"
29 #include "qemu/option.h"
30 #include <sys/ioctl.h>
31 
32 #ifdef CONFIG_BSD
33 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
34 #include <dev/ppbus/ppi.h>
35 #include <dev/ppbus/ppbconf.h>
36 #elif defined(__DragonFly__)
37 #include <dev/misc/ppi/ppi.h>
38 #include <bus/ppbus/ppbconf.h>
39 #endif
40 #else
41 #ifdef __linux__
42 #include <linux/ppdev.h>
43 #include <linux/parport.h>
44 #endif
45 #endif
46 
47 #include "chardev/char-fd.h"
48 #include "chardev/char-parallel.h"
49 
50 #if defined(__linux__)
51 
52 typedef struct {
53     Chardev parent;
54     int fd;
55     int mode;
56 } ParallelChardev;
57 
58 #define PARALLEL_CHARDEV(obj) \
59     OBJECT_CHECK(ParallelChardev, (obj), TYPE_CHARDEV_PARALLEL)
60 
61 static int pp_hw_mode(ParallelChardev *s, uint16_t mode)
62 {
63     if (s->mode != mode) {
64         int m = mode;
65         if (ioctl(s->fd, PPSETMODE, &m) < 0) {
66             return 0;
67         }
68         s->mode = mode;
69     }
70     return 1;
71 }
72 
73 static int pp_ioctl(Chardev *chr, int cmd, void *arg)
74 {
75     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
76     int fd = drv->fd;
77     uint8_t b;
78 
79     switch (cmd) {
80     case CHR_IOCTL_PP_READ_DATA:
81         if (ioctl(fd, PPRDATA, &b) < 0) {
82             return -ENOTSUP;
83         }
84         *(uint8_t *)arg = b;
85         break;
86     case CHR_IOCTL_PP_WRITE_DATA:
87         b = *(uint8_t *)arg;
88         if (ioctl(fd, PPWDATA, &b) < 0) {
89             return -ENOTSUP;
90         }
91         break;
92     case CHR_IOCTL_PP_READ_CONTROL:
93         if (ioctl(fd, PPRCONTROL, &b) < 0) {
94             return -ENOTSUP;
95         }
96         /* Linux gives only the lowest bits, and no way to know data
97            direction! For better compatibility set the fixed upper
98            bits. */
99         *(uint8_t *)arg = b | 0xc0;
100         break;
101     case CHR_IOCTL_PP_WRITE_CONTROL:
102         b = *(uint8_t *)arg;
103         if (ioctl(fd, PPWCONTROL, &b) < 0) {
104             return -ENOTSUP;
105         }
106         break;
107     case CHR_IOCTL_PP_READ_STATUS:
108         if (ioctl(fd, PPRSTATUS, &b) < 0) {
109             return -ENOTSUP;
110         }
111         *(uint8_t *)arg = b;
112         break;
113     case CHR_IOCTL_PP_DATA_DIR:
114         if (ioctl(fd, PPDATADIR, (int *)arg) < 0) {
115             return -ENOTSUP;
116         }
117         break;
118     case CHR_IOCTL_PP_EPP_READ_ADDR:
119         if (pp_hw_mode(drv, IEEE1284_MODE_EPP | IEEE1284_ADDR)) {
120             struct ParallelIOArg *parg = arg;
121             int n = read(fd, parg->buffer, parg->count);
122             if (n != parg->count) {
123                 return -EIO;
124             }
125         }
126         break;
127     case CHR_IOCTL_PP_EPP_READ:
128         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
129             struct ParallelIOArg *parg = arg;
130             int n = read(fd, parg->buffer, parg->count);
131             if (n != parg->count) {
132                 return -EIO;
133             }
134         }
135         break;
136     case CHR_IOCTL_PP_EPP_WRITE_ADDR:
137         if (pp_hw_mode(drv, IEEE1284_MODE_EPP | IEEE1284_ADDR)) {
138             struct ParallelIOArg *parg = arg;
139             int n = write(fd, parg->buffer, parg->count);
140             if (n != parg->count) {
141                 return -EIO;
142             }
143         }
144         break;
145     case CHR_IOCTL_PP_EPP_WRITE:
146         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
147             struct ParallelIOArg *parg = arg;
148             int n = write(fd, parg->buffer, parg->count);
149             if (n != parg->count) {
150                 return -EIO;
151             }
152         }
153         break;
154     default:
155         return -ENOTSUP;
156     }
157     return 0;
158 }
159 
160 static void qemu_chr_open_pp_fd(Chardev *chr,
161                                 int fd,
162                                 bool *be_opened,
163                                 Error **errp)
164 {
165     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
166 
167     if (ioctl(fd, PPCLAIM) < 0) {
168         error_setg_errno(errp, errno, "not a parallel port");
169         close(fd);
170         return;
171     }
172 
173     drv->fd = fd;
174     drv->mode = IEEE1284_MODE_COMPAT;
175 }
176 #endif /* __linux__ */
177 
178 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
179 
180 typedef struct {
181     Chardev parent;
182     int fd;
183 } ParallelChardev;
184 
185 #define PARALLEL_CHARDEV(obj)                                   \
186     OBJECT_CHECK(ParallelChardev, (obj), TYPE_CHARDEV_PARALLEL)
187 
188 static int pp_ioctl(Chardev *chr, int cmd, void *arg)
189 {
190     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
191     uint8_t b;
192 
193     switch (cmd) {
194     case CHR_IOCTL_PP_READ_DATA:
195         if (ioctl(drv->fd, PPIGDATA, &b) < 0) {
196             return -ENOTSUP;
197         }
198         *(uint8_t *)arg = b;
199         break;
200     case CHR_IOCTL_PP_WRITE_DATA:
201         b = *(uint8_t *)arg;
202         if (ioctl(drv->fd, PPISDATA, &b) < 0) {
203             return -ENOTSUP;
204         }
205         break;
206     case CHR_IOCTL_PP_READ_CONTROL:
207         if (ioctl(drv->fd, PPIGCTRL, &b) < 0) {
208             return -ENOTSUP;
209         }
210         *(uint8_t *)arg = b;
211         break;
212     case CHR_IOCTL_PP_WRITE_CONTROL:
213         b = *(uint8_t *)arg;
214         if (ioctl(drv->fd, PPISCTRL, &b) < 0) {
215             return -ENOTSUP;
216         }
217         break;
218     case CHR_IOCTL_PP_READ_STATUS:
219         if (ioctl(drv->fd, PPIGSTATUS, &b) < 0) {
220             return -ENOTSUP;
221         }
222         *(uint8_t *)arg = b;
223         break;
224     default:
225         return -ENOTSUP;
226     }
227     return 0;
228 }
229 
230 static void qemu_chr_open_pp_fd(Chardev *chr,
231                                 int fd,
232                                 bool *be_opened,
233                                 Error **errp)
234 {
235     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
236     drv->fd = fd;
237     *be_opened = false;
238 }
239 #endif
240 
241 #ifdef HAVE_CHARDEV_PARPORT
242 static void qmp_chardev_open_parallel(Chardev *chr,
243                                       ChardevBackend *backend,
244                                       bool *be_opened,
245                                       Error **errp)
246 {
247     ChardevHostdev *parallel = backend->u.parallel.data;
248     int fd;
249 
250     fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);
251     if (fd < 0) {
252         return;
253     }
254     qemu_chr_open_pp_fd(chr, fd, be_opened, errp);
255 }
256 
257 static void qemu_chr_parse_parallel(QemuOpts *opts, ChardevBackend *backend,
258                                     Error **errp)
259 {
260     const char *device = qemu_opt_get(opts, "path");
261     ChardevHostdev *parallel;
262 
263     if (device == NULL) {
264         error_setg(errp, "chardev: parallel: no device path given");
265         return;
266     }
267     backend->type = CHARDEV_BACKEND_KIND_PARALLEL;
268     parallel = backend->u.parallel.data = g_new0(ChardevHostdev, 1);
269     qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(parallel));
270     parallel->device = g_strdup(device);
271 }
272 
273 static void char_parallel_class_init(ObjectClass *oc, void *data)
274 {
275     ChardevClass *cc = CHARDEV_CLASS(oc);
276 
277     cc->parse = qemu_chr_parse_parallel;
278     cc->open = qmp_chardev_open_parallel;
279 #if defined(__linux__)
280     cc->chr_ioctl = pp_ioctl;
281 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
282     defined(__DragonFly__)
283     cc->chr_ioctl = pp_ioctl;
284 #endif
285 }
286 
287 static void char_parallel_finalize(Object *obj)
288 {
289 #if defined(__linux__)
290     Chardev *chr = CHARDEV(obj);
291     ParallelChardev *drv = PARALLEL_CHARDEV(chr);
292     int fd = drv->fd;
293 
294     pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
295     ioctl(fd, PPRELEASE);
296     close(fd);
297     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
298 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
299     defined(__DragonFly__)
300     /* FIXME: close fd? */
301 #endif
302 }
303 
304 static const TypeInfo char_parallel_type_info = {
305     .name = TYPE_CHARDEV_PARALLEL,
306     .parent = TYPE_CHARDEV,
307     .instance_size = sizeof(ParallelChardev),
308     .instance_finalize = char_parallel_finalize,
309     .class_init = char_parallel_class_init,
310 };
311 
312 static void register_types(void)
313 {
314     type_register_static(&char_parallel_type_info);
315 }
316 
317 type_init(register_types);
318 
319 #endif
320