FreeBSD/Linux Kernel Cross Reference
sys/i386/isa/qcamio.c

     /*
      * Connectix QuickCam parallel-port camera video capture driver.
      * Copyright (c) 1996, Paul Traina.
      *
      * This driver is based in part on work
      * Copyright (c) 1996, Thomas Davis.
      *
      * Additional ideas from code written by Michael Chinn and Nelson Minar.
      *
     * QuickCam(TM) is a registered trademark of Connectix Inc.
     * Use this driver at your own risk, it is not warranted by
     * Connectix or the authors.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions
     * are met:
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer
     *    in this position and unchanged.
     * 2. Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     * 3. The name of the author may not be used to endorse or promote products
     *    derived from this software withough specific prior written permission
     *
     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     */
    
    #ifndef NQCAM
    #include        "qcam.h"                /* this file defines NQCAM _only_ */
    #endif
    
    #if NQCAM > 0
    
    #if defined(__FreeBSD__) || defined(__NetBSD__)
    #include        <sys/param.h>
    #include        <machine/cpufunc.h>
    #ifdef  KERNEL
    #include        <sys/systm.h>
    #include        <machine/clock.h>
    #include        <machine/qcam.h>
    #else   /* user mode version of driver */
    #include        <unistd.h>
    #include        <stdio.h>
    #include        "qcam.h"
    #endif  /* KERNEL */
    #endif  /* FreeBSD or NetBSD */
    
    #ifdef  bsdi
    #include        <sys/param.h>
    #include        <sys/conf.h>
    #include        <sys/device.h>
    #include        "qcam.h"
    #endif  /* bsdi */
    
    #ifdef  __linux__
    #include        <linux/kernel.h>
    #include        <linux/sched.h>
    #include        <linux/string.h>
    #include        <linux/delay.h>
    #include        <asm/io.h>
    #include        "qcam-linux.h"
    #include        "qcam.h"
    #endif  /* __linux__ */
    
    #ifdef  _SCO_DS
    #include        <limits.h>
    #include        <errno.h>
    #include        <sys/types.h>
    #include        "qcam-sco.h"
    #include        "qcam.h"
    #endif
    
    #ifdef __FreeBSD__
    #include        <i386/isa/qcamreg.h>
    #include        <i386/isa/qcamdefs.h>
    #else
    #include        "qcamreg.h"
    #include        "qcamdefs.h"
    #endif
    
    /*
     * There should be _NO_ operating system dependant code or definitions
     * past this point.
     */
    
    static const u_char qcam_zoommode[3][3] = {
            { QC_XFER_WIDE,   QC_XFER_WIDE,   QC_XFER_WIDE },
            { QC_XFER_NARROW, QC_XFER_WIDE,   QC_XFER_WIDE },
            { QC_XFER_TIGHT,  QC_XFER_NARROW, QC_XFER_WIDE }
   };
   
   static int qcam_timeouts;
   
   #ifdef  QCAM_GRAB_STATS
   
   #define STATBUFSIZE (QC_MAXFRAMEBUFSIZE*2+50)
   static u_short qcam_rsbhigh[STATBUFSIZE];
   static u_short qcam_rsblow[STATBUFSIZE];
   static u_short *qcam_rsbhigh_p   = qcam_rsbhigh;
   static u_short *qcam_rsblow_p    = qcam_rsblow;
   static u_short *qcam_rsbhigh_end = &qcam_rsbhigh[STATBUFSIZE];
   static u_short *qcam_rsblow_end  = &qcam_rsblow[STATBUFSIZE];
   
   #define STATHIGH(T) \
           if (qcam_rsbhigh_p < qcam_rsbhigh_end) \
                   *qcam_rsbhigh_p++ = ((T) - timeout); \
           if (!timeout) qcam_timeouts++;
   
   #define STATLOW(T) \
           if (qcam_rsblow_p < qcam_rsblow_end) \
                   *qcam_rsblow_p++ = ((T) - timeout); \
           if (!timeout) qcam_timeouts++;
   
   #else
   
   #define STATHIGH(T)     if (!timeout) qcam_timeouts++;
   #define STATLOW(T)      if (!timeout) qcam_timeouts++;
   
   #endif  /* QCAM_GRAB_STATS */
   
   #define READ_STATUS_BYTE_HIGH(P, V, T) { \
           u_short timeout = (T); \
           do { (V) = read_status((P)); \
           } while (!(((V) & 0x08)) && --timeout); STATHIGH(T) \
   }
   
   #define READ_STATUS_BYTE_LOW(P, V, T) { \
           u_short timeout = (T); \
           do { (V) = read_status((P)); \
           } while (((V) & 0x08) && --timeout); STATLOW(T) \
   }
                   
   #define READ_DATA_WORD_HIGH(P, V, T) { \
           u_int timeout = (T); \
           do { (V) = read_data_word((P)); \
           } while (!((V) & 0x01) && --timeout); STATHIGH(T) \
   }
   
   #define READ_DATA_WORD_LOW(P, V, T) { \
           u_int timeout = (T); \
           do { (V) = read_data_word((P)); \
           } while (((V) & 0x01) && --timeout); STATLOW(T) \
   }
   
   inline static int
   sendbyte (u_int port, int value, int sdelay)
   {
           u_char s1, s2;
   
           write_data(port, value);
           if (sdelay) {
               DELAY(sdelay);
               write_data(port, value);
           }
   
           write_control(port, QC_CTL_HIGHNIB);
           READ_STATUS_BYTE_HIGH(port, s1, QC_TIMEOUT_CMD);
   
           write_control(port, QC_CTL_LOWNIB);
           READ_STATUS_BYTE_LOW(port, s2, QC_TIMEOUT_CMD);
   
           return (s1 & 0xf0) | (s2 >> 4);
   }
   
   static int
   send_command (struct qcam_softc *qs, int cmd, int value)
   {
           if (sendbyte(qs->iobase, cmd, qs->exposure) != cmd)
                   return 1;
   
           if (sendbyte(qs->iobase, value, qs->exposure) != value)
                   return 1;
   
           return 0;                       /* success */
   }
   
   static int
   send_xfermode (struct qcam_softc *qs, int value)
   {
           if (sendbyte(qs->iobase, QC_XFERMODE, qs->exposure) != QC_XFERMODE)
                   return 1;
   
           if (sendbyte(qs->iobase, value, qs->exposure) != value)
                   return 1;
   
           return 0;
   }
   
   void
   qcam_reset (struct qcam_softc *qs)
   {
           register u_int  iobase = qs->iobase;
           register u_char result;
   
           write_control(iobase, 0x20);
           write_data   (iobase, 0x75);
   
           result = read_data(iobase);
   
           if ((result != 0x75) && !(qs->flags & QC_FORCEUNI))
               qs->flags |= QC_BIDIR_HW;   /* bidirectional parallel port */
           else
               qs->flags &= ~QC_BIDIR_HW;
   
           write_control(iobase, 0x0b);
           DELAY(250);
           write_control(iobase, QC_CTL_LOWNIB);
           DELAY(250);
   }
   
   static int
   qcam_waitfor_bi (u_int port)
   {
           u_char s1, s2;
   
           write_control(port, QC_CTL_HIGHWORD);
           READ_STATUS_BYTE_HIGH(port, s1, QC_TIMEOUT_INIT);
   
           write_control(port, QC_CTL_LOWWORD);
           READ_STATUS_BYTE_LOW(port, s2, QC_TIMEOUT);
   
           return (s1 & 0xf0) | (s2 >> 4);
   }
   
   /*
    * The pixels are read in 16 bits at a time, and we get 3 valid pixels per
    * 16-bit read.  The encoding format looks like this:
    *
    * |---- status reg -----| |----- data reg ------|
    * 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
    *  3  3  3  3  2  x  x  x  2  2  2  1  1  1  1  R
    *
    *  1 = left pixel      R = camera ready
    *  2 = middle pixel    x = unknown/unused?
    *  3 = right pixel
    *
    * XXX do not use this routine yet!  It does not work.
    *     Nelson believes that even though 6 pixels are read in per 2 words,
    *     only the 1 & 2 pixels from the first word are correct.  This seems
    *     bizzare, more study is needed here.
    */
   
   #define DECODE_WORD_BI4BPP(P, W) \
           *(P)++ = 15 - (((W) >> 12) & 0x0f); \
           *(P)++ = 15 - ((((W) >> 8) & 0x08) | (((W) >> 5) & 0x07)); \
           *(P)++ = 15 - (((W) >>  1) & 0x0f);
   
   static void
   qcam_bi_4bit (struct qcam_softc *qs)
   {
           u_char *p;
           u_int   port;
           u_short word;
   
           port = qs->iobase;                      /* for speed */
   
           qcam_waitfor_bi(port);
   
           /*
            * Unlike the other routines, this routine has NOT be interleaved
            * yet because we don't have the algorythm for 4bbp down tight yet,
            * so why add to the confusion?
            */
           for (p = qs->buffer; p < qs->buffer_end; ) {
                   write_control(port, QC_CTL_HIGHWORD);
                   READ_DATA_WORD_HIGH(port, word, QC_TIMEOUT);
                   DECODE_WORD_BI4BPP(p, word);
   
                   write_control(port, QC_CTL_LOWWORD);
                   READ_DATA_WORD_HIGH(port, word, QC_TIMEOUT);
                   DECODE_WORD_BI4BPP(p, word);
           }
   }
   
   /*
    * The pixels are read in 16 bits at a time, 12 of those bits contain
    * pixel information, the format looks like this:
    *
    * |---- status reg -----| |----- data reg ------|
    * 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
    *  2  2  2  2  2  x  x  x  2  1  1  1  1  1  1  R
    *
    * 1 = left pixel               R = camera ready
    * 2 = right pixel              x = unknown/unused?
    */
   
   #define DECODE_WORD_BI6BPP(P, W) \
           *(P)++ = 63 -  (((W) >>  1) & 0x3f); \
           *(P)++ = 63 - ((((W) >> 10) & 0x3e) | (((W) >> 7) & 0x01));
   
   static void
   qcam_bi_6bit (struct qcam_softc *qs)
   {
           u_char *p;
           u_short hi, low;
           u_int   port;
   
           port = qs->iobase;                      /* for speed */
   
           qcam_waitfor_bi(port);
   
           /*
            * This was interleaved before, but I cut it back to the simple
            * mode so that it's easier for people to play with it.  A quick
            * unrolling of the loop coupled with interleaved decoding and I/O
            * should get us a slight CPU bonus later.
            */
           for (p = qs->buffer; p < qs->buffer_end; ) {
                   write_control(port, QC_CTL_HIGHWORD);
                   READ_DATA_WORD_HIGH(port, hi, QC_TIMEOUT);
                   DECODE_WORD_BI6BPP(p, hi);
   
                   write_control(port, QC_CTL_LOWWORD);
                   READ_DATA_WORD_LOW(port, low, QC_TIMEOUT);
                   DECODE_WORD_BI6BPP(p, low);
           }
   }
   
   /*
    * We're doing something tricky here that makes this routine a little
    * more complex than you would expect.  We're interleaving the high
    * and low nibble reads with the math required for nibble munging.
    * This should allow us to use the "free" time while we're waiting for
    * the next nibble to come ready to do any data conversion operations.
    */
   #define DECODE_WORD_UNI4BPP(P, W) \
           *(P)++ = 15 - ((W) >> 4);
   
   static void
   qcam_uni_4bit (struct qcam_softc *qs)
   {
           u_char  *p, *end, hi, low;
           u_int   port;
   
           port = qs->iobase;
           p    = qs->buffer;
           end  = qs->buffer_end - 1;
   
           /* request and wait for first nibble */
   
           write_control(port, QC_CTL_HIGHNIB);
           READ_STATUS_BYTE_HIGH(port, hi, QC_TIMEOUT_INIT);
   
           /* request second nibble, munge first nibble while waiting, read 2nd */
   
           write_control(port, QC_CTL_LOWNIB);
           DECODE_WORD_UNI4BPP(p, hi);
           READ_STATUS_BYTE_LOW(port, low, QC_TIMEOUT);
   
           while (p < end) {
                   write_control(port, QC_CTL_HIGHNIB);
                   DECODE_WORD_UNI4BPP(p, low);
                   READ_STATUS_BYTE_HIGH(port, hi, QC_TIMEOUT);
   
                   write_control(port, QC_CTL_LOWNIB);
                   DECODE_WORD_UNI4BPP(p, hi);
                   READ_STATUS_BYTE_LOW(port, low, QC_TIMEOUT);
           }
           DECODE_WORD_UNI4BPP(p, low);
   }
   
   /*
    * If you treat each pair of nibble operations as pulling in a byte, you
    * end up with a byte stream that looks like this:
    *
    *    msb             lsb
    *      2 2 1 1 1 1 1 1
    *      2 2 2 2 3 3 3 3
    *      3 3 4 4 4 4 4 4
    */
   
   static void
   qcam_uni_6bit (struct qcam_softc *qs)
   {
           u_char  *p;
           u_int   port;
           u_char  word1, word2, word3, hi, low;
   
           port = qs->iobase;
   
           /*
            * This routine has been partially interleaved... we can do a better
            * job, but for right now, I've deliberately kept it less efficient
            * so we can play with decoding without hurting peoples brains.
            */
           for (p = qs->buffer; p < qs->buffer_end; ) {
                   write_control(port, QC_CTL_HIGHNIB);
                   READ_STATUS_BYTE_HIGH(port, hi, QC_TIMEOUT_INIT);
                   write_control(port, QC_CTL_LOWNIB);
                   READ_STATUS_BYTE_LOW(port, low, QC_TIMEOUT);
                   write_control(port, QC_CTL_HIGHNIB);
                   word1 = (hi & 0xf0) | (low >>4);
                   READ_STATUS_BYTE_HIGH(port, hi, QC_TIMEOUT);
                   write_control(port, QC_CTL_LOWNIB);
                   *p++ = 63 - (word1 >> 2);
                   READ_STATUS_BYTE_LOW(port, low, QC_TIMEOUT);
                   write_control(port, QC_CTL_HIGHNIB);
                   word2 = (hi & 0xf0) | (low >> 4);
                   READ_STATUS_BYTE_HIGH(port, hi, QC_TIMEOUT);
                   write_control(port, QC_CTL_LOWNIB);
                   *p++ = 63 - (((word1 & 0x03) << 4) | (word2 >> 4));
                   READ_STATUS_BYTE_LOW(port, low, QC_TIMEOUT);
                   word3 = (hi & 0xf0) | (low >> 4);
                   *p++ = 63 - (((word2 & 0x0f) << 2) | (word3 >> 6));
                   *p++ = 63 - (word3 & 0x3f);
           }
   
           /* XXX this is something xfqcam does, doesn't make sense to me,
              but we don't see timeoutes here... ? */
           write_control(port, QC_CTL_LOWNIB);
           READ_STATUS_BYTE_LOW(port, word1, QC_TIMEOUT);
           write_control(port, QC_CTL_HIGHNIB);
           READ_STATUS_BYTE_LOW(port, word1, QC_TIMEOUT);
   }
   
   static void
   qcam_xferparms (struct qcam_softc *qs)
   {
           int bidir;
   
           qs->xferparms = 0;
   
           bidir = (qs->flags & QC_BIDIR_HW);
           if (bidir)
                   qs->xferparms |= QC_XFER_BIDIR;
   
           if (qcam_debug)
                   printf("qcam%d: %dbpp %sdirectional scan mode selected\n",
                           qs->unit, qs->bpp, bidir ? "bi" : "uni");
   
           if (qs->bpp == 6) {
                   qs->xferparms |= QC_XFER_6BPP;
                   qs->scanner    = bidir ? qcam_bi_6bit : qcam_uni_6bit;
           } else {
                   qs->scanner    = bidir ? qcam_bi_4bit : qcam_uni_4bit;
           }
   
           if (qs->x_size > 160 || qs->y_size > 120) {
                   qs->xferparms |= qcam_zoommode[0][qs->zoom];
           } else if (qs->x_size > 80 || qs->y_size > 60) {
                   qs->xferparms |= qcam_zoommode[1][qs->zoom];
           } else
                   qs->xferparms |= qcam_zoommode[2][qs->zoom];
   }
   
   static void
   qcam_init (struct qcam_softc *qs)
   {
           int x_size = (qs->bpp == 4) ? qs->x_size / 2 : qs->x_size / 4;
   
           qcam_xferparms(qs);
   
           send_command(qs, QC_BRIGHTNESS,   qs->brightness);
           send_command(qs, QC_BRIGHTNESS,   1);
           send_command(qs, QC_BRIGHTNESS,   1);
           send_command(qs, QC_BRIGHTNESS,   qs->brightness);
           send_command(qs, QC_BRIGHTNESS,   qs->brightness);
           send_command(qs, QC_BRIGHTNESS,   qs->brightness);
           send_command(qs, QC_YSIZE,        qs->y_size);
           send_command(qs, QC_XSIZE,        x_size);
           send_command(qs, QC_YORG,         qs->y_origin);
           send_command(qs, QC_XORG,         qs->x_origin);
           send_command(qs, QC_CONTRAST,     qs->contrast);
           send_command(qs, QC_WHITEBALANCE, qs->whitebalance);
   
           if (qs->buffer)
               qs->buffer_end = qs->buffer +
                                min((qs->x_size*qs->y_size), QC_MAXFRAMEBUFSIZE);
   
           qs->init_req = 0;
   }
   
   int
   qcam_scan (struct qcam_softc *qs)
   {
           int timeouts;
   
   #ifdef  QCAM_GRAB_STATS
           bzero(qcam_rsbhigh, sizeof(qcam_rsbhigh));
           bzero(qcam_rsblow,  sizeof(qcam_rsblow));
           qcam_rsbhigh_p = qcam_rsbhigh;
           qcam_rsblow_p  = qcam_rsblow;
   #endif
   
           timeouts = qcam_timeouts;
   
           if (qs->init_req)
                   qcam_init(qs);
   
           if (send_xfermode(qs, qs->xferparms))
                   return 1;
   
           if (qcam_debug && (timeouts != qcam_timeouts))
                   printf("qcam%d: %d timeouts during init\n", qs->unit,
                           qcam_timeouts - timeouts);
   
           timeouts = qcam_timeouts;
   
           if (qs->scanner)
                   (*qs->scanner)(qs);
           else
                   return 1;
   
           if (qcam_debug && (timeouts != qcam_timeouts))
                   printf("qcam%d: %d timeouts during scan\n", qs->unit,
                           qcam_timeouts - timeouts);
   
           write_control(qs->iobase, 0x0f);
   
           return 0;                       /* success */
   }
   
   void
   qcam_default (struct qcam_softc *qs)
   {
           qs->contrast     = QC_DEF_CONTRAST;
           qs->brightness   = QC_DEF_BRIGHTNESS;
           qs->whitebalance = QC_DEF_WHITEBALANCE;
           qs->x_size       = QC_DEF_XSIZE;
           qs->y_size       = QC_DEF_YSIZE;
           qs->x_origin     = QC_DEF_XORG;
           qs->y_origin     = QC_DEF_YORG;
           qs->bpp          = QC_DEF_BPP;
           qs->zoom         = QC_DEF_ZOOM;
           qs->exposure     = QC_DEF_EXPOSURE;
   }
   
   int
   qcam_ioctl_get (struct qcam_softc *qs, struct qcam *info)
   {
           info->qc_version        = QC_IOCTL_VERSION;
           info->qc_xsize          = qs->x_size;
           info->qc_ysize          = qs->y_size;
           info->qc_xorigin        = qs->x_origin;
           info->qc_yorigin        = qs->y_origin;
           info->qc_bpp            = qs->bpp;
           info->qc_zoom           = qs->zoom;
           info->qc_exposure       = qs->exposure;
           info->qc_brightness     = qs->brightness;
           info->qc_whitebalance   = qs->whitebalance;
           info->qc_contrast       = qs->contrast;
   
           return 0;               /* success */
   }
   
   int
   qcam_ioctl_set (struct qcam_softc *qs, struct qcam *info)
   {
           /*
            * sanity check parameters passed in by user
            * we're extra paranoid right now because the API
            * is in flux
            */
           if (info->qc_xsize        > QC_MAX_XSIZE        ||
               info->qc_ysize        > QC_MAX_YSIZE        ||
               info->qc_xorigin      > QC_MAX_XSIZE        ||
               info->qc_yorigin      > QC_MAX_YSIZE        ||
               (info->qc_bpp != 4 && info->qc_bpp != 6)    ||
               info->qc_zoom         > QC_ZOOM_200         ||
               info->qc_brightness   > UCHAR_MAX           ||
               info->qc_whitebalance > UCHAR_MAX           ||
               info->qc_contrast     > UCHAR_MAX)
           return 1;               /* failure */
   
           /* version check */
           if (info->qc_version != QC_IOCTL_VERSION)
                   return 1;       /* failure */
   
           qs->x_size        = info->qc_xsize;
           qs->y_size        = info->qc_ysize;
           qs->x_origin      = info->qc_xorigin;
           qs->y_origin      = info->qc_yorigin;
           qs->bpp           = info->qc_bpp;
           qs->zoom          = info->qc_zoom;
           qs->exposure      = info->qc_exposure;
           qs->brightness    = info->qc_brightness;
           qs->whitebalance  = info->qc_whitebalance;
           qs->contrast      = info->qc_contrast;
   
           /* request initialization before next scan pass */
           qs->init_req = 1;
   
           return 0;               /* success */
   }
   
   #ifndef QCAM_INVASIVE_SCAN
   /*
    * Attempt a non-destructive probe for the QuickCam.
    * Current models appear to toggle the upper 4 bits of
    * the status register at approximately 5-10 Hz.
    *
    * Be aware that this isn't the way that Connectix detects the
    * camera (they send a reset and try to handshake),  but this
    * way is safe.
    */
   int
   qcam_detect (u_int port)
   {
           int i, transitions = 0;
           u_char reg, last;
   
           write_control(port, 0x20);
           write_control(port, 0x0b);
           write_control(port, 0x0e);
   
           last = reg = read_status(port);
   
           for (i = 0; i < QC_PROBELIMIT; i++) {
               reg = read_status(port) & 0xf0;
   
               if (reg != last)    /* if we got a toggle, count it */
                   transitions++;
   
               last = reg;
               LONGDELAY(100000);  /* 100ms */
           }
   
           return transitions >= QC_PROBECNTLOW &&
                  transitions <= QC_PROBECNTHI;
   }
   #else
   /*
    * This form of probing for the camera can cause garbage to show
    * up on your printers if they're plugged in instead.  However,
    * some folks have a problem with the nondestructive scan when
    * using EPP/ECP parallel ports.
    *
    * Try to send down a brightness command, if we succeed, we've
    * got a camera on the remote side.
    */
   int
   qcam_detect (u_int port)
   {
           write_control(port, 0x20);
           write_data(port, 0x75);
           read_data(port);
           write_control(port, 0x0b);
           DELAY(250);
           write_control(port, 0x0e);
           DELAY(250);
   
           if (sendbyte(port, QC_BRIGHTNESS, QC_DEF_EXPOSURE) != QC_BRIGHTNESS)
                   return 0;       /* failure */
           return (sendbyte(port, 1, QC_DEF_EXPOSURE) == 1);
   }
   #endif
   
   #endif /* NQCAM */

Cache object: 13a7deeb0e839b49774acf6612622ea2