drivers/usb/cpia.c

   1 /*
   2  * USB CPiA Video Camera driver
   3  *
   4  * Supports CPiA based Video Camera's. Many manufacturers use this chipset.
   5  * There's a good chance, if you have a USB video camera, it's a CPiA based
   6  * one
   7  *
   8  * (C) Copyright 1999 Johannes Erdfelt
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/sched.h>
  13 #include <linux/list.h>
  14 #include <linux/malloc.h>
  15 #include <linux/mm.h>
  16 #include <linux/smp_lock.h>
  17 #include <linux/videodev.h>
  18 #include <linux/vmalloc.h>
  19 #include <linux/wrapper.h>
  20 #include <linux/module.h>
  21
  22 #include <asm/spinlock.h>
  23 #include <asm/io.h>
  24
  25 #include "usb.h"
  26 #include "cpia.h"
  27
  28 #define CPIA_DEBUG      /* Gobs of debugging info */
  29
  30 #define MAX_FRAME_SIZE (384 * 288 * 3)
  31
  32 /*******************************/
  33 /* Memory management functions */
  34 /*******************************/
  35
  36 /* convert virtual user memory address to physical address */
  37 /* (virt_to_phys only works for kmalloced kernel memory) */
  38
  39 static inline unsigned long uvirt_to_phys(unsigned long adr)
  40 {
  41         pgd_t *pgd;
  42         pmd_t *pmd;
  43         pte_t *ptep, pte;
  44
  45         pgd = pgd_offset(current->mm, adr);
  46         if (pgd_none(*pgd))
  47                 return 0;
  48         pmd = pmd_offset(pgd, adr);
  49         if (pmd_none(*pmd))
  50                 return 0;
  51         ptep = pte_offset(pmd, adr/*&(~PGDIR_MASK)*/);
  52         pte = *ptep;
  53         if(pte_present(pte))
  54                 return
  55                   virt_to_phys((void *)(pte_page(pte)|(adr&(PAGE_SIZE-1))));
  56         return 0;
  57 }
  58
  59 static inline unsigned long uvirt_to_bus(unsigned long adr)
  60 {
  61         return virt_to_bus(phys_to_virt(uvirt_to_phys(adr)));
  62 }
  63
  64 /* convert virtual kernel memory address to physical address */
  65 /* (virt_to_phys only works for kmalloced kernel memory) */
  66
  67 static inline unsigned long kvirt_to_phys(unsigned long adr)
  68 {
  69         return uvirt_to_phys(VMALLOC_VMADDR(adr));
  70 }
  71
  72 static inline unsigned long kvirt_to_bus(unsigned long adr)
  73 {
  74         return uvirt_to_bus(VMALLOC_VMADDR(adr));
  75 }
  76
  77
  78 static void * rvmalloc(unsigned long size)
  79 {
  80         void * mem;
  81         unsigned long adr, page;
  82
  83         size += (PAGE_SIZE - 1);
  84         size &= ~(PAGE_SIZE - 1);
  85
  86         mem=vmalloc(size);
  87         if (mem)
  88         {
  89                 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
  90                 adr=(unsigned long) mem;
  91                 while (size > 0)
  92                 {
  93                         page = kvirt_to_phys(adr);
  94                         mem_map_reserve(MAP_NR(phys_to_virt(page)));
  95                         adr+=PAGE_SIZE;
  96                         if (size > PAGE_SIZE)
  97                                 size-=PAGE_SIZE;
  98                         else
  99                                 size=0;
 100                 }
 101         }
 102         return mem;
 103 }
 104
 105 static void rvfree(void * mem, unsigned long size)
 106 {
 107         unsigned long adr, page;
 108
 109         size += (PAGE_SIZE - 1);
 110         size &= ~(PAGE_SIZE - 1);
 111
 112         if (mem)
 113         {
 114                 adr=(unsigned long) mem;
 115                 while (size > 0)
 116                 {
 117                         page = kvirt_to_phys(adr);
 118                         mem_map_unreserve(MAP_NR(phys_to_virt(page)));
 119                         adr+=PAGE_SIZE;
 120                         if (size > PAGE_SIZE)
 121                                 size-=PAGE_SIZE;
 122                         else
 123                                 size=0;
 124                 }
 125                 vfree(mem);
 126         }
 127 }
 128
 129 int usb_cpia_get_version(struct usb_device *dev, void *buf)
 130 {
 131         devrequest dr;
 132
 133         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE) | 0x80;
 134         dr.request = USB_REQ_CPIA_GET_VERSION;
 135         dr.value = 0;
 136         dr.index = 0;
 137         dr.length = 4;
 138
 139         return dev->bus->op->control_msg(dev, usb_rcvctrlpipe(dev,0), &dr, buf, 4);
 140 }
 141
 142 int usb_cpia_get_pnp_id(struct usb_device *dev, void *buf)
 143 {
 144         devrequest dr;
 145
 146         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE) | 0x80;
 147         dr.request = USB_REQ_CPIA_GET_PNP_ID;
 148         dr.value = 0;
 149         dr.index = 0;
 150         dr.length = 6;
 151
 152         return dev->bus->op->control_msg(dev, usb_rcvctrlpipe(dev,0), &dr, buf, 6);
 153 }
 154
 155 int usb_cpia_get_camera_status(struct usb_device *dev, void *buf)
 156 {
 157         devrequest dr;
 158
 159         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE) | 0x80;
 160         dr.request = USB_REQ_CPIA_GET_CAMERA_STATUS;
 161         dr.value = 0;
 162         dr.index = 0;
 163         dr.length = 8;
 164
 165         return dev->bus->op->control_msg(dev, usb_rcvctrlpipe(dev,0), &dr, buf, 8);
 166 }
 167
 168 int usb_cpia_goto_hi_power(struct usb_device *dev)
 169 {
 170         devrequest dr;
 171
 172         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 173         dr.request = USB_REQ_CPIA_GOTO_HI_POWER;
 174         dr.value = 0;
 175         dr.index = 0;
 176         dr.length = 0;
 177
 178         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 179 }
 180
 181 int usb_cpia_get_vp_version(struct usb_device *dev, void *buf)
 182 {
 183         devrequest dr;
 184
 185         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 186         dr.request = USB_REQ_CPIA_GET_VP_VERSION;
 187         dr.value = 0;
 188         dr.index = 0;
 189         dr.length = 4;
 190
 191         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, buf, 4);
 192 }
 193
 194 int usb_cpia_set_sensor_fps(struct usb_device *dev, int sensorbaserate, int sensorclkdivisor)
 195 {
 196         devrequest dr;
 197
 198         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 199         dr.request = USB_REQ_CPIA_SET_SENSOR_FPS;
 200         dr.value = (sensorclkdivisor << 8) + sensorbaserate;
 201         dr.index = 0;
 202         dr.length = 0;
 203
 204         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 205 }
 206
 207 int usb_cpia_grab_frame(struct usb_device *dev, int streamstartline)
 208 {
 209         devrequest dr;
 210
 211         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 212         dr.request = USB_REQ_CPIA_GRAB_FRAME;
 213         dr.value = streamstartline << 8;
 214         dr.index = 0;
 215         dr.length = 0;
 216
 217         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 218 }
 219
 220 int usb_cpia_upload_frame(struct usb_device *dev, int forceupload)
 221 {
 222         devrequest dr;
 223
 224         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 225         dr.request = USB_REQ_CPIA_UPLOAD_FRAME;
 226         dr.value = forceupload;
 227         dr.index = 0;
 228         dr.length = 0;
 229
 230         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 231 }
 232
 233 int usb_cpia_set_grab_mode(struct usb_device *dev, int continuousgrab)
 234 {
 235         devrequest dr;
 236
 237         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 238         dr.request = USB_REQ_CPIA_SET_GRAB_MODE;
 239         dr.value = continuousgrab;
 240         dr.index = 0;
 241         dr.length = 0;
 242
 243         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 244 }
 245
 246 int usb_cpia_set_format(struct usb_device *dev, int size, int subsample, int order)
 247 {
 248         devrequest dr;
 249
 250         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 251         dr.request = USB_REQ_CPIA_SET_FORMAT;
 252         dr.value = (subsample << 8) + size;
 253         dr.index = order;
 254         dr.length = 0;
 255
 256         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 257 }
 258
 259 int usb_cpia_set_compression(struct usb_device *dev, int compmode, int decimation)
 260 {
 261         devrequest dr;
 262
 263         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 264         dr.request = USB_REQ_CPIA_SET_COMPRESSION;
 265         dr.value = (decimation << 8) + compmode;
 266         dr.index = 0;
 267         dr.length = 0;
 268
 269         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 270 }
 271
 272 int usb_cpia_initstreamcap(struct usb_device *dev, int skipframes, int streamstartline)
 273 {
 274         devrequest dr;
 275
 276         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 277         dr.request = USB_REQ_CPIA_INIT_STREAM_CAP;
 278         dr.value = (streamstartline << 8) + skipframes;
 279         dr.index = 0;
 280         dr.length = 0;
 281
 282         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 283 }
 284
 285 int usb_cpia_finistreamcap(struct usb_device *dev)
 286 {
 287         devrequest dr;
 288
 289         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 290         dr.request = USB_REQ_CPIA_FINI_STREAM_CAP;
 291         dr.value = 0;
 292         dr.index = 0;
 293         dr.length = 0;
 294
 295         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 296 }
 297
 298 int usb_cpia_startstreamcap(struct usb_device *dev)
 299 {
 300         devrequest dr;
 301
 302         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 303         dr.request = USB_REQ_CPIA_START_STREAM_CAP;
 304         dr.value = 0;
 305         dr.index = 0;
 306         dr.length = 0;
 307
 308         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 309 }
 310
 311 int usb_cpia_endstreamcap(struct usb_device *dev)
 312 {
 313         devrequest dr;
 314
 315         dr.requesttype = (USB_TYPE_VENDOR | USB_RECIP_DEVICE);
 316         dr.request = USB_REQ_CPIA_END_STREAM_CAP;
 317         dr.value = 0;
 318         dr.index = 0;
 319         dr.length = 0;
 320
 321         return dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 322 }
 323
 324 /* How much data is left in the scratch buf? */
 325 #define scratch_left(x) (cpia->scratchlen - (int)((char *)x - (char *)cpia->scratch))
 326
 327 static void cpia_parse_data(struct usb_cpia *cpia)
 328 {
 329         unsigned char *data = cpia->scratch;
 330         unsigned long l;
 331         int done;
 332
 333         done = 0;
 334         while (!done && scratch_left(data)) {
 335                 switch (cpia->state) {
 336                 case STATE_SCANNING:
 337                 {
 338                         unsigned char *begin = data;
 339
 340                         /* We need atleast 2 bytes for the magic value */
 341                         if (scratch_left(data) < 2) {
 342                                 done = 1;
 343                                 break;
 344                         }
 345
 346                         /* 0x1968 is magic */
 347                         printk("header: %X\n", (*data << 8) + *(data + 1));
 348                         if ((*data == 0x19) && (*(data + 1) == 0x68)) {
 349                                 cpia->state = STATE_HEADER;
 350                                 printk("moving to header\n");
 351                                 break;
 352                         }
 353
 354                         /* Woops, lost the header, find the end of the frame */
 355                         if (scratch_left(data) < 4) {
 356                                 done = 1;
 357                                 break;
 358                         }
 359
 360                         printk("Scanning for end of frame\n");
 361                         while (scratch_left(data) >= 4) {
 362                                 if ((*data == 0xFF) &&
 363                                         (*(data + 1) == 0xFF) &&
 364                                         (*(data + 2) == 0xFF) &&
 365                                         (*(data + 3) == 0xFF)) {
 366                                         data += 4;
 367                                         break;
 368                                 }
 369                                 data++;
 370                         }
 371 #ifdef CPIA_DEBUG
 372                         printk("scan: scanned %d bytes\n", data-begin);
 373 #endif
 374                         break;
 375                 }
 376                 case STATE_HEADER:
 377                         /* We need atleast 64 bytes for the header */
 378                         if (scratch_left(data) < 64) {
 379                                 done = 1;
 380                                 break;
 381                         }
 382
 383 #ifdef CPIA_DEBUG
 384                         printk("header: framerate %d\n", data[41]);
 385 #endif
 386
 387                         data += 64;
 388
 389                         cpia->state = STATE_LINES;
 390
 391                         break;
 392                 case STATE_LINES:
 393                 {
 394                         unsigned char *begin = data;
 395                         int found = 0;
 396
 397                         while (scratch_left(data)) {
 398                                 if (*data == 0xFD) {
 399                                         data++;
 400                                         found = 1;
 401                                         break;
 402                                 } else if ((*data == 0xFF) &&
 403                                                 (scratch_left(data) >= 3) &&
 404                                                 (*(data + 1) == 0xFF) &&
 405                                                 (*(data + 2) == 0xFF) &&
 406                                                 (*(data + 3) == 0xFF)) {
 407                                         data += 4;
 408                                         cpia->curline = 144;
 409                                         found = 1;
 410                                         break;
 411                                 }
 412
 413                                 data++;
 414                         }
 415
 416                         if (data-begin == 355 && cpia->frame[cpia->curframe].width != 64) {
 417                                 int i;
 418                                 char *f = cpia->frame[cpia->curframe].data, *b = begin;
 419
 420                                 b += 2;
 421                                 f += (cpia->frame[cpia->curframe].width * 3) * cpia->curline;
 422
 423                                 for (i = 0; i < 176; i++)
 424                                         f[(i * 3) + 0] =
 425                                         f[(i * 3) + 1] =
 426                                         f[(i * 3) + 2] =
 427                                                 b[(i * 2)];
 428                         }
 429
 430                         if (found) {
 431                                 cpia->curline++;
 432                                 if (cpia->curline >= 144) {
 433                                         wake_up(&cpia->wq);
 434                                         cpia->state = STATE_SCANNING;
 435                                         cpia->curline = 0;
 436                                         cpia->curframe = -1;
 437                                         done = 1;
 438                                 }
 439                         } else {
 440                                 data = begin;
 441                                 done = 1;
 442                         }
 443
 444                         break;
 445                 }
 446                 }
 447         }
 448
 449         /* Grab the remaining */
 450         l = scratch_left(data);
 451         memmove(cpia->scratch, data, l);
 452
 453         cpia->scratchlen = l;
 454 }
 455
 456 static int cpia_isoc_irq(int status, void *__buffer, int len, void *dev_id)
 457 {
 458         struct usb_cpia *cpia = dev_id;
 459         struct usb_device *dev = cpia->dev;
 460         struct cpia_sbuf *sbuf;
 461         int i;
 462         char *p;
 463
 464         if (!cpia->streaming) {
 465                 printk("oops, not streaming, but interrupt\n");
 466                 return 0;
 467         }
 468
 469         if (cpia->curframe < 0) {
 470                 if (cpia->frame[0].state == FRAME_READY) {
 471                         cpia->curframe = 0;
 472                         cpia->frame[0].state = FRAME_GRABBING;
 473 #ifdef CPIA_DEBUG
 474                         printk("capturing to frame 0\n");
 475 #endif
 476                 } else if (cpia->frame[1].state == FRAME_READY) {
 477                         cpia->curframe = 1;
 478                         cpia->frame[1].state = FRAME_GRABBING;
 479 #ifdef CPIA_DEBUG
 480                         printk("capturing to frame 1\n");
 481 #endif
 482 #ifdef CPIA_DEBUG
 483                 } else
 484                         printk("no frame available\n");
 485 #else
 486                 }
 487 #endif
 488         }
 489
 490         sbuf = &cpia->sbuf[cpia->receivesbuf];
 491
 492         usb_unschedule_isochronous(dev, sbuf->isodesc);
 493
 494         /* Do something to it now */
 495         sbuf->len = usb_compress_isochronous(dev, sbuf->isodesc);
 496
 497 #ifdef CPIA_DEBUG
 498         if (sbuf->len)
 499                 printk("%d bytes received\n", sbuf->len);
 500 #endif
 501
 502         if (sbuf->len && cpia->curframe >= 0) {
 503                 if (sbuf->len > (SCRATCH_BUF_SIZE - cpia->scratchlen)) {
 504                         printk("overflow!\n");
 505                         return 0;
 506                 }
 507                 memcpy(cpia->scratch + cpia->scratchlen, sbuf->data, sbuf->len);
 508                 cpia->scratchlen += sbuf->len;
 509
 510                 cpia_parse_data(cpia);
 511         }
 512
 513         /* Reschedule this block of Isochronous desc */
 514         usb_schedule_isochronous(dev, sbuf->isodesc, cpia->sbuf[(cpia->receivesbuf + 2) % 3].isodesc);
 515
 516         /* Move to the next one */
 517         cpia->receivesbuf = (cpia->receivesbuf + 1) % 3;
 518
 519         return 1;
 520 }
 521
 522 int cpia_init_isoc(struct usb_cpia *cpia)
 523 {
 524         struct usb_device *dev = cpia->dev;
 525
 526         cpia->receivesbuf = 0;
 527
 528         cpia->scratchlen = 0;
 529         cpia->curline = 0;
 530         cpia->state = STATE_SCANNING;
 531
 532         /* Allocate all of the memory necessary */
 533         cpia->sbuf[0].isodesc = usb_allocate_isochronous(dev, usb_rcvisocpipe(dev,1), cpia->sbuf[0].data, STREAM_BUF_SIZE, 960, cpia_isoc_irq, cpia);
 534         cpia->sbuf[1].isodesc = usb_allocate_isochronous(dev, usb_rcvisocpipe(dev,1), cpia->sbuf[1].data, STREAM_BUF_SIZE, 960, cpia_isoc_irq, cpia);
 535         cpia->sbuf[2].isodesc = usb_allocate_isochronous(dev, usb_rcvisocpipe(dev,1), cpia->sbuf[2].data, STREAM_BUF_SIZE, 960, cpia_isoc_irq, cpia);
 536
 537 #ifdef CPIA_DEBUG
 538         printk("isodesc[0] @ %p\n", cpia->sbuf[0].isodesc);
 539         printk("isodesc[1] @ %p\n", cpia->sbuf[1].isodesc);
 540         printk("isodesc[2] @ %p\n", cpia->sbuf[2].isodesc);
 541 #endif
 542
 543         /* Schedule the queues */
 544         usb_schedule_isochronous(dev, cpia->sbuf[0].isodesc, NULL);
 545         usb_schedule_isochronous(dev, cpia->sbuf[1].isodesc, cpia->sbuf[0].isodesc);
 546         usb_schedule_isochronous(dev, cpia->sbuf[2].isodesc, cpia->sbuf[1].isodesc);
 547
 548 #ifdef CPIA_DEBUG
 549         printk("done scheduling\n");
 550 #endif
 551         if (usb_set_interface(cpia->dev, 1, 3)) {
 552                 printk("cpia_set_interface error\n");
 553                 return -EINVAL;
 554         }
 555
 556         usb_cpia_startstreamcap(cpia->dev);
 557
 558         cpia->streaming = 1;
 559 #ifdef CPIA_DEBUG
 560         printk("now streaming\n");
 561 #endif
 562
 563         return 0;
 564 }
 565
 566 void cpia_stop_isoc(struct usb_cpia *cpia)
 567 {
 568         struct usb_device *dev = cpia->dev;
 569
 570         if (!cpia->streaming)
 571                 return;
 572
 573         cpia->streaming = 0;
 574
 575         /* Stop the streaming */
 576         usb_cpia_endstreamcap(cpia->dev);
 577
 578         /* Set packet size to 0 */
 579         if (usb_set_interface(cpia->dev, 1, 0)) {
 580                 printk("cpia_set_interface error\n");
 581                 return /* -EINVAL */;
 582         }
 583
 584         /* Unschedule all of the iso td's */
 585         usb_unschedule_isochronous(dev, cpia->sbuf[2].isodesc);
 586         usb_unschedule_isochronous(dev, cpia->sbuf[1].isodesc);
 587         usb_unschedule_isochronous(dev, cpia->sbuf[0].isodesc);
 588
 589         /* Delete them all */
 590         usb_delete_isochronous(dev, cpia->sbuf[2].isodesc);
 591         usb_delete_isochronous(dev, cpia->sbuf[1].isodesc);
 592         usb_delete_isochronous(dev, cpia->sbuf[0].isodesc);
 593 }
 594
 595 /* Video 4 Linux API */
 596 static int cpia_open(struct video_device *dev, int flags)
 597 {
 598         struct usb_cpia *cpia = (struct usb_cpia *)dev;
 599
 600 #ifdef CPIA_DEBUG
 601         printk("cpia_open\n");
 602 #endif
 603
 604         cpia->fbuf = rvmalloc(2 * MAX_FRAME_SIZE);
 605         if (!cpia->fbuf)
 606                 goto open_err_ret;
 607
 608         cpia->frame[0].state = FRAME_DONE;
 609         cpia->frame[1].state = FRAME_DONE;
 610
 611         cpia->frame[0].data = cpia->fbuf;
 612         cpia->frame[1].data = cpia->fbuf + MAX_FRAME_SIZE;
 613 #ifdef CPIA_DEBUG
 614         printk("frame [0] @ %p\n", cpia->frame[0].data);
 615         printk("frame [1] @ %p\n", cpia->frame[1].data);
 616 #endif
 617
 618         cpia->sbuf[0].data = kmalloc(STREAM_BUF_SIZE, GFP_KERNEL);
 619         if (!cpia->sbuf[0].data)
 620                 goto open_err_on0;
 621
 622         cpia->sbuf[1].data = kmalloc(STREAM_BUF_SIZE, GFP_KERNEL);
 623         if (!cpia->sbuf[1].data)
 624                 goto open_err_on1;
 625
 626         cpia->sbuf[2].data = kmalloc(STREAM_BUF_SIZE, GFP_KERNEL);
 627         if (!cpia->sbuf[2].data)
 628                 goto open_err_on2;
 629
 630 #ifdef CPIA_DEBUG
 631         printk("sbuf[0] @ %p\n", cpia->sbuf[0].data);
 632         printk("sbuf[1] @ %p\n", cpia->sbuf[1].data);
 633         printk("sbuf[2] @ %p\n", cpia->sbuf[2].data);
 634 #endif
 635
 636         cpia->curframe = -1;
 637         cpia->receivesbuf = 0;
 638
 639         usb_cpia_initstreamcap(cpia->dev, 0, 60);
 640
 641         cpia_init_isoc(cpia);
 642
 643         return 0;
 644
 645 open_err_on2:
 646         kfree (cpia->sbuf[1].data);
 647 open_err_on1:
 648         kfree (cpia->sbuf[0].data);
 649 open_err_on0:
 650         rvfree(cpia->fbuf, 2 * MAX_FRAME_SIZE);
 651 open_err_ret:
 652         return -ENOMEM;
 653 }
 654
 655 static void cpia_close(struct video_device *dev)
 656 {
 657         struct usb_cpia *cpia = (struct usb_cpia *)dev;
 658
 659 #ifdef CPIA_DEBUG
 660         printk("cpia_close\n");
 661 #endif
 662
 663         cpia_stop_isoc(cpia);
 664
 665         usb_cpia_finistreamcap(cpia->dev);
 666
 667         rvfree(cpia->fbuf, 2 * MAX_FRAME_SIZE);
 668
 669         kfree(cpia->sbuf[2].data);
 670         kfree(cpia->sbuf[1].data);
 671         kfree(cpia->sbuf[0].data);
 672 }
 673
 674 static int cpia_init_done(struct video_device *dev)
 675 {
 676         return 0;
 677 }
 678
 679 static long cpia_write(struct video_device *dev, const char *buf, unsigned long count, int noblock)
 680 {
 681         return -EINVAL;
 682 }
 683
 684 static int cpia_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
 685 {
 686         struct usb_cpia *cpia = (struct usb_cpia *)dev;
 687
 688         switch (cmd) {
 689                 case VIDIOCGCAP:
 690                 {
 691                         struct video_capability b;
 692
 693                         strcpy(b.name, "CPiA USB Camera");
 694                         b.type = VID_TYPE_CAPTURE /* | VID_TYPE_SUBCAPTURE */;
 695                         b.channels = 1;
 696                         b.audios = 0;
 697                         b.maxwidth = 176        /* 352 */;
 698                         b.maxheight = 144       /* 240 */;
 699                         b.minwidth = 176        /* (Something small?) */;
 700                         b.minheight = 144       /* "         " */;
 701
 702                         if (copy_to_user(arg, &b, sizeof(b)))
 703                                 return -EFAULT;
 704                         return 0;
 705                 }
 706                 case VIDIOCGCHAN:
 707                 {
 708                         struct video_channel v;
 709
 710                         if (copy_from_user(&v, arg, sizeof(v)))
 711                                 return -EFAULT;
 712                         if (v.channel != 0)
 713                                 return -EINVAL;
 714
 715                         v.flags = 0;
 716                         v.tuners = 0;
 717                         v.type = VIDEO_TYPE_CAMERA;
 718                         strcpy(v.name, "Camera");
 719
 720                         if (copy_to_user(arg, &v, sizeof(v)))
 721                                 return -EFAULT;
 722                         return 0;
 723                 }
 724                 case VIDIOCSCHAN:
 725                 {
 726                         int v;
 727
 728                         if (copy_from_user(&v, arg, sizeof(v)))
 729                                 return -EFAULT;
 730
 731                         if (v != 0)
 732                                 return -EINVAL;
 733
 734                         return 0;
 735                 }
 736                 case VIDIOCGTUNER:
 737                 {
 738                         struct video_tuner v;
 739
 740                         if (copy_from_user(&v, arg, sizeof(v)))
 741                                 return -EFAULT;
 742
 743                         if (v.tuner)
 744                                 return -EINVAL;
 745
 746                         strcpy(v.name, "Format");
 747
 748                         v.rangelow = 0;
 749                         v.rangehigh = 0;
 750                         v.flags = 0;
 751                         v.mode = VIDEO_MODE_AUTO;
 752
 753                         if (copy_to_user(arg, &v, sizeof(v)))
 754                                 return -EFAULT;
 755
 756                         return 0;
 757                 }
 758                 case VIDIOCSTUNER:
 759                 {
 760                         struct video_tuner v;
 761
 762                         if (copy_from_user(&v, arg, sizeof(v)))
 763                                 return -EFAULT;
 764
 765                         if (v.tuner)
 766                                 return -EINVAL;
 767
 768                         if (v.mode != VIDEO_MODE_AUTO)
 769                                 return -EINVAL;
 770
 771                         return 0;
 772                 }
 773                 case VIDIOCGPICT:
 774                 {
 775                         struct video_picture p;
 776
 777                         p.colour = 0x8000;      /* Damn British people :) */
 778                         p.hue = 0x8000;
 779                         p.brightness = 180 << 8;        /* XXX */
 780                         p.contrast = 192 << 8;          /* XXX */
 781                         p.whiteness = 105 << 8;         /* XXX */
 782 #if 0
 783                         p.depth = 24;
 784 #endif
 785                         p.depth = 16;
 786                         p.palette = VIDEO_PALETTE_YUYV;
 787
 788                         if (copy_to_user(arg, &p, sizeof(p)))
 789                                 return -EFAULT;
 790
 791                         return 0;
 792                 }
 793                 case VIDIOCSPICT:
 794                 {
 795                         struct video_picture p;
 796
 797                         if (copy_from_user(&p, arg, sizeof(p)))
 798                                 return -EFAULT;
 799
 800 #ifdef CPIA_DEBUG
 801                         printk("Attempting to set palette %d, depth %d\n",
 802                                 p.palette, p.depth);
 803 #endif
 804
 805                         return 0;
 806                 }
 807                 case VIDIOCSWIN:
 808                 {
 809                         struct video_window vw;
 810
 811 #ifdef CPIA_DEBUG
 812                         printk("VIDIOCSWIN\n");
 813 #endif
 814
 815                         if (copy_from_user(&vw, arg, sizeof(vw)))
 816                                 return -EFAULT;
 817                         if (vw.flags)
 818                                 return -EINVAL;
 819                         if (vw.clipcount)
 820                                 return -EINVAL;
 821                         if (vw.height != 176)
 822                                 return -EINVAL;
 823                         if (vw.width != 144)
 824                                 return -EINVAL;
 825
 826                         return 0;
 827                 }
 828                 case VIDIOCGWIN:
 829                 {
 830                         struct video_window vw;
 831
 832 #ifdef CPIA_DEBUG
 833                         printk("VIDIOCGWIN\n");
 834 #endif
 835
 836                         vw.x = 0;
 837                         vw.y = 0;
 838                         vw.width = 176;
 839                         vw.height = 144;
 840                         vw.chromakey = 0;
 841                         vw.flags = 0;
 842
 843                         if (copy_to_user(arg, &vw, sizeof(vw)))
 844                                 return -EFAULT;
 845
 846                         return 0;
 847                 }
 848                 case VIDIOCGMBUF:
 849                 {
 850                         struct video_mbuf vm;
 851
 852                         memset(&vm, 0, sizeof(vm));
 853                         vm.size = MAX_FRAME_SIZE * 2;
 854                         vm.frames = 2;
 855                         vm.offsets[0] = 0;
 856                         vm.offsets[1] = MAX_FRAME_SIZE;
 857
 858                         if (copy_to_user((void *)arg, (void *)&vm, sizeof(vm)))
 859                                 return -EFAULT;
 860
 861                         return 0;
 862                 }
 863                 case VIDIOCMCAPTURE:
 864                 {
 865                         struct video_mmap vm;
 866
 867                         if (copy_from_user((void *)&vm, (void *)arg, sizeof(vm)))
 868                                 return -EFAULT;
 869
 870 #ifdef CPIA_DEBUG
 871                         printk("MCAPTURE\n");
 872                         printk("frame: %d, size: %dx%d, format: %d\n",
 873                                 vm.frame, vm.width, vm.height, vm.format);
 874 #endif
 875
 876                         if (vm.format != VIDEO_PALETTE_RGB24)
 877                                 return -EINVAL;
 878
 879                         if ((vm.frame != 0) && (vm.frame != 1))
 880                                 return -EINVAL;
 881
 882                         cpia->frame[vm.frame].width = vm.width;
 883                         cpia->frame[vm.frame].height = vm.height;
 884
 885                         /* Mark it as free */
 886                         cpia->frame[vm.frame].state = FRAME_READY;
 887
 888                         return 0;
 889                 }
 890                 case VIDIOCSYNC:
 891                 {
 892                         int frame;
 893
 894                         if (copy_from_user((void *)&frame, arg, sizeof(int)))
 895                                 return -EFAULT;
 896
 897 #ifdef CPIA_DEBUG
 898                         printk("syncing to frame %d\n", frame);
 899 #endif
 900                         switch (cpia->frame[frame].state) {
 901                                 case FRAME_UNUSED:
 902                                         return -EINVAL;
 903                                 case FRAME_READY:
 904                                 case FRAME_GRABBING:
 905                                         interruptible_sleep_on(&cpia->wq);
 906                                 case FRAME_DONE:
 907                                         cpia->frame[frame].state = FRAME_UNUSED;
 908                                         break;
 909                         }
 910 #ifdef CPIA_DEBUG
 911                         printk("synced to frame %d\n", frame);
 912 #endif
 913                         return 0;
 914                 }
 915                 case VIDIOCCAPTURE:
 916                         return -EINVAL;
 917                 case VIDIOCGFBUF:
 918                         return -EINVAL;
 919                 case VIDIOCSFBUF:
 920                         return -EINVAL;
 921                 case VIDIOCKEY:
 922                         return 0;
 923                 case VIDIOCGFREQ:
 924                         return -EINVAL;
 925                 case VIDIOCSFREQ:
 926                         return -EINVAL;
 927                 case VIDIOCGAUDIO:
 928                         return -EINVAL;
 929                 case VIDIOCSAUDIO:
 930                         return -EINVAL;
 931                 default:
 932                         return -ENOIOCTLCMD;
 933         }
 934         return 0;
 935 }
 936
 937 static long cpia_read(struct video_device *dev, char *buf, unsigned long count, int noblock)
 938 {
 939         struct usb_cpia *cpia = (struct usb_cpia *)dev;
 940         int len;
 941
 942 #ifdef CPIA_DEBUG
 943         printk("cpia_read: %ld bytes\n", count);
 944 #endif
 945 #if 0
 946         len = cpia_capture(cpia, buf, count);
 947
 948         return len;
 949 #endif
 950         return 0;
 951 }
 952
 953 static int cpia_mmap(struct video_device *dev, const char *adr, unsigned long size)
 954 {
 955         struct usb_cpia *cpia = (struct usb_cpia *)dev;
 956         unsigned long start = (unsigned long)adr;
 957         unsigned long page, pos;
 958
 959 #ifdef CPIA_DEBUG
 960         printk("mmap: %ld (%lX) bytes\n", size, size);
 961 #endif
 962         if (size > (((2 * MAX_FRAME_SIZE) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)))
 963                 return -EINVAL;
 964
 965         pos = (unsigned long)cpia->fbuf;
 966         while (size > 0)
 967         {
 968                 page = kvirt_to_phys(pos);
 969                 if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED))
 970                         return -EAGAIN;
 971                 start+=PAGE_SIZE;
 972                 pos+=PAGE_SIZE;
 973                 if (size > PAGE_SIZE)
 974                         size-=PAGE_SIZE;
 975                 else
 976                         size=0;
 977         }
 978
 979         return 0;
 980 }
 981
 982 static struct video_device cpia_template = {
 983         "CPiA USB Camera",
 984         VID_TYPE_CAPTURE,
 985         VID_HARDWARE_CPIA,
 986         cpia_open,
 987         cpia_close,
 988         cpia_read,
 989         cpia_write,
 990         NULL,
 991         cpia_ioctl,
 992         cpia_mmap,
 993         cpia_init_done,
 994         NULL,
 995         0,
 996         0
 997 };
 998
 999 static void usb_cpia_configure(struct usb_cpia *cpia)
1000 {
1001         struct usb_device *dev = cpia->dev;
1002         unsigned char version[4];
1003         unsigned char pnpid[6];
1004         unsigned char camerastat[8];
1005         unsigned char *buf;
1006
1007         if (usb_set_configuration(dev, dev->config[0].bConfigurationValue)) {
1008                 printk (KERN_INFO " Failed usb_set_configuration: CPIA\n");
1009                 return;
1010         }
1011
1012         if (usb_cpia_get_version(dev, version)) {
1013                 printk("cpia_get_version error\n");
1014                 return;
1015         }
1016
1017         printk("cpia: Firmware v%d.%d, VC Hardware v%d.%d\n",
1018                 version[0], version[1], version[2], version[3]);
1019
1020         if (usb_cpia_get_pnp_id(dev, pnpid)) {
1021                 printk("cpia_get_pnp_id error\n");
1022                 return;
1023         }
1024
1025         printk("cpia: PnP Id: Vendor: %X, Product: %X, Revision: %X\n",
1026                 (pnpid[1] << 8) + pnpid[0], (pnpid[3] << 8) + pnpid[2],
1027                 (pnpid[5] << 8) + pnpid[4]);
1028
1029         memcpy(&cpia->vdev, &cpia_template, sizeof(cpia_template));
1030
1031         init_waitqueue_head(&cpia->wq);
1032
1033         if (video_register_device(&cpia->vdev, VFL_TYPE_GRABBER) == -1) {
1034                 printk("video_register_device failed\n");
1035                 return;
1036         }
1037
1038         if (usb_cpia_goto_hi_power(dev)) {
1039                 printk("cpia_goto_hi_power error\n");
1040                 return;
1041         }
1042
1043         if (usb_cpia_get_vp_version(dev, version)) {
1044                 printk("cpia_get_vp_version error\n");
1045                 return;
1046         }
1047
1048         printk("cpia: VP v%d rev %d\n", version[0], version[1]);
1049         printk("cpia: Camera Head ID %04X\n", (version[3] << 8) + version[2]);
1050
1051         /* Turn off continuous grab */
1052         if (usb_cpia_set_grab_mode(dev, 1)) {
1053                 printk("cpia_set_grab_mode error\n");
1054                 return;
1055         }
1056
1057         /* Set up the sensor to be 30fps */
1058         if (usb_cpia_set_sensor_fps(dev, 1, 0)) {
1059                 printk("cpia_set_sensor_fps error\n");
1060                 return;
1061         }
1062
1063         /* Set video into QCIF mode, and order into YUYV mode */
1064         if (usb_cpia_set_format(dev, CPIA_QCIF, 1, CPIA_YUYV)) {
1065                 printk("cpia_set_format error\n");
1066                 return;
1067         }
1068
1069         /* Turn off compression */
1070         if (usb_cpia_set_compression(dev, 0, 0)) {
1071                 printk("cpia_set_compression error\n");
1072                 return;
1073         }
1074 }
1075
1076 static int cpia_probe(struct usb_device *dev)
1077 {
1078         struct usb_interface_descriptor *interface;
1079         struct usb_endpoint_descriptor *endpoint;
1080         struct usb_cpia *cpia;
1081
1082         /* We don't handle multi-config cameras */
1083         if (dev->descriptor.bNumConfigurations != 1)
1084                 return -1;
1085
1086         interface = &dev->config[0].interface[0].altsetting[0];
1087
1088         /* Is it a CPiA? */
1089         if (dev->descriptor.idVendor != 0x0553)
1090                 return -1;
1091         if (dev->descriptor.idProduct != 0x0002)
1092                 return -1;
1093         if (interface->bInterfaceClass != 0xFF)
1094                 return -1;
1095         if (interface->bInterfaceSubClass != 0x00)
1096                 return -1;
1097
1098         /* We found a CPiA */
1099         printk("USB CPiA camera found\n");
1100
1101         if ((cpia = kmalloc(sizeof(*cpia), GFP_KERNEL)) == NULL) {
1102                 printk("couldn't kmalloc cpia struct\n");
1103                 return -1;
1104         }
1105
1106         memset(cpia, 0, sizeof(*cpia));
1107
1108         dev->private = cpia;
1109         cpia->dev = dev;
1110
1111         usb_cpia_configure(cpia);
1112
1113         return 0;
1114 }
1115
1116 static void cpia_disconnect(struct usb_device *dev)
1117 {
1118         struct usb_cpia *cpia = dev->private;
1119
1120         video_unregister_device(&cpia->vdev);
1121
1122         /* Free the memory */
1123         kfree(cpia);
1124 }
1125
1126 static struct usb_driver cpia_driver = {
1127         "cpia",
1128         cpia_probe,
1129         cpia_disconnect,
1130         { NULL, NULL }
1131 };
1132
1133 /*
1134  * This should be a separate module.
1135  */
1136 int usb_cpia_init(void)
1137 {
1138         usb_register(&cpia_driver);
1139
1140         return 0;
1141 }
1142
1143 #ifdef MODULE
1144 int init_module(void)
1145 {
1146         return usb_cpia_init();
1147 }
1148
1149 void cleanup_module(void)
1150 {
1151 }
1152 #endif
1153