chardev/char-parallel.c

   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