PS2SDK
PS2 Homebrew Libraries
ps2cam.c
Go to the documentation of this file.
1 /*-----------------------------------------------------------------------
2 - PSX2 OpenSource Project -
3 - (C)2004 lion[PS2Dev] -
4 - (C)2004 PS2Dev.org -
5 -----------------------------------------------------------------------*/
6 
12 //(1) Please keep this file neat.
13 //(2) This irx must always be backwards compatible.
14 #include <stdio.h>
15 #include <sysclib.h>
16 #include <tamtypes.h>
17 #include <thbase.h>
18 #include <sifcmd.h>
19 #include <sifrpc.h>
20 #include <loadcore.h>
21 #include <ioman.h>
22 #include <usbd.h>
23 #include <usbd_macro.h>
24 #include <thsemap.h>
25 #include <sysmem.h>
26 
27 
28 #include "ps2cam.h"
29 
30 #define MODNAME "PS2 USB camera driver"
31 
32 IRX_ID(MODNAME, 1, 1);
33 
34 #define BIND_RPC_ID 0x00FD000 +2
35 #define DRIVER_VERSON_MAJOR 1
36 #define DRIVER_VERSON_MINOR 0
37 
38 #define MAX_CAM_DEVICE 2
39 #define MAX_CAM_DEVICE_HANDLE 2
40 
41 
42 static SifRpcDataQueue_t rpc_queue __attribute__((__aligned__(16)));
43 static SifRpcServerData_t rpc_server __attribute__((__aligned__(16)));
44 static int _rpc_buffer[1024] __attribute__((__aligned__(4)));
45 //static int threadId;
46 static int maintain_thread;
47 sceUsbdLddOps cam_driver = {NULL,
48  NULL,
49  "ps2cam",
50  PS2CamProbe,
51  PS2CamConnect,
52  PS2CamDisconnect,
53  0, 0, 0, 0, 0, NULL };
54 
55 
56 
57 char campacket[896] __attribute__((__aligned__(16)));
58 char irx_initialized = 0;
59 int ps2cam_sema=0;
60 CAMERA_DEVICE Camera[MAX_CAM_DEVICE];
61 PS2CAM_DEVICE_HANDLE CamHandle[MAX_CAM_DEVICE_HANDLE];
62 
63 
64 
65 
66 
67 
68 
69 int _start( int argc, char *argv[])
70 {
71  iop_thread_t param;
72  int th;
73 
74  (void)argc;
75  (void)argv;
76 
77  PS2CamInitDriver();
78 
79 
80  /*create thread*/
81  param.attr = TH_C;
82  param.thread = rpcMainThread;
83  param.priority = 40;
84  param.stacksize = 0x800;
85  param.option = 0;
86 
87 
88  th = CreateThread(&param);
89 
90  if (th > 0)
91  {
92  StartThread(th,NULL);
93  return MODULE_RESIDENT_END;
94  }
95  else
96  {
97  return MODULE_NO_RESIDENT_END;
98  }
99 }
100 
101 
102 
103 
104 
105 
106 
107 
109 int PS2CamInitDriver(void)
110 {
111  int i;
112  iop_sema_t sema;
113 
114  printf("PS2 USB Camera Driver v.%d.%d ((C) www.ps2dev.org)\n",DRIVER_VERSON_MAJOR,DRIVER_VERSON_MINOR);
115 
116 
117  memset(&Camera[0], 0, sizeof(Camera));
118  memset(&CamHandle[0], 0, sizeof(CamHandle));
119 
120  for(i=0;i<MAX_CAM_DEVICE_HANDLE;i++)
121  {
122  CamHandle[i].fd = i+1;
123  }
124 
125  //setup sema
126 
127 
128  sema.initial= 1;
129  sema.max = 1;
130  sema.option = 0;
131  sema.attr = 0;
132  ps2cam_sema = CreateSema(&sema);
133 
134 
135  //connect to usb.irx
136  return sceUsbdRegisterLdd(&cam_driver);
137 }
138 
139 
140 
141 
143 int PS2CamProbe(int devId)
144 {
145  static short count;
146  int i;
147  UsbDeviceDescriptor *dev;
148  UsbConfigDescriptor *conf;
149  UsbInterfaceDescriptor *intf;
150 
151 
152  dev = sceUsbdScanStaticDescriptor(devId, NULL, USB_DT_DEVICE);
153  conf = sceUsbdScanStaticDescriptor(devId, dev, USB_DT_CONFIG);
154  intf = (UsbInterfaceDescriptor *) ((char *) conf + conf->bLength);
155 
156 
157 
158 
159  // check for a free device slot. if none just ignore new device
160  count=0;
161 
162  for(i=0;i<MAX_CAM_DEVICE;i++)
163  {
164  if(Camera[i].status==0)count++;
165  }
166 
167  if(count <= 0) return 0;
168 
169 
170  if(intf->bInterfaceClass == USB_CLASS_VENDOR_SPEC)
171  {
172  // eyetoy 1
173  if(dev->idVendor == PS2CAM_VEND_SONY && dev->idProduct == PS2CAM_PROD_EYETOY)
174  {
175  return 1;
176  }
177 
178  // eyetoy 2
179  if(dev->idVendor == PS2CAM_VEND_SONY && dev->idProduct == PS2CAM_PROD_EYETOY2)
180  {
181  return 1;
182  }
183 
184  // eyetoy 3
185  if(dev->idVendor == PS2CAM_VEND_SONY && dev->idProduct == PS2CAM_PROD_EYETOY3)
186  {
187  return 1;
188  }
189 
190  // eyetoy 4
191  if(dev->idVendor == PS2CAM_VEND_SONY && dev->idProduct == PS2CAM_PROD_EYETOY4)
192  {
193  return 1;
194  }
195 
196  // D-Link VisualStream DSB-C310
197  if(dev->idVendor == PS2CAM_VEND_DLINK && dev->idProduct == PS2CAM_PROD_VISUALSTREAM)
198  {
199  return 1;
200  }
201  }
202 
203 
204  return 0;
205 }
206 
207 
208 
209 
210 
211 
213 int PS2CamConnect(int devId)
214 {
215 
216  int i;
217  UsbDeviceDescriptor *dev;
218 
219  UsbInterfaceDescriptor *intf0,*intf1;
220  UsbEndpointDescriptor *endp1;
221  CAMERA_DEVICE *cam = NULL;
222  iop_thread_t param;
223 
224 
225  printf("camera was connected\n");
226 
227 
228 
229  dev = sceUsbdScanStaticDescriptor(devId, NULL, USB_DT_DEVICE);
230 
231  intf0 = sceUsbdScanStaticDescriptor(devId, dev, USB_DT_INTERFACE);
232  intf1 = sceUsbdScanStaticDescriptor(devId, intf0, USB_DT_INTERFACE);
233 
234  endp1= (UsbEndpointDescriptor *) ((char *) intf1 + intf1->bLength);
235 
236 
237 
238 
239  //get a free device slot
240  for(i=0;i<MAX_CAM_DEVICE;i++)
241  {
242  if(Camera[i].status == 0)
243  {
244  cam = (CAMERA_DEVICE *)&Camera[i];
245 
246  cam->status = CAM_STATUS_CONNECTED;
247  break;
248  }
249  }
250 
251  if (cam == NULL)
252  {
253  return 0;
254  }
255 
256 
257  cam->device_id = devId;
258 
259  cam->controll = sceUsbdOpenPipe(devId, NULL);
260  cam->stream = sceUsbdOpenPipe(devId, endp1);
261  cam->stream_pocket_size = (endp1->wMaxPacketSizeHB * 256 + endp1->wMaxPacketSizeLB);
262 
263 
264 
265 
266 
267 
268 
269 
270 
271 
272 
273 
274 
275  /*create thread that will execute funtions that cant be called*/
276  /*in this funtion*/
277  param.attr = TH_C;
278  param.thread = (void *)PS2CamInitializeNewDevice;
279  param.priority = 40;
280  param.stacksize = 0x800;
281  param.option = 0;
282 
283  maintain_thread = CreateThread(&param);
284 
285 
286  StartThread(maintain_thread, cam);
287 
288  return 0;
289 }
290 
291 
292 
293 
294 
295 
297 int PS2CamDisconnect(int devId)
298 {
299  int i;
300  CAMERA_DEVICE *cam = NULL;
301 
302  printf("camera was unplugged\n");
303 
304  //find device in slots and remove/clear/free it
305  for(i=0;i<MAX_CAM_DEVICE;i++)
306  {
307  if(Camera[i].device_id == devId)
308  {
309  cam = (CAMERA_DEVICE *)&Camera[i];
310 
311  cam->status = CAM_STATUS_NOTCONNECTED;
312  break;
313  }
314  }
315 
316 
317 
318  // inform any handle that is using this device
319 
320  //find device handle and set the status
321  for(i=0;i<MAX_CAM_DEVICE_HANDLE;i++)
322  {
323  if(CamHandle[i].cam == cam)
324  {
325  CamHandle[i].status = -1;
326  }
327  }
328 
329 
330 
331  // close endpoints
332  sceUsbdClosePipe(cam->controll);
333  sceUsbdClosePipe(cam->stream );
334 
335  cam->status = CAM_STATUS_NOTCONNECTED;
336 
337  return 0;
338 }
339 
340 
341 
342 
343 
344 
345 
346 
347 
348 
349 
350 
351 
352 
353 
354 
355 
356 
357 
358 
359 /* SIF RPC SERVER FUNCTIONS */
360 
361 
362 void rpcMainThread(void* param)
363 {
364  //int ret=-1;
365  int tid;
366 
367  (void)param;
368 
369  sceSifInitRpc(0);
370  tid = GetThreadId();
371  sceSifSetRpcQueue(&rpc_queue, tid);
372  sceSifRegisterRpc(&rpc_server, BIND_RPC_ID, (void *) rpcCommandHandler, (u8 *) &_rpc_buffer, 0, 0, &rpc_queue);
373  sceSifRpcLoop(&rpc_queue);
374 }
375 
376 /* CAMERA HIGH LEVEL FUNCTIONS */
377 
378 
379 
380 
382 void PS2CamInitializeNewDevice(CAMERA_DEVICE *cam)
383 {
384  unsigned char *temp_str;
385  UsbDeviceDescriptor *d;
386 
387 
388  PS2CamSetDeviceConfiguration(cam,1);
389 
390  camStopStream(cam);
391  PS2CamSelectInterface(cam,0,0);
392  camStartStream(cam);
393 
394  PS2CamSetDeviceDefaults(cam);
395 
396 /* camStopStream(dev);
397  setReg16(dev, 0x30, 384);
398  camStartStream(dev);
399 */
400  camStopStream(cam);
401  PS2CamSelectInterface(cam,0,EYETOY_ALTERNATE_SIZE_384);
402  camStartStream(cam);
403 
404  cam->status = CAM_STATUS_CONNECTEDREADY;
405 
406 
407 
408  // connected message (alloc som mem and get device string then print it and free the mem we alloced)
409  d = sceUsbdScanStaticDescriptor(cam->device_id, NULL, USB_DT_DEVICE);
410  temp_str = AllocSysMemory(0, 128, 0);
411  temp_str[0]=0x00;
412  PS2CamGetDeviceSring(cam, d->iProduct, (char *)temp_str, 128);
413  printf("cam initialized(%s)\n",temp_str);
414  FreeSysMemory(temp_str);
415 
416 
417 
418  DeleteThread(maintain_thread);
419 
420  return;
421 
422 }
423 
424 
425 
426 
427 
429 void PS2CamSetDeviceConfiguration(CAMERA_DEVICE *dev,int id)
430 {
431  int ret;
432 
433 
434  WaitSema(ps2cam_sema);
435 
436  ret = sceUsbdSetConfiguration(dev->controll, id, PS2CamCallback, (void*)ps2cam_sema);
437 
438  if(ret != USB_RC_OK)
439  {
440  printf("Usb: Error sending set_configuration\n");
441  }
442  else
443  {
444  WaitSema(ps2cam_sema);
445  }
446 
447  SignalSema(ps2cam_sema);
448 }
449 
450 
451 
453 void PS2CamSetDeviceDefaults(CAMERA_DEVICE *dev)
454 {
455  //int i;
456  static int width,height;
457 
458 
459  camResetDevice(dev);
460 
461  //stop cam before we change settings then start it back later
462  camStopStream(dev);
463 
464  camEnableSystem(dev);
465 
466  /*set red led pin to out before turning it on*/
467  setReg8(dev,EYETOY_GPIO_IO_CTRL0, 0xee);
468 
469  camSetUsbInit(dev);
470 
471 
472  //turn red led off by default
473  camTurnOffRedLed(dev);
474 
475 
476 
477 
478 
479 
480 
481 
482  /* some info sent to cam while peeking at
483  the usb log under windows
484  */
485  setReg8(dev, EYETOY_CREG_PWDN, 0x03);
486  setReg8(dev, EYETOY_CREG_EN_CLK0, 0x9f);
487  setReg8(dev, EYETOY_CREG_EN_CLK1, 0x0f);
488  setReg8(dev, 0xa2, 0x20);
489  setReg8(dev, 0xa3, 0x18);
490  setReg8(dev, 0xa4, 0x04);
491  setReg8(dev, 0xa5, 0x28);
492 
493  setReg8(dev, 0x37, 0x00);
494  setReg8(dev, EYETOY_CREG_AUDIO_CLK, 0x02);
495  setReg8(dev, EYETOY_IREG_FRAR, 0x1f);
496  setReg8(dev, 0x17, 0x50);
497  setReg8(dev, 0x37, 0x00);
498 
499  setReg8(dev, 0x40, 0xff);
500  setReg8(dev, 0x46, 0x00);
501  setReg8(dev, EYETOY_CREG_CAMERA_CLK,0x04);
502 // setReg8(dev, 0xff, 0x00 );
503 
504 
505 
506 
507 
508 
509 
510  // my Y Enhancement
511  setReg8(dev, 0xa8, 0x00 );
512  setReg8(dev, 0xa9, 0x20 );
513  setReg8(dev, 0xaa, 0x00 );
514 
515 
516 
517 
518 
519 
520  /* Select 8-bit input mode */
521  setReg8Mask(dev, EYETOY_IREG_DFR, 0x10, 0x10);
522 
523  // 320x240
524  width = 320;
525  height= 240;
526 
527  //set rez
528  setReg8(dev, EYETOY_IREG_H_SIZE, width>>4);
529  setReg8(dev, EYETOY_IREG_V_SIZE, height>>3);
530  //set offset
531  setReg8(dev, EYETOY_IREG_X_OFFSETL, 0x00);
532  setReg8(dev, EYETOY_IREG_X_OFFSETH, 0x00);
533  setReg8(dev, EYETOY_IREG_Y_OFFSETL, 0x00);
534  setReg8(dev, EYETOY_IREG_Y_OFFSETH, 0x00);
535  //div & color
536  //setReg8(dev, EYETOY_IREG_DIVIDER, 0x11);
537  camSetDIVIDER(dev, 1, 0, 1, 0);
538  setReg8(dev, EYETOY_IREG_FORMAT, 0x03);
539  setReg8(dev, 0x26, 0x00);
540 
541 
542  // 30 fps
543  setReg8(dev, 0xa4, 0x0c);
544  setReg8(dev, 0x23, 0xff);
545 
546 
547 
548  // start cam after changing settings
549  camStartStream(dev);
550 
551 }
552 
553 
554 
555 
556 
557 
558 
559 
560 
561 
562 
563 
564 
565 
566 /* CAMERA LOW LEVEL FUNCTIONS */
567 
568 
570 void PS2CamCallback(int resultCode, int bytes, void *arg)
571 {
572  if(resultCode !=0)
573  printf("callback: result= %d, bytes= %d, arg= %p \n", resultCode, bytes, arg);
574 
575  SignalSema(ps2cam_sema);
576 }
577 
578 
580 int setReg8(CAMERA_DEVICE *dev, unsigned char reg_id, unsigned char value)
581 {
582  int ret;
583 
584  WaitSema(ps2cam_sema);
585 
586  ret = sceUsbdControlTransfer(dev->controll, USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1, 0, (unsigned short)reg_id, 1, &value, PS2CamCallback, (void*)ps2cam_sema);
587 
588  if(ret != USB_RC_OK)
589  {
590  printf("sceUsbdControlTransfer failed in 'setReg8'.\n");
591  ret = -1;
592  }
593  else
594  {
595  WaitSema(ps2cam_sema);
596  }
597 
598  SignalSema(ps2cam_sema);
599  return ret;
600 }
601 
602 
603 
604 
606 int getReg8(CAMERA_DEVICE *dev, unsigned char reg_id, unsigned char *value)
607 {
608  int ret;
609 
610  WaitSema(ps2cam_sema);
611 
612  ret = sceUsbdControlTransfer(dev->controll,USB_DIR_IN|USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1, 0,(unsigned short)reg_id, 1, value, PS2CamCallback, (void*)ps2cam_sema);
613 
614  if(ret != USB_RC_OK)
615  {
616  printf("sceUsbdControlTransfer failed in 'getRegValue'.\n");
617  ret = -1;
618  }
619  else
620  {
621  WaitSema(ps2cam_sema);
622  }
623 
624 
625  SignalSema(ps2cam_sema);
626  return ret;
627 }
628 
629 
630 
631 
633 int setReg8Mask(CAMERA_DEVICE *dev,unsigned char reg_id, unsigned char value, unsigned char mask)
634 {
635  int ret;
636  unsigned char current, final;
637 
638  ret = getReg8(dev, reg_id, &current);
639 
640  if (ret < 0) return -1;
641 
642  current &= (~mask);
643  value &= mask;
644  final = current | value;
645 
646  ret = setReg8(dev, reg_id, final);
647  return ret;
648 }
649 
650 int setReg16(CAMERA_DEVICE *dev, unsigned char reg_id, unsigned short value)
651 {
652  int ret;
653 
654  WaitSema(ps2cam_sema);
655 
656  ret = sceUsbdControlTransfer(dev->controll,USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1, 0, (unsigned short)reg_id, 2, &value, PS2CamCallback, (void*)ps2cam_sema);
657 
658 
659  if(ret != USB_RC_OK)
660  {
661  printf("Usb: setReg16 Error (%d)\n",ret);
662  }else
663  {
664  WaitSema(ps2cam_sema);
665  }
666 
667  SignalSema(ps2cam_sema);
668  return 0;
669 }
670 
671 
672 
674 void PS2CamGetDeviceSring(CAMERA_DEVICE* dev, int index, char *str, int strmax)
675 {
676  static char buff[50];
677  UsbStringDescriptor *sd;
678  int ret;
679 
680 
681  WaitSema(ps2cam_sema);
682 
683 
684  ret = sceUsbdControlTransfer(dev->controll, 0x80, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) | index, 0, sizeof(buff), (char *)&buff[0], PS2CamCallback, (void*)ps2cam_sema);
685 
686  if(ret != USB_RC_OK)
687  {
688  printf("Usb: Error getting string (%d)\n",ret);
689  }
690  else
691  {
692  int i;
693 
694 
695  WaitSema(ps2cam_sema);
696 
697  sd = (UsbStringDescriptor *)&buff[0];
698  for(i=0;(i<(sd->bLength-4)/2 && i<strmax-1);i++)
699  {
700  str[i] = sd->wData[i] & 0xFF;
701  str[i+1] = 0x00;
702  }
703  }
704 
705 
706  SignalSema(ps2cam_sema);
707 }
708 
709 
710 
712 int PS2CamSelectInterface(CAMERA_DEVICE* dev, int interface, int altSetting)
713 {
714  int ret;
715  //int semh;
716  //iop_sema_t s;
717 
718 
719  WaitSema(ps2cam_sema);
720 
721 
722  ret = sceUsbdSetInterface(dev->controll, interface, altSetting, PS2CamCallback, (void*)ps2cam_sema);
723 
724  if(ret != USB_RC_OK)
725  {
726  printf("Usb: PS2CamSelectInterface Error...\n");
727  }
728  else
729  {
730  WaitSema(ps2cam_sema);
731  }
732 
733  SignalSema(ps2cam_sema);
734  return ret;
735 }
736 
737 
738 
739 
740 
741 
743 void camResetDevice(CAMERA_DEVICE *dev)
744 {
745  setReg8(dev,EYETOY_CREG_RESET1, 0x0f);
746  setReg8(dev,EYETOY_CREG_RESET1, 0x00);
747 }
748 
749 
750 void camEnableAutoLaunch(CAMERA_DEVICE *dev)
751 {
752  setReg8(dev, EYETOY_CREG_SNAPSHOT, 23);
753 }
754 
755 
756 void camDisableAutoLaunch(CAMERA_DEVICE *dev)
757 {
758  setReg8(dev, EYETOY_CREG_SNAPSHOT, 23);
759 }
760 
761 
762 void camClearSnapButton(CAMERA_DEVICE *dev)
763 {
764  setReg8Mask(dev, EYETOY_CREG_SNAPSHOT, 03,02);
765 }
766 
767 
768 int camCheckAutoLaunch(CAMERA_DEVICE *dev)
769 {
770  (void)dev;
771 
772  //setReg8Mask(dev, EYETOY_CREG_SNAPSHOT, 10,10);
773  return 0;
774 }
775 
776 
778 void camEnableSystem(CAMERA_DEVICE *dev)
779 {
780  setReg8(dev,0x5a, 0x6d);
781  setReg8(dev,0x53, 0x9b);
782  setReg8(dev,0x54, 0x0f);
783  setReg8(dev,0x5d, 0x03);
784  setReg8(dev,0x49, 0x01);
785  setReg8(dev,0x48, 0x00);
786 }
787 
788 
790 void camDisableSystem(CAMERA_DEVICE *dev)
791 {
792  setReg8Mask(dev, EYETOY_CREG_EN_CLK0, 0x9b,0x9b);
793 }
794 
795 
797 void camResetUsb(CAMERA_DEVICE *dev)
798 {
799  setReg8(dev,0x51, 0x0f);
800  setReg8(dev,0x51, 0x00);
801 }
802 
803 
805 void camSetUsbInit(CAMERA_DEVICE *dev)
806 {
807  setReg8(dev,0x51, 0x0f);
808  setReg8(dev,0x51, 0x00);
809  setReg8(dev,0x22, 0x00);
810 }
811 
812 
814 void camSetUsbWork(CAMERA_DEVICE *dev)
815 {
816  setReg8(dev,0x51, 0x0f);
817  setReg8(dev,0x51, 0x00);
818  setReg8(dev,0x22, 0x1d);
819 }
820 
821 
823 void camTurnOnRedLed(CAMERA_DEVICE *dev)
824 {
825  setReg8Mask(dev, EYETOY_GPIO_DATA_OUT0, 0x01,0x01);
826 }
827 
828 
830 void camTurnOffRedLed(CAMERA_DEVICE *dev)
831 {
832  setReg8Mask(dev, EYETOY_GPIO_DATA_OUT0, 0x00,0x01);
833 }
834 
835 
837 void camStartStream(CAMERA_DEVICE *dev)
838 {
839 
840  setReg8(dev, EYETOY_CREG_RESET1, 0x00);
841 }
842 
843 
844 void camStopStream(CAMERA_DEVICE *dev)
845 {
846 
847  setReg8(dev, EYETOY_CREG_RESET1, 0x0f);
848 }
849 
850 
851 
852 
853 
854 
855 
856 
857 
858 
859 
860 
861 
862 
863 
864 
865 
866 
867 
868 
869 
870 
871 int read_rslt;
872 int read_byts;
873 
874 void PS2CamReadDataCallback(int resultCode, int bytes, void *arg)
875 {
876  (void)arg;
877 
878  //printf("read_data_callback: result= %d, bytes= %d, arg= %p \n", resultCode, bytes, arg);
879 
880  read_rslt = resultCode;
881  read_byts = bytes;
882  SignalSema(ps2cam_sema);
883 }
884 
885 
886 
887 
888 int PS2CamReadData(CAMERA_DEVICE* dev, void *addr, int size)
889 {
890  int ret;
891 
892  WaitSema(ps2cam_sema);
893 
894  ret = sceUsbdIsochronousTransfer(dev->stream, addr, size, 0, PS2CamReadDataCallback, (void*)ps2cam_sema);
895 
896  if(ret != USB_RC_OK)
897  {
898  printf("Usb: Error sending sceUsbdIsochronousTransfer\n");
899  SignalSema(ps2cam_sema);
900  return -1;
901  }
902  else
903  {
904  WaitSema(ps2cam_sema);
905  }
906 
907  SignalSema(ps2cam_sema);
908  return read_byts;
909 }
910 
911 
912 
913 
914 
915 
916 
917 
918 
919 
920 
921 
922 
923 /* CAMERA MISC FUNTIONS */
924 
925 
926 
927 
928 
929 
930 
931 
932 
933 
934 
935 
936 /* CAMERA RPC/EXPORTED FUNTIONS */
937 
938 
940 int PS2CamGetIRXVersion(void)
941 {
942  static unsigned short ver[2];
943  int *ret;
944 
945  ret = (int *)&ver[0];
946  ver[0] =DRIVER_VERSON_MAJOR;
947  ver[1] =DRIVER_VERSON_MINOR;
948 
949  return *ret;
950 }
951 
952 
953 
955 int PS2CamInit(int mode)
956 {
957  (void)mode;
958 
959  irx_initialized = 1;
960 
961  return 0;
962 }
963 
964 
965 
967 int PS2CamGetDeviceCount(void)
968 {
969  int i;
970  static int count;
971 
972  if(! irx_initialized)
973  return CAM_ERROR_NOTINIT;
974 
975 
976  //scan device slots for camara(s)
977  for(i=0;i<MAX_CAM_DEVICE;i++)
978  {
979  if(Camera[i].status > 0)
980  {
981  count++;
982  }
983  }
984 
985  return count;
986 }
987 
988 
989 
991 int PS2CamOpenDevice(int device_index)
992 {
993  int i;
994  CAMERA_DEVICE *cam = NULL;
995  PS2CAM_DEVICE_HANDLE *handle = NULL;
996  int index;
997 
998  if(! irx_initialized)
999  return CAM_ERROR_NOTINIT;
1000 
1001  //search for a connected camera
1002  for(i=0,index=0;i<MAX_CAM_DEVICE;i++)
1003  {
1004  if(Camera[i].status > 0)
1005  {
1006  if(index == device_index)
1007  {
1008  cam = &Camera[i];
1009  break;
1010  }
1011 
1012  index++;
1013  }
1014 
1015 
1016  //see the error code to return
1017  if((i+1) == (MAX_CAM_DEVICE))
1018  {
1019  if(index == 0)return CAM_ERROR_NODEVICE;
1020  if(index < device_index)return CAM_ERROR_BADRANGE;
1021  return CAM_ERROR_UNKNOWN;
1022  }
1023  }
1024 
1025 
1026 
1027  //find a free device handle slot for the device
1028  for(i=0;i<MAX_CAM_DEVICE_HANDLE;i++)
1029  {
1030  if(CamHandle[i].status == 0)
1031  {
1032  handle = &CamHandle[i];
1033  break;
1034  }
1035 
1036 
1037  //see error to return
1038  if((i+1)== MAX_CAM_DEVICE_HANDLE)
1039  {
1040  return CAM_ERROR_MAXHANDLE;
1041  }
1042  }
1043 
1044  if (handle == NULL)
1045  {
1046  return CAM_ERROR_MAXHANDLE;
1047  }
1048 
1049 
1050  //now we point handle attribute to the camera
1051  handle->status = 1;
1052  handle->cam = cam;
1053 
1054  return handle->fd;
1055 }
1056 
1057 
1058 
1060 int PS2CamCloseDevice(int handle)
1061 {
1062  int i;
1063 
1064  if(! irx_initialized)
1065  return CAM_ERROR_NOTINIT;
1066 
1067  //find device handle and clear the status
1068  for(i=0;i<MAX_CAM_DEVICE_HANDLE;i++)
1069  {
1070  if(CamHandle[i].fd == handle)
1071  {
1072  CamHandle[i].status=0;
1073  break;
1074  }
1075 
1076 
1077  //see error to return
1078  if((i+1)== MAX_CAM_DEVICE_HANDLE)
1079  {
1080  return CAM_ERROR_BADHANDLE;
1081  }
1082  }
1083 
1084  return 0;
1085 }
1086 
1087 
1088 
1090 int PS2CamGetDeviceStatus(int handle)
1091 {
1092  CAMERA_DEVICE *dev;
1093 
1094 
1095 
1096  if(! irx_initialized)
1097  return CAM_ERROR_NOTINIT;
1098 
1099  if(handle > MAX_CAM_DEVICE_HANDLE || handle <= 0 || CamHandle[handle-1].status == 0)
1100  return CAM_ERROR_BADHANDLE;
1101 
1102  if(CamHandle[handle-1].status == -1)
1103  return CAM_ERROR_DISCONNECTED;
1104 
1105  dev = CamHandle[handle-1].cam;
1106 
1107 
1108  return dev->status;
1109 }
1110 
1111 
1112 
1114 int PS2CamGetDeviceInfo(int handle,int *info)
1115 {
1116  static unsigned int size;
1117  UsbDeviceDescriptor *dev;
1118  PS2CAM_DEVICE_INFO inf;
1119  PS2CAM_DEVICE_INFO *ptr;
1120  CAMERA_DEVICE *cam;
1121 
1122  if(! irx_initialized)
1123  return CAM_ERROR_NOTINIT;
1124 
1125  if(handle > MAX_CAM_DEVICE_HANDLE || handle <= 0 || CamHandle[handle-1].status == 0)
1126  return CAM_ERROR_BADHANDLE;
1127 
1128  if(CamHandle[handle-1].status == -1)
1129  return CAM_ERROR_DISCONNECTED;
1130 
1131  ptr = (PS2CAM_DEVICE_INFO *)info;
1132  size = ptr->ssize;
1133 
1134 
1135 
1136  if(size > sizeof(PS2CAM_DEVICE_INFO))
1137  {
1138  size = sizeof(PS2CAM_DEVICE_INFO);
1139  }
1140 
1141 
1142 
1143  cam = CamHandle[handle-1].cam;
1144 
1145  //get descripters
1146  dev = sceUsbdScanStaticDescriptor(cam->device_id, NULL, USB_DT_DEVICE);
1147 
1148 
1149  // now collect inf
1150  inf.ssize = size;
1151  inf.vendor_id = dev->idVendor;
1152  inf.product_id = dev->idProduct;
1153 
1154  PS2CamGetDeviceSring(cam, dev->iManufacturer, (char *)&inf.vendor_name[0] , 32);
1155  PS2CamGetDeviceSring(cam, dev->iProduct, (char *)&inf.product_name[0], 32);
1156 
1157 
1158  if(dev->idProduct == PS2CAM_PROD_EYETOY)
1159  {
1160  strcpy((char *)&inf.model[0],"SLEH-00030\0");
1161  }
1162  else if(dev->idProduct == PS2CAM_PROD_EYETOY2)
1163  {
1164  strcpy((char *)&inf.model[0],"SLEH-00031\0");
1165  }
1166  else
1167  {
1168  strcpy((char *)&inf.model[0],"UNKNOWN\0");
1169  }
1170 
1171  memcpy(info, &inf, size);
1172 
1173  return 0;
1174 }
1175 
1176 
1177 
1179 int PS2CamSetDeviceBandwidth(int handle, char bandwidth)
1180 {
1181  int i;
1182  CAMERA_DEVICE *cam;
1183 
1184  UsbDeviceDescriptor *dev;
1185  UsbInterfaceDescriptor *intf;
1186  UsbEndpointDescriptor *endp;
1187 
1188  if(! irx_initialized)
1189  return CAM_ERROR_NOTINIT;
1190 
1191  if(handle > MAX_CAM_DEVICE_HANDLE || handle <= 0 || CamHandle[handle-1].status == 0)
1192  return CAM_ERROR_BADHANDLE;
1193 
1194  if(CamHandle[handle-1].status == -1)
1195  return CAM_ERROR_DISCONNECTED;
1196 
1197 
1198  cam = CamHandle[handle-1].cam;
1199 
1200  cam->bandwidth = bandwidth;
1201 
1202 
1203 
1204  //search for enpoint to open
1205  dev = sceUsbdScanStaticDescriptor(cam->device_id, NULL, USB_DT_DEVICE);
1206  intf = sceUsbdScanStaticDescriptor(cam->device_id, dev, USB_DT_INTERFACE);
1207 
1208  for(i=0;i<cam->bandwidth;i++)
1209  {
1210  intf = sceUsbdScanStaticDescriptor(cam->device_id, intf, USB_DT_INTERFACE);
1211  }
1212 
1213  endp= (UsbEndpointDescriptor *) ((char *) intf + intf->bLength);
1214 
1215 
1216  // close old endpoint and open new one
1217  sceUsbdClosePipe(cam->stream);
1218  cam->stream = sceUsbdOpenPipe(cam->device_id, endp);
1219 
1220  cam->stream_pocket_size = (endp->wMaxPacketSizeHB * 256 + endp->wMaxPacketSizeLB);
1221  printf("bandwidth =%d\n",cam->stream_pocket_size);
1222 
1223 
1224 
1225  camStopStream(cam);
1226 
1227  switch(bandwidth)
1228  {
1229  case 0:
1230  PS2CamSelectInterface(cam,0,EYETOY_ALTERNATE_SIZE_0);
1231  break;
1232  case 1:
1233  PS2CamSelectInterface(cam,0,EYETOY_ALTERNATE_SIZE_384);
1234  break;
1235  case 2:
1236  PS2CamSelectInterface(cam,0,EYETOY_ALTERNATE_SIZE_512);
1237  break;
1238  case 3:
1239  PS2CamSelectInterface(cam,0,EYETOY_ALTERNATE_SIZE_768);
1240  break;
1241  case 4:
1242  PS2CamSelectInterface(cam,0,EYETOY_ALTERNATE_SIZE_896);
1243  break;
1244 
1245  }
1246 
1247  setReg8(cam, EYETOY_CREG_RESET1, 0x00);
1248 
1249  return 0;
1250 }
1251 
1252 
1253 
1255 int PS2CamReadPacket(int handle)
1256 {
1257 
1258  CAMERA_DEVICE *cam;
1259  int ret;
1260 
1261 
1262 
1263  if(! irx_initialized)
1264  return CAM_ERROR_NOTINIT;
1265 
1266  if(handle > MAX_CAM_DEVICE_HANDLE || handle <= 0 || CamHandle[handle-1].status == 0)
1267  return CAM_ERROR_BADHANDLE;
1268 
1269  if(CamHandle[handle-1].status == -1)
1270  return CAM_ERROR_DISCONNECTED;
1271 
1272 
1273  cam = CamHandle[handle-1].cam;
1274 
1275  if(cam == NULL) return CAM_ERROR_INVALIDDEVICE;
1276  if(cam->status < 2) return CAM_ERROR_DEVNOTREADY;
1277 
1278 
1279 
1280 
1281  switch(cam->bandwidth)
1282  {
1283  case EYETOY_ALTERNATE_SIZE_0:
1284  ret =0;
1285  break;
1286  case EYETOY_ALTERNATE_SIZE_384:
1287  ret = PS2CamReadData(cam, &campacket[0], 384);
1288  break;
1289  case EYETOY_ALTERNATE_SIZE_512:
1290  ret = PS2CamReadData(cam, &campacket[0], 512);
1291  break;
1292  case EYETOY_ALTERNATE_SIZE_768:
1293  ret = PS2CamReadData(cam, &campacket[0], 768);
1294  break;
1295  case EYETOY_ALTERNATE_SIZE_896:
1296  ret = PS2CamReadData(cam, &campacket[0], 896);
1297  break;
1298  default :
1299  ret = PS2CamReadData(cam, &campacket[0], 384);
1300  break;
1301  }
1302 
1303  return ret;
1304 }
1305 
1306 
1307 
1309 int PS2CamSetLEDMode(int handle, int mode)
1310 {
1311  CAMERA_DEVICE *cam;
1312 
1313  if(! irx_initialized)
1314  return CAM_ERROR_NOTINIT;
1315 
1316  if(handle > MAX_CAM_DEVICE_HANDLE || handle <= 0 || CamHandle[handle-1].status == 0)
1317  return CAM_ERROR_BADHANDLE;
1318 
1319  if(CamHandle[handle-1].status == -1)
1320  return CAM_ERROR_DISCONNECTED;
1321 
1322 
1323  cam = CamHandle[handle-1].cam;
1324 
1325  if(cam == NULL) return CAM_ERROR_INVALIDDEVICE;
1326  if(cam->status < 2) return CAM_ERROR_DEVNOTREADY;
1327 
1328 
1329 
1330  switch(mode)
1331  {
1332  case 0://off
1333  camTurnOffRedLed(cam);
1334  break;
1335  case 1://on
1336  camTurnOnRedLed(cam);
1337  break;
1338 // case 2://flash
1339 //
1340 // break;
1341  default:
1342  camTurnOffRedLed(cam);
1343  break;
1344  }
1345 
1346 
1347  return 0;
1348 }
1349 
1350 
1351 
1352 
1354 int PS2CamSetDeviceConfig(int handle, void *config)
1355 {
1356  CAMERA_DEVICE *cam;
1357  PS2CAM_DEVICE_CONFIG *cfg;
1358 
1359  if(! irx_initialized)
1360  return CAM_ERROR_NOTINIT;
1361 
1362  if(handle > MAX_CAM_DEVICE_HANDLE || handle <= 0 || CamHandle[handle-1].status == 0)
1363  return CAM_ERROR_BADHANDLE;
1364 
1365  if(CamHandle[handle-1].status == -1)
1366  return CAM_ERROR_DISCONNECTED;
1367 
1368 
1369  cam = CamHandle[handle-1].cam;
1370 
1371  if(cam == NULL) return CAM_ERROR_INVALIDDEVICE;
1372  if(cam->status < 2) return CAM_ERROR_DEVNOTREADY;
1373 
1374 
1375 
1376  cfg = (PS2CAM_DEVICE_CONFIG *)config;
1377 
1378  // stop data
1379  camStopStream(cam);
1380 
1381 
1382  //set rez
1383  if(cfg->mask & CAM_CONFIG_MASK_DIMENSION)
1384  {
1385 
1386  setReg8(cam, EYETOY_IREG_H_SIZE, cfg->width >>4);
1387  setReg8(cam, EYETOY_IREG_V_SIZE, cfg->height >>3);
1388  }
1389 
1390  //set offset
1391  if(cfg->mask & CAM_CONFIG_MASK_OFFSET)
1392  {
1393  unsigned char *p;
1394 
1395  p = (unsigned char *)&cfg->x_offset;
1396  setReg8(cam, EYETOY_IREG_X_OFFSETL, p[0]);
1397  setReg8(cam, EYETOY_IREG_X_OFFSETH, p[1]);
1398 
1399  p = (unsigned char *)&cfg->y_offset;
1400  setReg8(cam, EYETOY_IREG_Y_OFFSETL, p[0]);
1401  setReg8(cam, EYETOY_IREG_Y_OFFSETH, p[1]);
1402  }
1403 
1404  //set divider
1405  if(cfg->mask & CAM_CONFIG_MASK_DIVIDER)
1406  {
1407  if(cfg->h_divider > 4)cfg->h_divider = 4;
1408  if(cfg->v_divider > 4)cfg->v_divider = 4;
1409 
1410  camSetDIVIDER(cam, cfg->h_divider, 0, cfg->v_divider, 0);
1411  }
1412 
1413  //set framerate
1414  if(cfg->mask & CAM_CONFIG_MASK_FRAMERATE)
1415  {
1416 
1417  switch(cfg->framerate)
1418  {
1419  case 5:
1420  setReg8(cam, 0xa4, 0x04);
1421  setReg8(cam, 0x23, 0x1b);
1422  break;
1423  case 10:
1424  setReg8(cam, 0xa4, 0x04);
1425  setReg8(cam, 0x23, 0x1f);
1426  break;
1427  case 15:
1428  setReg8(cam, 0xa4, 0x04);
1429  setReg8(cam, 0x23, 0xff);
1430  break;
1431  case 25:
1432  setReg8(cam, 0xa4, 0x0c);
1433  setReg8(cam, 0x23, 0x1f);
1434  break;
1435  case 30:
1436  setReg8(cam, 0xa4, 0x0c);
1437  setReg8(cam, 0x23, 0xff);
1438  break;
1439  default:
1440  setReg8(cam, 0xa4, 0x0c);
1441  setReg8(cam, 0x23, 0xff);
1442  break;
1443  }
1444  }
1445 
1446 
1447  // restart data
1448  camStartStream(cam);
1449 
1450  return 0;
1451 }
1452 
1453 
1454 void *rpcCommandHandler(u32 command, void *buffer, int size)
1455 {
1456  int* buf = (int*) buffer;
1457  //char* ptr = (char*) buffer;
1458  int ret = 0;
1459 
1460  (void)size;
1461 
1462  switch (command)
1463  {
1464  case PS2CAM_RPC_GETIRXVERSION:
1465  ret = PS2CamGetIRXVersion();
1466 
1467  break;
1468  case PS2CAM_RPC_INITIALIZE:
1469  ret = PS2CamInit(buf[0]);
1470 
1471  break;
1472  case PS2CAM_RPC_GETDEVCOUNT:
1473  ret = PS2CamGetDeviceCount();
1474 
1475  break;
1476  case PS2CAM_RPC_OPENDEVICE:
1477  ret = PS2CamOpenDevice(buf[0]);
1478 
1479  break;
1480  case PS2CAM_RPC_CLOSEDEVICE:
1481  ret = PS2CamCloseDevice(buf[0]);
1482 
1483  break;
1484  case PS2CAM_RPC_GETDEVSTATUS:
1485  ret = PS2CamGetDeviceStatus(buf[0]);
1486 
1487  break;
1488  case PS2CAM_RPC_GETDEVINFO:
1489  ret = PS2CamGetDeviceInfo(buf[0],&buf[1]);
1490 
1491  break;
1492  case PS2CAM_RPC_SETDEVBANDWIDTH:
1493  ret = PS2CamSetDeviceBandwidth(buf[0], buf[1]);
1494 
1495  break;
1496  case PS2CAM_RPC_READPACKET:
1497  ret = PS2CamReadPacket(buf[0]);
1498 
1499  //get mem address so i can access it from ee
1500  buf[1] = (int )&campacket[0];
1501 
1502  break;
1503 
1504  case PS2CAM_RPC_SETLEDMODE:
1505  ret = PS2CamSetLEDMode(buf[0], buf[1]);
1506 
1507  break;
1508  case PS2CAM_RPC_SETDEVCONFIG:
1509  ret = PS2CamSetDeviceConfig(buf[0], &buf[1]);
1510 
1511  break;
1512  default:
1513  ret = CAM_ERROR_COMMUNKNOWN;
1514 
1515  break;
1516  }
1517 
1518 
1519  buf[0] = ret;
1520 
1521 
1522  return buffer;
1523 }
1524 
1525 
1526 
1527 
1528 
1529 
1530 /*EOF*/
PS2CAM_RPC_GETDEVCOUNT
#define PS2CAM_RPC_GETDEVCOUNT
Definition: ps2cam_rpc.h:20
CAM_ERROR_BADRANGE
#define CAM_ERROR_BADRANGE
Definition: ps2cam_rpc.h:67
PS2CAM_PROD_VISUALSTREAM
#define PS2CAM_PROD_VISUALSTREAM
Definition: ps2cam.h:58
UsbDeviceDescriptor
Definition: usbd.h:63
CAM_ERROR_DEVNOTREADY
#define CAM_ERROR_DEVNOTREADY
Definition: ps2cam_rpc.h:63
PS2CamSetDeviceConfig
int PS2CamSetDeviceConfig(int handle, void *config)
Definition: ps2cam.c:1354
USB_RC_OK
#define USB_RC_OK
Definition: usbd.h:238
PS2CAM_DEVICE_CONFIG::height
unsigned short height
Definition: ps2cam_rpc.h:130
PS2CamSetDeviceConfiguration
void PS2CamSetDeviceConfiguration(CAMERA_DEVICE *dev, int id)
Definition: ps2cam.c:429
ps2cam.h
getReg8
int getReg8(CAMERA_DEVICE *dev, unsigned char reg_id, unsigned char *value)
Definition: ps2cam.c:606
PS2CAM_VEND_SONY
#define PS2CAM_VEND_SONY
Definition: ps2cam.h:41
PS2CAM_DEVICE_INFO::vendor_name
unsigned char vendor_name[32]
Definition: ps2cam_rpc.h:113
PS2CAM_RPC_GETIRXVERSION
#define PS2CAM_RPC_GETIRXVERSION
Definition: ps2cam_rpc.h:16
thbase.h
PS2CamConnect
int PS2CamConnect(int devId)
Definition: ps2cam.c:213
iop_sema_t
Definition: thsemap.h:38
PS2CAM_RPC_INITIALIZE
#define PS2CAM_RPC_INITIALIZE
Definition: ps2cam_rpc.h:18
sysclib.h
PS2CAM_DEVICE_INFO::product_name
unsigned char product_name[32]
Definition: ps2cam_rpc.h:115
PS2CamInit
int PS2CamInit(int mode)
Definition: ps2cam.c:955
camResetUsb
void camResetUsb(CAMERA_DEVICE *dev)
Definition: ps2cam.c:797
CAM_ERROR_UNKNOWN
#define CAM_ERROR_UNKNOWN
Definition: ps2cam_rpc.h:69
PS2CAM_DEVICE_HANDLE
Definition: ps2cam.h:174
s_info
Definition: xprintf.c:78
PS2CAM_DEVICE_CONFIG::framerate
unsigned short framerate
Definition: ps2cam_rpc.h:140
CAM_STATUS_CONNECTED
#define CAM_STATUS_CONNECTED
Definition: ps2cam_rpc.h:45
PS2CAM_DEVICE_INFO::ssize
unsigned int ssize
Definition: ps2cam_rpc.h:107
PS2CAM_PROD_EYETOY2
#define PS2CAM_PROD_EYETOY2
Definition: ps2cam.h:51
_UsbDriver
Definition: usbd.h:47
PS2CAM_RPC_READPACKET
#define PS2CAM_RPC_READPACKET
Definition: ps2cam_rpc.h:30
PS2CamGetIRXVersion
int PS2CamGetIRXVersion(void)
Definition: ps2cam.c:940
EYETOY_ALTERNATE_SIZE_0
#define EYETOY_ALTERNATE_SIZE_0
Definition: ps2cam.h:102
PS2CamCallback
void PS2CamCallback(int resultCode, int bytes, void *arg)
Definition: ps2cam.c:570
PS2CamSetLEDMode
int PS2CamSetLEDMode(int handle, int mode)
Definition: ps2cam.c:1309
PS2CAM_DEVICE_CONFIG::h_divider
unsigned char h_divider
Definition: ps2cam_rpc.h:136
loadcore.h
CAMERA_DEVICE::controll
int controll
Definition: ps2cam.h:164
PS2CamGetDeviceCount
int PS2CamGetDeviceCount(void)
Definition: ps2cam.c:967
UsbEndpointDescriptor
Definition: usbd.h:108
usbd.h
PS2CamReadPacket
int PS2CamReadPacket(int handle)
Definition: ps2cam.c:1255
PS2CamProbe
int PS2CamProbe(int devId)
Definition: ps2cam.c:143
count
u32 count
start sector of fragmented bd/file
Definition: usbhdfsd-common.h:3
CAM_ERROR_COMMUNKNOWN
#define CAM_ERROR_COMMUNKNOWN
Definition: ps2cam_rpc.h:61
CAM_ERROR_BADHANDLE
#define CAM_ERROR_BADHANDLE
Definition: ps2cam_rpc.h:73
PS2CamGetDeviceInfo
int PS2CamGetDeviceInfo(int handle, int *info)
Definition: ps2cam.c:1114
PS2CAM_DEVICE_CONFIG::mask
unsigned int mask
Definition: ps2cam_rpc.h:126
PS2CAM_DEVICE_INFO::vendor_id
unsigned short vendor_id
Definition: ps2cam_rpc.h:109
thsemap.h
CAM_ERROR_NODEVICE
#define CAM_ERROR_NODEVICE
Definition: ps2cam_rpc.h:65
PS2CAM_DEVICE_INFO
Definition: ps2cam_rpc.h:104
PS2CAM_PROD_EYETOY3
#define PS2CAM_PROD_EYETOY3
Definition: ps2cam.h:53
PS2CamSetDeviceBandwidth
int PS2CamSetDeviceBandwidth(int handle, char bandwidth)
Definition: ps2cam.c:1179
PS2CAM_RPC_SETLEDMODE
#define PS2CAM_RPC_SETLEDMODE
Definition: ps2cam_rpc.h:32
PS2CAM_DEVICE_INFO::product_id
unsigned short product_id
Definition: ps2cam_rpc.h:111
CAM_ERROR_DISCONNECTED
#define CAM_ERROR_DISCONNECTED
Definition: ps2cam_rpc.h:75
PS2CamDisconnect
int PS2CamDisconnect(int devId)
Definition: ps2cam.c:297
CAMERA_DEVICE
Definition: ps2cam.h:155
usbd_macro.h
tamtypes.h
PS2CamOpenDevice
int PS2CamOpenDevice(int device_index)
Definition: ps2cam.c:991
PS2CAM_PROD_EYETOY
#define PS2CAM_PROD_EYETOY
Definition: ps2cam.h:49
stdio.h
CAM_ERROR_MAXHANDLE
#define CAM_ERROR_MAXHANDLE
Definition: ps2cam_rpc.h:71
camDisableSystem
void camDisableSystem(CAMERA_DEVICE *dev)
Definition: ps2cam.c:790
ioman.h
camTurnOffRedLed
void camTurnOffRedLed(CAMERA_DEVICE *dev)
Definition: ps2cam.c:830
_iop_thread
Definition: thbase.h:39
PS2CamInitDriver
int PS2CamInitDriver(void)
Definition: ps2cam.c:109
PS2CAM_DEVICE_CONFIG::x_offset
unsigned short x_offset
Definition: ps2cam_rpc.h:132
UsbConfigDescriptor
Definition: usbd.h:81
PS2CAM_DEVICE_CONFIG::y_offset
unsigned short y_offset
Definition: ps2cam_rpc.h:134
PS2CamSelectInterface
int PS2CamSelectInterface(CAMERA_DEVICE *dev, int interface, int altSetting)
Definition: ps2cam.c:712
camStartStream
void camStartStream(CAMERA_DEVICE *dev)
Definition: ps2cam.c:837
PS2CAM_DEVICE_CONFIG
Definition: ps2cam_rpc.h:121
PS2CAM_RPC_GETDEVINFO
#define PS2CAM_RPC_GETDEVINFO
Definition: ps2cam_rpc.h:26
t_SifRpcServerData
Definition: sifrpc-common.h:98
PS2CamGetDeviceSring
void PS2CamGetDeviceSring(CAMERA_DEVICE *dev, int index, char *str, int strmax)
Definition: ps2cam.c:674
PS2CAM_RPC_SETDEVBANDWIDTH
#define PS2CAM_RPC_SETDEVBANDWIDTH
Definition: ps2cam_rpc.h:28
PS2CAM_DEVICE_INFO::model
unsigned char model[16]
Definition: ps2cam_rpc.h:117
camTurnOnRedLed
void camTurnOnRedLed(CAMERA_DEVICE *dev)
Definition: ps2cam.c:823
t_SifRpcDataQueue
Definition: sifrpc-common.h:153
CAMERA_DEVICE::stream
int stream
Definition: ps2cam.h:166
sysmem.h
setReg8
int setReg8(CAMERA_DEVICE *dev, unsigned char reg_id, unsigned char value)
Definition: ps2cam.c:580
PS2CamInitializeNewDevice
void PS2CamInitializeNewDevice(CAMERA_DEVICE *cam)
Definition: ps2cam.c:382
__attribute__
Definition: gif_registers.h:38
PS2CAM_DEVICE_CONFIG::v_divider
unsigned char v_divider
Definition: ps2cam_rpc.h:138
PS2CamSetDeviceDefaults
void PS2CamSetDeviceDefaults(CAMERA_DEVICE *dev)
Definition: ps2cam.c:453
camSetUsbInit
void camSetUsbInit(CAMERA_DEVICE *dev)
Definition: ps2cam.c:805
PS2CAM_RPC_GETDEVSTATUS
#define PS2CAM_RPC_GETDEVSTATUS
Definition: ps2cam_rpc.h:24
PS2CamGetDeviceStatus
int PS2CamGetDeviceStatus(int handle)
Definition: ps2cam.c:1090
setReg8Mask
int setReg8Mask(CAMERA_DEVICE *dev, unsigned char reg_id, unsigned char value, unsigned char mask)
Definition: ps2cam.c:633
PS2CAM_PROD_EYETOY4
#define PS2CAM_PROD_EYETOY4
Definition: ps2cam.h:55
camEnableSystem
void camEnableSystem(CAMERA_DEVICE *dev)
Definition: ps2cam.c:778
camResetDevice
void camResetDevice(CAMERA_DEVICE *dev)
Definition: ps2cam.c:743
PS2CamCloseDevice
int PS2CamCloseDevice(int handle)
Definition: ps2cam.c:1060
PS2CAM_VEND_DLINK
#define PS2CAM_VEND_DLINK
Definition: ps2cam.h:43
PS2CAM_DEVICE_CONFIG::width
unsigned short width
Definition: ps2cam_rpc.h:128
UsbInterfaceDescriptor
Definition: usbd.h:95
CAM_STATUS_NOTCONNECTED
#define CAM_STATUS_NOTCONNECTED
Definition: ps2cam_rpc.h:43
camSetUsbWork
void camSetUsbWork(CAMERA_DEVICE *dev)
Definition: ps2cam.c:814
CAM_STATUS_CONNECTEDREADY
#define CAM_STATUS_CONNECTEDREADY
Definition: ps2cam_rpc.h:47
UsbStringDescriptor
Definition: usbd.h:119