kstars/kstars/indi/fli/libfli-camera-parport.c

   1 /*
   2
   3   Copyright (c) 2002 Finger Lakes Instrumentation (FLI), L.L.C.
   4   All rights reserved.
   5
   6   Redistribution and use in source and binary forms, with or without
   7   modification, are permitted provided that the following conditions
   8   are met:
   9
  10         Redistributions of source code must retain the above copyright
  11         notice, this list of conditions and the following disclaimer.
  12
  13         Redistributions in binary form must reproduce the above
  14         copyright notice, this list of conditions and the following
  15         disclaimer in the documentation and/or other materials
  16         provided with the distribution.
  17
  18         Neither the name of Finger Lakes Instrumentation (FLI), LLC
  19         nor the names of its contributors may be used to endorse or
  20         promote products derived from this software without specific
  21         prior written permission.
  22
  23   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  27   REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  28   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31   CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  33   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34   POSSIBILITY OF SUCH DAMAGE.
  35
  36   ======================================================================
  37
  38   Finger Lakes Instrumentation, L.L.C. (FLI)
  39   web: http://www.fli-cam.com
  40   email: support@fli-cam.com
  41
  42 */
  43
  44 #ifdef WIN32
  45 #include <winsock.h>
  46 #else
  47 #include <sys/param.h>
  48 #include <netinet/in.h>
  49 #endif
  50
  51 #include <stdio.h>
  52 #include <errno.h>
  53 #include <string.h>
  54
  55 #include "libfli-libfli.h"
  56 #include "libfli-mem.h"
  57 #include "libfli-debug.h"
  58 #include "libfli-camera.h"
  59 #include "libfli-camera-parport.h"
  60
  61 long fli_camera_parport_open(flidev_t dev)
  62 {
  63   flicamdata_t *cam;
  64   long rlen, wlen;
  65   unsigned short buf;
  66   int id;
  67
  68   cam = DEVICE->device_data;
  69
  70   /* Set timeout values */
  71   cam->readto = 1000;
  72   cam->writeto = 1000;
  73   cam->dirto = 1000;
  74
  75   rlen = 2;
  76   wlen = 2;
  77   buf = htons(C_ADDRESS(1, EPARAM_ECHO));
  78   IO(dev, &buf, &wlen, &rlen);
  79   if (buf != htons(C_ADDRESS(1, EPARAM_ECHO)))
  80   {
  81     debug(FLIDEBUG_FAIL, "Echo back from camera failed.");
  82     return -EIO;
  83   }
  84
  85   rlen = 2; wlen = 2;
  86   buf = htons(C_ADDRESS(1, EPARAM_DEVICE));
  87   IO(dev, &buf, &wlen, &rlen);
  88   DEVICE->devinfo.hwrev = ntohs(buf) & 0x00ff;
  89
  90   rlen = 2; wlen = 2;
  91   buf = htons(C_ADDRESS(1, EPARAM_CCDID));
  92   IO(dev, &buf, &wlen, &rlen);
  93   DEVICE->devinfo.devid = ntohs(buf) & 0x00ff;
  94
  95   for (id = 0; knowndev[id].index != 0; id++)
  96     if (knowndev[id].index == DEVICE->devinfo.devid)
  97       break;
  98
  99   if (knowndev[id].index == 0)
 100     return -ENODEV;
 101
 102   cam->ccd.array_area.ul.x = knowndev[id].array_area.ul.x;
 103   cam->ccd.array_area.ul.y = knowndev[id].array_area.ul.y;
 104   cam->ccd.array_area.lr.x = knowndev[id].array_area.lr.x;
 105   cam->ccd.array_area.lr.y = knowndev[id].array_area.lr.y;
 106   cam->ccd.visible_area.ul.x = knowndev[id].visible_area.ul.x;
 107   cam->ccd.visible_area.ul.y = knowndev[id].visible_area.ul.y;
 108   cam->ccd.visible_area.lr.x = knowndev[id].visible_area.lr.x;
 109   cam->ccd.visible_area.lr.y = knowndev[id].visible_area.lr.y;
 110   cam->ccd.pixelwidth = knowndev[id].pixelwidth;
 111   cam->ccd.pixelheight = knowndev[id].pixelheight;
 112
 113   if ((DEVICE->devinfo.model =
 114        (char *)xmalloc(strlen(knowndev[id].model) + 1)) == NULL)
 115     return -ENOMEM;
 116   strcpy(DEVICE->devinfo.model, knowndev[id].model);
 117
 118   debug(FLIDEBUG_INFO, "     Name: %s", DEVICE->devinfo.devnam);
 119   debug(FLIDEBUG_INFO, "    Array: (%4d,%4d),(%4d,%4d)",
 120         cam->ccd.array_area.ul.x,
 121         cam->ccd.array_area.ul.y,
 122         cam->ccd.array_area.lr.x,
 123         cam->ccd.array_area.lr.y);
 124   debug(FLIDEBUG_INFO, "  Visible: (%4d,%4d),(%4d,%4d)",
 125         cam->ccd.visible_area.ul.x,
 126         cam->ccd.visible_area.ul.y,
 127         cam->ccd.visible_area.lr.x,
 128         cam->ccd.visible_area.lr.y);
 129
 130   rlen = 2; wlen = 2;
 131   buf = htons(C_ADDRESS(1, EPARAM_SNHIGH));
 132   IO(dev, &buf, &wlen, &rlen);
 133   DEVICE->devinfo.serno = (ntohs(buf) & 0x00ff) << 8;
 134
 135   rlen = 2; wlen = 2;
 136   buf = htons(C_ADDRESS(1, EPARAM_SNLOW));
 137   IO(dev, &buf, &wlen, &rlen);
 138   DEVICE->devinfo.serno |= (ntohs(buf) & 0x00ff);
 139
 140   rlen = 2; wlen = 2;
 141   buf = htons(C_ADDRESS(1, EPARAM_FIRM));
 142   IO(dev, &buf, &wlen, &rlen);
 143   DEVICE->devinfo.fwrev = (ntohs(buf) & 0x00ff);
 144
 145   /* Initialize all varaibles to something */
 146   switch(DEVICE->devinfo.hwrev)
 147   {
 148   case 0x01:
 149     cam->tempslope = (100.0 / 201.1);
 150     cam->tempintercept = (-61.613);
 151     break;
 152
 153   case 0x02:
 154     cam->tempslope = (70.0 / 215.75);
 155     cam->tempintercept = (-52.5681);
 156     break;
 157
 158   default:
 159     debug(FLIDEBUG_WARN, "Could not set temperature parameters.");
 160     break;
 161   }
 162
 163   cam->vflushbin = 4;
 164   cam->hflushbin = 4;
 165   cam->vbin = 1;
 166   cam->hbin = 1;
 167   cam->image_area.ul.x = cam->ccd.visible_area.ul.x;
 168   cam->image_area.ul.y = cam->ccd.visible_area.ul.y;
 169   cam->image_area.lr.x = cam->ccd.visible_area.lr.x;
 170   cam->image_area.lr.y = cam->ccd.visible_area.lr.y;
 171   cam->exposure = 100;
 172   cam->frametype = FLI_FRAME_TYPE_NORMAL;
 173   cam->flushes = 0;
 174   cam->bitdepth = FLI_MODE_16BIT;
 175   cam->exttrigger = 0;
 176
 177   cam->grabrowwidth =
 178     (cam->image_area.lr.x - cam->image_area.ul.x) / cam->hbin;
 179   cam->grabrowcount = 1;
 180   cam->grabrowcounttot = cam->grabrowcount;
 181   cam->grabrowindex = 0;
 182   cam->grabrowbatchsize = 1;
 183   cam->grabrowbufferindex = cam->grabrowcount;
 184   cam->flushcountbeforefirstrow = 0;
 185   cam->flushcountafterlastrow = 0;
 186
 187   return 0;
 188 }
 189
 190 long fli_camera_parport_get_array_area(flidev_t dev, long *ul_x, long *ul_y,
 191                                        long *lr_x, long *lr_y)
 192 {
 193   flicamdata_t *cam;
 194
 195   cam = DEVICE->device_data;
 196
 197   *ul_x = cam->ccd.array_area.ul.x;
 198   *ul_y = cam->ccd.array_area.ul.y;
 199   *lr_x = cam->ccd.array_area.lr.x;
 200   *lr_y = cam->ccd.array_area.lr.y;
 201
 202   return 0;
 203 }
 204
 205 long fli_camera_parport_get_visible_area(flidev_t dev, long *ul_x, long *ul_y,
 206                                          long *lr_x, long *lr_y)
 207 {
 208   flicamdata_t *cam;
 209
 210   cam = DEVICE->device_data;
 211
 212   *ul_x = cam->ccd.visible_area.ul.x;
 213   *ul_y = cam->ccd.visible_area.ul.y;
 214   *lr_x = cam->ccd.visible_area.lr.x;
 215   *lr_y = cam->ccd.visible_area.lr.y;
 216
 217   return 0;
 218 }
 219
 220 long fli_camera_parport_set_exposure_time(flidev_t dev, long exptime)
 221 {
 222   flicamdata_t *cam;
 223
 224   cam = DEVICE->device_data;
 225
 226   if (exptime < 0)
 227     return -EINVAL;
 228
 229   cam->exposure = exptime;
 230
 231   if (exptime <= 15000) /* Less than thirty seconds..., 8.192e-3 sec */
 232   {
 233     cam->expdur = 1;
 234     cam->expmul = (long) (((double) exptime) / 8.192);
 235   }
 236   else if (exptime <= 2000000) /* Less than one hour */
 237   {
 238     cam->expdur = (long) (1.0 / 8.192e-3);
 239     cam->expmul = (long) (exptime / 1000);
 240   }
 241   else
 242   {
 243     cam->expdur = (long) (10.0 / 8.192e-3);
 244     cam->expmul = (long) (exptime / 10000);
 245   }
 246
 247   return 0;
 248 }
 249
 250 long fli_camera_parport_set_image_area(flidev_t dev, long ul_x, long ul_y,
 251                                        long lr_x, long lr_y)
 252 {
 253   flicamdata_t *cam;
 254
 255   cam = DEVICE->device_data;
 256
 257   if ((ul_x < cam->ccd.visible_area.ul.x) ||
 258       (ul_y < cam->ccd.visible_area.ul.y) ||
 259       (lr_x > cam->ccd.visible_area.lr.x) ||
 260       (lr_y > cam->ccd.visible_area.lr.y))
 261     return -EINVAL;
 262
 263   cam->image_area.ul.x = ul_x;
 264   cam->image_area.ul.y = ul_y;
 265   cam->image_area.lr.x = lr_x;
 266   cam->image_area.lr.y = lr_y;
 267
 268   return 0;
 269 }
 270
 271 long fli_camera_parport_set_hbin(flidev_t dev, long hbin)
 272 {
 273   flicamdata_t *cam;
 274
 275   cam = DEVICE->device_data;
 276
 277   if ((hbin < 1) || (hbin > 16))
 278     return -EINVAL;
 279
 280   cam->hbin = hbin;
 281   return 0;
 282 }
 283
 284 long fli_camera_parport_set_vbin(flidev_t dev, long vbin)
 285 {
 286   flicamdata_t *cam;
 287
 288   cam = DEVICE->device_data;
 289
 290   if ((vbin < 1) || (vbin > 16))
 291     return -EINVAL;
 292
 293   cam->vbin = vbin;
 294   return 0;
 295 }
 296
 297 long fli_camera_parport_get_exposure_status(flidev_t dev, long *timeleft)
 298 {
 299   flicamdata_t *cam;
 300   long rlen, wlen;
 301   unsigned short buf;
 302
 303   cam = DEVICE->device_data;
 304
 305   rlen = 2; wlen = 2;
 306   buf = htons(C_SHUTTER(1,0));
 307   IO(dev, &buf, &wlen, &rlen);
 308   if ((ntohs(buf) & 0xf000) != C_SHUTTER(0,0))
 309   {
 310     debug(FLIDEBUG_FAIL, "(exposurestatus) echo back from camera failed.");
 311     return -EIO;
 312   }
 313
 314   *timeleft = (long)((double)(ntohs(buf) & 0x07ff) *
 315                      ((double)cam->expdur * 8.192));
 316
 317   return 0;
 318 }
 319
 320 long fli_camera_parport_set_temperature(flidev_t dev, double temperature)
 321 {
 322   flicamdata_t *cam;
 323   long rlen, wlen;
 324   unsigned short buf;
 325
 326   cam = DEVICE->device_data;
 327
 328   rlen = 2; wlen = 2;
 329   buf = (unsigned short)((temperature - cam->tempintercept) /
 330                          cam->tempslope);
 331   buf = htons((unsigned short) C_TEMP(buf));
 332   IO(dev, &buf, &wlen, &rlen);
 333   if ((ntohs(buf) & 0xf000) != C_TEMP(0))
 334   {
 335     debug(FLIDEBUG_FAIL, "(settemperature) echo back from camera failed.");
 336     return -EIO;
 337   }
 338
 339   return 0;
 340 }
 341
 342 long fli_camera_parport_get_temperature(flidev_t dev, double *temperature)
 343 {
 344   flicamdata_t *cam;
 345   long rlen, wlen;
 346   unsigned short buf;
 347
 348   cam = DEVICE->device_data;
 349
 350   rlen = 2; wlen = 2;
 351   buf = htons(C_TEMP(0x0800));
 352   IO(dev, &buf, &wlen, &rlen);
 353   if ((ntohs(buf) & 0xf000) != C_TEMP(0))
 354   {
 355     debug(FLIDEBUG_FAIL, "(settemperature) echo back from camera failed.");
 356     return -EIO;
 357   }
 358   *temperature = cam->tempslope * (double)(ntohs(buf) & 0x00ff) +
 359     cam->tempintercept;
 360
 361   return 0;
 362 }
 363
 364 long fli_camera_parport_grab_row(flidev_t dev, void *buff, size_t width)
 365 {
 366   flicamdata_t *cam;
 367   long r;
 368   double dTm;
 369   long rlen, wlen;
 370   unsigned short buf;
 371
 372   cam = DEVICE->device_data;
 373
 374   if (cam->flushcountbeforefirstrow > 0)
 375   {
 376     if ((r = fli_camera_parport_flush_rows(dev,
 377                                            cam->flushcountbeforefirstrow, 1)))
 378       return r;
 379
 380     cam->flushcountbeforefirstrow = 0;
 381   }
 382
 383   dTm = (25.0e-6) * cam->ccd.array_area.lr.x + 1e-3;
 384   dTm = dTm / 1e-6;
 385   cam->readto = (long)dTm;
 386   cam->writeto = (long)dTm;
 387
 388   rlen = 0; wlen = 2;
 389   buf = htons((unsigned short) C_SEND(cam->grabrowwidth));
 390   IO(dev, &buf, &wlen, &rlen);
 391
 392   if (cam->bitdepth == FLI_MODE_8BIT)
 393   {
 394     unsigned char *cbuf;
 395     int x;
 396
 397     if ((cbuf = xmalloc(cam->grabrowwidth)) == NULL)
 398     {
 399       debug(FLIDEBUG_FAIL, "Failed memory allocation during row grab.");
 400       return -ENOMEM;
 401     }
 402
 403     rlen = cam->grabrowwidth; wlen = 0;
 404     r = DEVICE->fli_io(dev, cbuf, &wlen, &rlen);
 405     if (r != 0)
 406     {
 407       debug(FLIDEBUG_WARN, "Couldn't grab entire row, got %d of %d bytes.",
 408             rlen, cam->grabrowwidth);
 409     }
 410     for (x = 0; x < (int)width; x++)
 411     {
 412       ((char *)buff)[x] = (((cbuf[x]) + 128) & 0x00ff);
 413     }
 414     xfree(cbuf);
 415   }
 416   else
 417   {
 418     unsigned short *sbuf;
 419     int x;
 420
 421     if ((sbuf = xmalloc(cam->grabrowwidth * sizeof(unsigned short))) == NULL)
 422     {
 423       debug(FLIDEBUG_FAIL, "Failed memory allocation during row grab.");
 424       return -ENOMEM;
 425     }
 426
 427     rlen = cam->grabrowwidth * sizeof(unsigned short); wlen = 0;
 428     r = DEVICE->fli_io(dev, sbuf, &wlen, &rlen);
 429     if (r != 0)
 430     {
 431       debug(FLIDEBUG_WARN, "Couldn't grab entire row, got %d of %d bytes.",
 432             rlen, cam->grabrowwidth);
 433     }
 434     for (x = 0; x < (int)width; x++)
 435     {
 436       if (DEVICE->devinfo.hwrev == 0x01) /* IMG camera */
 437       {
 438                                 ((unsigned short *)buff)[x] = ntohs(sbuf[x]) + 32768;
 439       }
 440       else
 441       {
 442                                 ((unsigned short *)buff)[x] = ntohs(sbuf[x]);
 443       }
 444     }
 445     xfree(sbuf);
 446   }
 447
 448   rlen = 2; wlen = 0;
 449   IO(dev, &buf, &wlen, &rlen);
 450   if (ntohs(buf) != C_SEND(width))
 451   {
 452     debug(FLIDEBUG_WARN, "Width: %d, requested %d.",
 453           width, cam->grabrowwidth * sizeof(unsigned short));
 454     debug(FLIDEBUG_WARN, "Got 0x%04x instead of 0x%04x.", ntohs(buf), C_SEND(width));
 455     debug(FLIDEBUG_WARN, "Didn't get command echo at end of row.");
 456   }
 457
 458   if (cam->grabrowcount > 0)
 459   {
 460     cam->grabrowcount--;
 461     if (cam->grabrowcount == 0)
 462     {
 463       if ((r = fli_camera_parport_flush_rows(dev,
 464                                              cam->flushcountafterlastrow, 1)))
 465                         return r;
 466
 467       cam->flushcountafterlastrow = 0;
 468       cam->grabrowbatchsize = 1;
 469     }
 470   }
 471
 472   cam->readto = 1000;
 473   cam->writeto = 1000;
 474
 475   return 0;
 476 }
 477
 478 long fli_camera_parport_expose_frame(flidev_t dev)
 479 {
 480   flicamdata_t *cam;
 481   long rlen, wlen;
 482   unsigned short buf;
 483
 484   cam = DEVICE->device_data;
 485
 486   debug(FLIDEBUG_INFO, "Setting X Row Offset.");
 487   rlen = 2; wlen = 2;
 488   buf = htons((unsigned short) D_XROWOFF(cam->image_area.ul.x));
 489   IO(dev, &buf, &wlen, &rlen);
 490
 491   debug(FLIDEBUG_INFO, "Setting X Row Width to %d.", cam->ccd.array_area.lr.x - cam->ccd.array_area.ul.x);
 492   buf = htons((unsigned short) D_XROWWID(cam->ccd.array_area.lr.x - cam->ccd.array_area.ul.x));
 493   IO(dev, &buf, &wlen, &rlen);
 494
 495   debug(FLIDEBUG_INFO, "Setting X Flush Bin.");
 496   buf = htons((unsigned short) D_XFLBIN(cam->hflushbin));
 497   IO(dev, &buf, &wlen, &rlen);
 498
 499   debug(FLIDEBUG_INFO, "Setting Y Flush Bin.");
 500   buf = htons((unsigned short) D_YFLBIN(cam->vflushbin));
 501   IO(dev, &buf, &wlen, &rlen);
 502
 503   debug(FLIDEBUG_INFO, "Setting X Bin.");
 504   buf = htons((unsigned short) D_XBIN(cam->hbin));
 505   IO(dev, &buf, &wlen, &rlen);
 506
 507   debug(FLIDEBUG_INFO, "Setting Y Bin.");
 508   buf = htons((unsigned short) D_YBIN(cam->vbin));
 509   IO(dev, &buf, &wlen, &rlen);
 510
 511   debug(FLIDEBUG_INFO, "Setting Exposure Duration.");
 512   buf = htons((unsigned short) D_EXPDUR(cam->expdur));
 513   IO(dev, &buf, &wlen, &rlen);
 514
 515   if (cam->bitdepth == FLI_MODE_8BIT)
 516   {
 517     debug(FLIDEBUG_INFO, "Eight Bit.");
 518     buf = htons((unsigned short)((cam->exttrigger > 0) ?
 519                                  C_RESTCFG(0,0,1,7) : C_RESTCFG(0,0,0,7)));
 520   }
 521   else
 522   {
 523     debug(FLIDEBUG_INFO, "Sixteen Bit.");
 524     buf = htons((unsigned short)((cam->exttrigger > 0) ?
 525                                  C_RESTCFG(0,0,1,15) :
 526                                  C_RESTCFG(0,0,0,15)));
 527   }
 528   IO(dev, &buf, &wlen, &rlen);
 529
 530   if (cam->flushes > 0)
 531   {
 532     int r;
 533
 534     debug(FLIDEBUG_INFO, "Flushing array.");
 535     if ((r = fli_camera_parport_flush_rows(dev,
 536                                            cam->ccd.array_area.lr.y - cam->ccd.array_area.ul.y,
 537                                            cam->flushes)))
 538       return r;
 539   }
 540
 541   debug(FLIDEBUG_INFO, "Exposing.");
 542   buf = htons((unsigned short) C_SHUTTER((cam->frametype == FLI_FRAME_TYPE_DARK)?0:1,
 543                         cam->expmul));
 544   IO(dev, &buf, &wlen, &rlen);
 545
 546   cam->grabrowwidth = cam->image_area.lr.x - cam->image_area.ul.x;
 547   cam->flushcountbeforefirstrow = cam->image_area.ul.y;
 548   cam->flushcountafterlastrow =
 549     (cam->ccd.array_area.lr.y - cam->ccd.array_area.ul.y) -
 550     ((cam->image_area.lr.y - cam->image_area.ul.y) * cam->vbin) -
 551     cam->image_area.ul.y;
 552
 553   if (cam->flushcountafterlastrow < 0)
 554     cam->flushcountafterlastrow = 0;
 555
 556   cam->grabrowcount = cam->image_area.lr.y - cam->image_area.ul.y;
 557
 558   return 0;
 559 }
 560
 561 long fli_camera_parport_flush_rows(flidev_t dev, long rows, long repeat)
 562 {
 563   flicamdata_t *cam;
 564   double dTm;
 565   long rlen, wlen;
 566   unsigned short buf;
 567
 568   if (rows < 0)
 569     return -EINVAL;
 570
 571   if (rows == 0)
 572     return 0;
 573
 574   cam = DEVICE->device_data;
 575
 576   dTm = ((25e-6) / (cam->hflushbin / 2)) * cam->ccd.array_area.lr.x + 1e-3;
 577   dTm = dTm * rows;
 578   dTm = dTm / 1e-6;
 579   cam->readto = (long)dTm;
 580   cam->writeto = (long)dTm;
 581
 582   while (repeat>0)
 583   {
 584     long retval;
 585
 586     rlen = 2; wlen = 2;
 587     buf = htons((unsigned short) C_FLUSH(rows));
 588     retval = DEVICE->fli_io(dev, &buf, &wlen, &rlen);
 589     if (retval != 0)
 590     {
 591       cam->readto = 1000;
 592       cam->writeto = 1000;
 593       return retval;
 594     }
 595     repeat--;
 596   }
 597
 598   return 0;
 599 }
 600
 601 long fli_camera_parport_set_bit_depth(flidev_t dev, flibitdepth_t bitdepth)
 602 {
 603   flicamdata_t *cam;
 604
 605   cam = DEVICE->device_data;
 606
 607   if (DEVICE->devinfo.type != 0x01) /* IMG cameras only support this */
 608     return -EINVAL;
 609
 610   if ((bitdepth != FLI_MODE_8BIT) && (bitdepth != FLI_MODE_16BIT))
 611   {
 612     debug(FLIDEBUG_FAIL, "Invalid bit depth setting.");
 613     return -EINVAL;
 614   }
 615
 616   cam->bitdepth = bitdepth;
 617
 618   return 0;
 619 }
 620
 621 static void correctioportdatawrite(flidev_t dev, unsigned short *Data)
 622 {
 623   unsigned short data;
 624
 625   data = 0;
 626
 627   switch(DEVICE->devinfo.hwrev)
 628   {
 629   case 0x01:
 630     data |= (*Data & FLICCD_IO_P0)?0x01:0;
 631     data |= (*Data & FLICCD_IO_P1)?0x02:0;
 632     data |= (*Data & FLICCD_IO_P2)?0x04:0;
 633     data |= (*Data & FLICCD_IO_P3)?0x80:0;
 634     break;
 635
 636   case 0x02:
 637     data |= (*Data & FLICCD_IO_P0)?0x08:0;
 638     data |= (*Data & FLICCD_IO_P1)?0x10:0;
 639     data |= (*Data & FLICCD_IO_P2)?0x20:0;
 640     data |= (*Data & FLICCD_IO_P3)?0x40:0;
 641     break;
 642
 643   default:
 644     break;
 645   }
 646
 647   *Data = data;
 648
 649   return;
 650 }
 651
 652 static void correctioportdataread(flidev_t dev, unsigned short *Data)
 653 {
 654   unsigned short data;
 655
 656   data = 0;
 657
 658   switch (DEVICE->devinfo.hwrev)
 659   {
 660   case 0x01:
 661     data |= (*Data & 0x01)?FLICCD_IO_P0:0;
 662     data |= (*Data & 0x02)?FLICCD_IO_P1:0;
 663     data |= (*Data & 0x04)?FLICCD_IO_P2:0;
 664     data |= (*Data & 0x80)?FLICCD_IO_P3:0;
 665     break;
 666
 667   case 0x02:
 668     data |= (*Data & 0x08)?FLICCD_IO_P0:0;
 669     data |= (*Data & 0x10)?FLICCD_IO_P1:0;
 670     data |= (*Data & 0x20)?FLICCD_IO_P2:0;
 671     data |= (*Data & 0x40)?FLICCD_IO_P3:0;
 672     break;
 673
 674   default:
 675     break;
 676   }
 677
 678   *Data = data;
 679
 680   return;
 681 }
 682
 683 long fli_camera_parport_read_ioport(flidev_t dev, long *ioportset)
 684 {
 685   long rlen, wlen;
 686   unsigned short buf;
 687
 688   rlen = 2; wlen = 2;
 689   buf = htons(0x7900);
 690   IO(dev, &buf, &wlen, &rlen);
 691
 692   *ioportset = ntohs(buf) & 0x00ff;
 693   correctioportdataread(dev, (unsigned short *) ioportset);
 694
 695   return 0;
 696 }
 697
 698 long fli_camera_parport_write_ioport(flidev_t dev, long ioportset)
 699 {
 700   long rlen, wlen;
 701   unsigned short buf = (unsigned short) ioportset;
 702
 703   correctioportdatawrite(dev, &buf);
 704   buf = htons((unsigned short) (0x7100 | (buf & 0x00ff)));
 705
 706   rlen = 2; wlen = 2;
 707   IO(dev, &buf, &wlen, &rlen);
 708
 709   return 0;
 710 }
 711
 712 long fli_camera_parport_configure_ioport(flidev_t dev, long ioportset)
 713 {
 714   long rlen, wlen;
 715   unsigned short buf = (unsigned short) ioportset;
 716
 717   correctioportdatawrite(dev, &buf);
 718   buf = htons((unsigned short) (0x7000 | (buf & 0x00ff)));
 719
 720   rlen = 2; wlen = 2;
 721   IO(dev, &buf, &wlen, &rlen);
 722
 723   return 0;
 724 }
 725
 726 long fli_camera_parport_control_shutter(flidev_t dev, long shutter)
 727 {
 728   long rlen, wlen;
 729   unsigned short buf;
 730
 731   rlen = 2; wlen = 2;
 732   buf = htons(D_EXPDUR(0));
 733   IO(dev, &buf, &wlen, &rlen);
 734
 735   switch (shutter)
 736   {
 737   case FLI_SHUTTER_CLOSE:
 738     debug(FLIDEBUG_INFO, "Closing shutter.");
 739     buf = htons(C_SHUTTER(0, 0));
 740     IO(dev, &buf, &wlen, &rlen);
 741     break;
 742
 743   case FLI_SHUTTER_OPEN:
 744     buf = htons(C_SHUTTER(1, 1));
 745     IO(dev, &buf, &wlen, &rlen);
 746     break;
 747
 748   default:
 749     return -EINVAL;
 750   }
 751
 752   return 0;
 753 }