char-parallel.c (8958B)
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