spca5xx.c

linux下的摄像头驱动

      {
	alt = 8;
      }
    else
      {
	alt = SPCA50X_ALT_SIZE_1023;
      }
  else
    {
      /* if an unrecognised size, default to the minimum */
      PDEBUG (5, "Set packet size: invalid size (%d), defaulting to %d",
	      size, SPCA50X_ALT_SIZE_128);
      alt = SPCA50X_ALT_SIZE_128;
    }


  PDEBUG (5, "iface alt: %d %d ", spca50x->iface, alt);
  if (usb_set_interface (spca50x->dev, spca50x->iface, alt) < 0)
    {
      err ("Set packet size: set interface error");
      return -EBUSY;
    }

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,3)
  intf = usb_ifnum_to_if (dev, spca50x->iface);
  if (intf)
    {
      interface = usb_altnum_to_altsetting (intf, alt);
    }
  else
    {
      PDEBUG (0, "intf not found");
      return -ENXIO;
    }
  mysize = (interface->endpoint[0].desc.wMaxPacketSize);
#else
  interface = &config->interface[spca50x->iface].altsetting[alt];
  mysize = (interface->endpoint[0].wMaxPacketSize);
#endif

  PDEBUG (1, "set real packet size: %d, alt=%d", mysize, alt);
  spca50x->packet_size = mysize;
  spca50x->alt = alt;
  return 0;
}

/* Returns number of bits per pixel (regardless of where they are located; planar or
 * not), or zero for unsupported format.
 */
static int
spca5xx_get_depth (struct usb_spca50x *spca50x, int palette)
{
  switch (palette)
    {
//      case VIDEO_PALETTE_GREY:     return 8;
    case VIDEO_PALETTE_RGB565:
      return 16;
    case VIDEO_PALETTE_RGB24:
      return 24;

//      case VIDEO_PALETTE_YUV422:   return 16;
//      case VIDEO_PALETTE_YUYV:     return 16;
//      case VIDEO_PALETTE_YUV420:   return 24;
    case VIDEO_PALETTE_YUV420P:
      return 12;		/* strange need 12 this break the read method for this planar mode (6*8/4) */
//      case VIDEO_PALETTE_YUV422P:  return 24; /* Planar */

    case VIDEO_PALETTE_RGB32:
      return 32;
    case VIDEO_PALETTE_RAW_JPEG:
      return 24;		/* raw jpeg. what should we return ?? */
    case VIDEO_PALETTE_JPEG:
      if (spca50x->cameratype == JPEG ||
	  spca50x->cameratype == JPGH || spca50x->cameratype == JPGC)
	{
	  return 8;
	}
      else
	return 0;
    default:
      return 0;			/* Invalid format */
    }
}

/**********************************************************************
* spca50x_isoc_irq
* Function processes the finish of the USB transfer by calling 
* spca50x_move_data function to move data from USB buffer to internal
* driver structures 
***********************************************************************/
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
static void
spca50x_isoc_irq (struct urb *urb, struct pt_regs *regs)
{
  int i;
#else
static void
spca50x_isoc_irq (struct urb *urb)
{
#endif
  int len;
  struct usb_spca50x *spca50x;

  if (!urb->context)
    {
      PDEBUG (4, "no context");
      return;
    }

  spca50x = (struct usb_spca50x *) urb->context;

  if (!spca50x->dev)
    {
      PDEBUG (4, "no device ");
      return;
    }
  if (!spca50x->user)
    {
      PDEBUG (4, "device not open");
      return;
    }
  if (!spca50x->streaming)
    {
      /* Always get some of these after close but before packet engine stops */
      PDEBUG (4, "hmmm... not streaming, but got interrupt");
      return;
    }
  if (!spca50x->present)
    {
      /*  */
      PDEBUG (4, "device disconnected ..., but got interrupt !!");
      return;
    }
  /* Copy the data received into our scratch buffer */
  if (spca50x->curframe >= 0)
    {
      len = spca50x_move_data (spca50x, urb);
    }
  else if (waitqueue_active (&spca50x->wq))
    {
      wake_up_interruptible (&spca50x->wq);
    }

  /* Move to the next sbuf */
  spca50x->cursbuf = (spca50x->cursbuf + 1) % SPCA50X_NUMSBUF;

  urb->dev = spca50x->dev;
  urb->status = 0;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 4)
  if ((i = usb_submit_urb (urb, GFP_ATOMIC)) != 0)
    err ("usb_submit_urb() ret %d", i);
#else
/* If we use urb->next usb_submit_urb() is not need in 2.4.x */
  //if ((i = usb_submit_urb(urb)) != 0)
  //err("usb_submit_urb() ret %d", i);
#endif


  /* let's try to set up brightness for the next frame */
  if (autoadjust && !spca50x->bh_requested)
    {
      spca50x->task.data = spca50x;
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
      spca50x->task.func = auto_bh;
      schedule_work (&spca50x->task);
#else
      spca50x->task.sync = 0;
      spca50x->task.routine = auto_bh;
      SCHEDULE_TASK (&spca50x->task);
#endif
      spca50x->bh_requested = 1;
    }

  return;
}


/**********************************************************************
* spca50x_init_isoc
* Function starts the ISO USB transfer by enabling this process
* from USB side and enabling ISO machine from the chip side
***********************************************************************/
static inline void
spcaCameraStart (struct usb_spca50x *spca50x)
{
  int err_code;
  struct usb_device *dev = spca50x->dev;
  switch (spca50x->bridge)
    {
    case BRIDGE_CX11646:
      cx11646_start (spca50x);
      break;
    case BRIDGE_ZC3XX:
      zc3xx_start (spca50x);
      break;
    case BRIDGE_SONIX:
      sonix_start (spca50x);
      break;
    case BRIDGE_SPCA500:
      {
	err_code = spca500_initialise (spca50x);
	break;
      }

    case BRIDGE_SPCA501:
      {
	/* Enable ISO packet machine CTRL reg=2,
	 * index=1 bitmask=0x2 (bit ordinal 1)
	 */
	err_code = spca50x_reg_write (dev, SPCA501_REG_CTLRL,
				      (__u16) 0x1, (__u16) 0x2);
	break;
      }

    case BRIDGE_SPCA504:
      spca504_initialize (spca50x);
      break;
    case BRIDGE_SPCA504_PCCAM600:
      {				/* specific code for clicsmart is in pccam600 */
	spca504_pccam600_initialize (spca50x);
	break;
      }
    case BRIDGE_SPCA536:
      {
	spca536_start (spca50x);
	break;
      }
    case BRIDGE_SPCA533:
    case BRIDGE_SPCA504B:
      {
	spca504B_start (spca50x);
	break;
      }
    case BRIDGE_SPCA506:
      spca506_start (spca50x);

      break;
    case BRIDGE_SPCA505:

      {
	//nessesary because without it we can see stream only once after loading module
	//stopping usb registers Tomasz change
	spca50x_reg_write (dev, 0x2, 0x0, 0x0);

	/* Enable ISO packet machine - should we do this here or in ISOC init ? */
	err_code = spca50x_reg_write (dev, SPCA50X_REG_USB,
				      SPCA50X_USB_CTRL, SPCA50X_CUSB_ENABLE);

//                      spca50x_reg_write(dev, 0x5, 0x0, 0x0);
//                      spca50x_reg_write(dev, 0x5, 0x0, 0x1);
//                      spca50x_reg_write(dev, 0x5, 0x11, 0x2);
	break;
      }

    case BRIDGE_SPCA508:
      err_code = spca50x_reg_write (dev, 0, 0x8112, 0x10 | 0x20);
      break;
    case BRIDGE_SPCA561:
      {
	/* Video ISO enable, Video Drop Packet enable: */
	spca561_start (spca50x);	//spca50x_reg_write(dev, 0, 0x8112, 0x10 | 0x20); 
	break;
      }
    case BRIDGE_TV8532:
      {
	tv8532_start (spca50x);
	break;
      }
    }

}

static inline void
spcaCameraStop (struct usb_spca50x *spca50x)
{

  switch (spca50x->bridge)
    {
    case BRIDGE_CX11646:
      /* deferred after set_alt(0,0) 
         cx11646_stop(spca50x); 
       */
      break;
    case BRIDGE_ZC3XX:
      zc3xx_stop (spca50x);
      break;
    case BRIDGE_SONIX:
      sonix_stop (spca50x);
      break;
    case BRIDGE_SPCA500:
      {
	/* stop the transfer */
	// Tha's the code need for familycam 300
	//spca50x_reg_write(spca50x->dev, 0x00, 0x8000, 0x0000);
	/*
	   spca50x_reg_write(spca50x->dev, 0xe1, 0x0001, 0x0000);
	   if (spca50x_reg_readwait(spca50x->dev, 0x06, 0, 0) != 0)
	   {
	   PDEBUG(2, "spca50x_reg_readwait() failed");
	   }

	   spca50x_reg_write(spca50x->dev, 0x0c, 0x0000, 0x0000);
	   spca50x_reg_write(spca50x->dev, 0x30, 0x0000, 0x0004);
	   if (spca500_full_reset(spca50x) < 0)
	   {
	   PDEBUG(2, "spca50x_full_reset() failed");
	   }
	 */
	break;
      }
    case BRIDGE_SPCA501:
      {
	/* Disable ISO packet machine CTRL reg=2, index=1 bitmask=0x0 (bit ordinal 1) */
	spca50x_reg_write (spca50x->dev, SPCA501_REG_CTLRL,
			   (__u16) 0x1, (__u16) 0x0);
	break;
      }
    case BRIDGE_SPCA504_PCCAM600:
    case BRIDGE_SPCA504:
      spca50x_reg_write (spca50x->dev, 0x00, 0x2000, 0x0000);

      if (spca50x->desc == AiptekMiniPenCam13)
	{
	  /* spca504a aiptek */

	  spca504A_acknowledged_command (spca50x, 0x08, 6, 0, 0x86, 1);
	  spca504A_acknowledged_command (spca50x, 0x24, 0x0000, 0x0000, 0x9d,
					 1);
	  spca504A_acknowledged_command (spca50x, 0x01, 0x000f, 0x0000, 0xFF,
					 1);
	}
      else
	{
	  spca504_acknowledged_command (spca50x, 0x24, 0x0000, 0x0000);
	  spca50x_reg_write (spca50x->dev, 0x01, 0x000f, 0x0);
	}
      break;
    case BRIDGE_SPCA536:
      {
	spca536_stop (spca50x);
      }
    case BRIDGE_SPCA533:
    case BRIDGE_SPCA504B:
      {
	spca504B_stop (spca50x);
	break;
      }
    case BRIDGE_SPCA505:
      {
	spca50x_reg_write (spca50x->dev, 0x2, 0x0, 0x0);	//Disable ISO packet machine
	break;
      }
    case BRIDGE_SPCA506:
      spca506_stop (spca50x);
      break;
    case BRIDGE_SPCA508:
      {
	// Video ISO disable, Video Drop Packet enable:
	spca50x_reg_write (spca50x->dev, 0, 0x8112, 0x20);
	break;
      }
    case BRIDGE_SPCA561:
      {
	// Video ISO disable, Video Drop Packet enable:
	spca561_stop (spca50x);	//spca50x_reg_write(spca50x->dev, 0, 0x8112, 0x20); 
	break;
      }
    case BRIDGE_TV8532:
      {
	tv8532_stop (spca50x);
	break;
      }
    }

}
static int
spca50x_init_isoc (struct usb_spca50x *spca50x)
{

  struct urb *urb;
  int fx, err, n;
  int intpipe;
  PDEBUG (3, "*** Initializing capture ***");

  spca50x->compress = 0;
  spca50x->curframe = 0;
  spca50x->cursbuf = 0;
  spca50x->scratchlen = 0;

  spca50x_set_packet_size (spca50x, spca50x->pipe_size);
  PDEBUG (2, "setpacketsize %d", spca50x->pipe_size);

  for (n = 0; n < SPCA50X_NUMSBUF; n++)
    {
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
      urb = usb_alloc_urb (FRAMES_PER_DESC, GFP_KERNEL);
#else
      urb = usb_alloc_urb (FRAMES_PER_DESC);
#endif
      if (!urb)
	{
	  err ("init isoc: usb_alloc_urb ret. NULL");
	  return -ENOMEM;
	}
      spca50x->sbuf[n].urb = urb;
      urb->dev = spca50x->dev;
      urb->context = spca50x;
      urb->pipe = usb_rcvisocpipe (spca50x->dev, SPCA50X_ENDPOINT_ADDRESS);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
      urb->transfer_flags = URB_ISO_ASAP;
      urb->interval = 1;
#else
      urb->transfer_flags = USB_ISO_ASAP;
#endif
      urb->transfer_buffer = spca50x->sbuf[n].data;
      urb->complete = spca50x_isoc_irq;
      urb->number_of_packets = FRAMES_PER_DESC;
      urb->transfer_buffer_length = spca50x->packet_size * FRAMES_PER_DESC;
      for (fx = 0; fx < FRAMES_PER_DESC; fx++)
	{
	  urb->iso_frame_desc[fx].offset = spca50x->packet_size * fx;
	  urb->iso_frame_desc[fx].length = spca50x->packet_size;
	}
    }

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,41)
  spca50x->sbuf[SPCA50X_NUMSBUF - 1].urb->next = spca50x->sbuf[0].urb;
  for (n = 0; n < SPCA50X_NUMSBUF - 1; n++)
    spca50x->sbuf[n].urb->next = spca50x->