2 * USB IBM C-It Video Camera driver
4 * Supports Xirlink C-It Video Camera, IBM PC Camera,
5 * IBM NetCamera and Veo Stingray.
7 * Copyright (C) 2010 Hans de Goede <hdegoede@redhat.com>
9 * This driver is based on earlier work of:
11 * (C) Copyright 1999 Johannes Erdfelt
12 * (C) Copyright 1999 Randy Dunlap
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32 #define MODULE_NAME "xirlink-cit"
34 #include <linux/input.h>
37 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
38 MODULE_DESCRIPTION("Xirlink C-IT");
39 MODULE_LICENSE("GPL");
41 /* FIXME we should autodetect this */
42 static int ibm_netcam_pro;
43 module_param(ibm_netcam_pro, int, 0);
44 MODULE_PARM_DESC(ibm_netcam_pro,
45 "Use IBM Netcamera Pro init sequences for Model 3 cams");
47 /* FIXME this should be handled through the V4L2 input selection API */
49 module_param(rca_input, int, 0644);
50 MODULE_PARM_DESC(rca_input,
51 "Use rca input instead of ccd sensor on Model 3 cams");
53 /* specific webcam descriptor */
55 struct gspca_dev gspca_dev; /* !! must be the first item */
56 struct v4l2_ctrl *lighting;
58 #define CIT_MODEL0 0 /* bcd version 0.01 cams ie the xvp-500 */
59 #define CIT_MODEL1 1 /* The model 1 - 4 nomenclature comes from the old */
60 #define CIT_MODEL2 2 /* ibmcam driver */
63 #define CIT_IBM_NETCAM_PRO 5
66 u8 stop_on_control_change;
71 static void sd_stop0(struct gspca_dev *gspca_dev);
73 static const struct v4l2_pix_format cif_yuv_mode[] = {
74 {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
76 .sizeimage = 176 * 144 * 3 / 2 + 4,
77 .colorspace = V4L2_COLORSPACE_SRGB},
78 {352, 288, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
80 .sizeimage = 352 * 288 * 3 / 2 + 4,
81 .colorspace = V4L2_COLORSPACE_SRGB},
84 static const struct v4l2_pix_format vga_yuv_mode[] = {
85 {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
87 .sizeimage = 160 * 120 * 3 / 2 + 4,
88 .colorspace = V4L2_COLORSPACE_SRGB},
89 {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
91 .sizeimage = 320 * 240 * 3 / 2 + 4,
92 .colorspace = V4L2_COLORSPACE_SRGB},
93 {640, 480, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
95 .sizeimage = 640 * 480 * 3 / 2 + 4,
96 .colorspace = V4L2_COLORSPACE_SRGB},
99 static const struct v4l2_pix_format model0_mode[] = {
100 {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
102 .sizeimage = 160 * 120 * 3 / 2 + 4,
103 .colorspace = V4L2_COLORSPACE_SRGB},
104 {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
106 .sizeimage = 176 * 144 * 3 / 2 + 4,
107 .colorspace = V4L2_COLORSPACE_SRGB},
108 {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
110 .sizeimage = 320 * 240 * 3 / 2 + 4,
111 .colorspace = V4L2_COLORSPACE_SRGB},
114 static const struct v4l2_pix_format model2_mode[] = {
115 {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
117 .sizeimage = 160 * 120 * 3 / 2 + 4,
118 .colorspace = V4L2_COLORSPACE_SRGB},
119 {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
121 .sizeimage = 176 * 144 * 3 / 2 + 4,
122 .colorspace = V4L2_COLORSPACE_SRGB},
123 {320, 240, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
125 .sizeimage = 320 * 240 + 4,
126 .colorspace = V4L2_COLORSPACE_SRGB},
127 {352, 288, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
129 .sizeimage = 352 * 288 + 4,
130 .colorspace = V4L2_COLORSPACE_SRGB},
134 * 01.01.08 - Added for RCA video in support -LO
135 * This struct is used to init the Model3 cam to use the RCA video in port
136 * instead of the CCD sensor.
138 static const u16 rca_initdata[][3] = {
675 /* TESTME the old ibmcam driver repeats certain commands to Model1 cameras, we
676 do the same for now (testing needed to see if this is really necessary) */
677 static const int cit_model1_ntries = 5;
678 static const int cit_model1_ntries2 = 2;
680 static int cit_write_reg(struct gspca_dev *gspca_dev, u16 value, u16 index)
682 struct usb_device *udev = gspca_dev->dev;
685 err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00,
686 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
687 value, index, NULL, 0, 1000);
689 pr_err("Failed to write a register (index 0x%04X, value 0x%02X, error %d)\n",
695 static int cit_read_reg(struct gspca_dev *gspca_dev, u16 index, int verbose)
697 struct usb_device *udev = gspca_dev->dev;
698 __u8 *buf = gspca_dev->usb_buf;
701 res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01,
702 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
703 0x00, index, buf, 8, 1000);
705 pr_err("Failed to read a register (index 0x%04X, error %d)\n",
711 PDEBUG(D_PROBE, "Register %04x value: %02x", index, buf[0]);
717 * cit_send_FF_04_02()
719 * This procedure sends magic 3-command prefix to the camera.
720 * The purpose of this prefix is not known.
725 static void cit_send_FF_04_02(struct gspca_dev *gspca_dev)
727 cit_write_reg(gspca_dev, 0x00FF, 0x0127);
728 cit_write_reg(gspca_dev, 0x0004, 0x0124);
729 cit_write_reg(gspca_dev, 0x0002, 0x0124);
732 static void cit_send_00_04_06(struct gspca_dev *gspca_dev)
734 cit_write_reg(gspca_dev, 0x0000, 0x0127);
735 cit_write_reg(gspca_dev, 0x0004, 0x0124);
736 cit_write_reg(gspca_dev, 0x0006, 0x0124);
739 static void cit_send_x_00(struct gspca_dev *gspca_dev, unsigned short x)
741 cit_write_reg(gspca_dev, x, 0x0127);
742 cit_write_reg(gspca_dev, 0x0000, 0x0124);
745 static void cit_send_x_00_05(struct gspca_dev *gspca_dev, unsigned short x)
747 cit_send_x_00(gspca_dev, x);
748 cit_write_reg(gspca_dev, 0x0005, 0x0124);
751 static void cit_send_x_00_05_02(struct gspca_dev *gspca_dev, unsigned short x)
753 cit_write_reg(gspca_dev, x, 0x0127);
754 cit_write_reg(gspca_dev, 0x0000, 0x0124);
755 cit_write_reg(gspca_dev, 0x0005, 0x0124);
756 cit_write_reg(gspca_dev, 0x0002, 0x0124);
759 static void cit_send_x_01_00_05(struct gspca_dev *gspca_dev, u16 x)
761 cit_write_reg(gspca_dev, x, 0x0127);
762 cit_write_reg(gspca_dev, 0x0001, 0x0124);
763 cit_write_reg(gspca_dev, 0x0000, 0x0124);
764 cit_write_reg(gspca_dev, 0x0005, 0x0124);
767 static void cit_send_x_00_05_02_01(struct gspca_dev *gspca_dev, u16 x)
769 cit_write_reg(gspca_dev, x, 0x0127);
770 cit_write_reg(gspca_dev, 0x0000, 0x0124);
771 cit_write_reg(gspca_dev, 0x0005, 0x0124);
772 cit_write_reg(gspca_dev, 0x0002, 0x0124);
773 cit_write_reg(gspca_dev, 0x0001, 0x0124);
776 static void cit_send_x_00_05_02_08_01(struct gspca_dev *gspca_dev, u16 x)
778 cit_write_reg(gspca_dev, x, 0x0127);
779 cit_write_reg(gspca_dev, 0x0000, 0x0124);
780 cit_write_reg(gspca_dev, 0x0005, 0x0124);
781 cit_write_reg(gspca_dev, 0x0002, 0x0124);
782 cit_write_reg(gspca_dev, 0x0008, 0x0124);
783 cit_write_reg(gspca_dev, 0x0001, 0x0124);
786 static void cit_Packet_Format1(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
788 cit_send_x_01_00_05(gspca_dev, 0x0088);
789 cit_send_x_00_05(gspca_dev, fkey);
790 cit_send_x_00_05_02_08_01(gspca_dev, val);
791 cit_send_x_00_05(gspca_dev, 0x0088);
792 cit_send_x_00_05_02_01(gspca_dev, fkey);
793 cit_send_x_00_05(gspca_dev, 0x0089);
794 cit_send_x_00(gspca_dev, fkey);
795 cit_send_00_04_06(gspca_dev);
796 cit_read_reg(gspca_dev, 0x0126, 0);
797 cit_send_FF_04_02(gspca_dev);
800 static void cit_PacketFormat2(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
802 cit_send_x_01_00_05(gspca_dev, 0x0088);
803 cit_send_x_00_05(gspca_dev, fkey);
804 cit_send_x_00_05_02(gspca_dev, val);
807 static void cit_model2_Packet2(struct gspca_dev *gspca_dev)
809 cit_write_reg(gspca_dev, 0x00ff, 0x012d);
810 cit_write_reg(gspca_dev, 0xfea3, 0x0124);
813 static void cit_model2_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
815 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
816 cit_write_reg(gspca_dev, 0x00ff, 0x012e);
817 cit_write_reg(gspca_dev, v1, 0x012f);
818 cit_write_reg(gspca_dev, 0x00ff, 0x0130);
819 cit_write_reg(gspca_dev, 0xc719, 0x0124);
820 cit_write_reg(gspca_dev, v2, 0x0127);
822 cit_model2_Packet2(gspca_dev);
826 * cit_model3_Packet1()
834 static void cit_model3_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
836 cit_write_reg(gspca_dev, 0x0078, 0x012d);
837 cit_write_reg(gspca_dev, v1, 0x012f);
838 cit_write_reg(gspca_dev, 0xd141, 0x0124);
839 cit_write_reg(gspca_dev, v2, 0x0127);
840 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
843 static void cit_model4_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
845 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
846 cit_write_reg(gspca_dev, v1, 0x012f);
847 cit_write_reg(gspca_dev, 0xd141, 0x0124);
848 cit_write_reg(gspca_dev, v2, 0x0127);
849 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
852 static void cit_model4_BrightnessPacket(struct gspca_dev *gspca_dev, u16 val)
854 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
855 cit_write_reg(gspca_dev, 0x0026, 0x012f);
856 cit_write_reg(gspca_dev, 0xd141, 0x0124);
857 cit_write_reg(gspca_dev, val, 0x0127);
858 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
859 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
860 cit_write_reg(gspca_dev, 0x0038, 0x012d);
861 cit_write_reg(gspca_dev, 0x0004, 0x012f);
862 cit_write_reg(gspca_dev, 0xd145, 0x0124);
863 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
866 /* this function is called at probe time */
867 static int sd_config(struct gspca_dev *gspca_dev,
868 const struct usb_device_id *id)
870 struct sd *sd = (struct sd *) gspca_dev;
873 sd->model = id->driver_info;
874 if (sd->model == CIT_MODEL3 && ibm_netcam_pro)
875 sd->model = CIT_IBM_NETCAM_PRO;
877 cam = &gspca_dev->cam;
880 cam->cam_mode = model0_mode;
881 cam->nmodes = ARRAY_SIZE(model0_mode);
885 cam->cam_mode = cif_yuv_mode;
886 cam->nmodes = ARRAY_SIZE(cif_yuv_mode);
890 cam->cam_mode = model2_mode + 1; /* no 160x120 */
894 cam->cam_mode = vga_yuv_mode;
895 cam->nmodes = ARRAY_SIZE(vga_yuv_mode);
896 sd->stop_on_control_change = 1;
900 cam->cam_mode = model2_mode;
901 cam->nmodes = ARRAY_SIZE(model2_mode);
903 case CIT_IBM_NETCAM_PRO:
904 cam->cam_mode = vga_yuv_mode;
905 cam->nmodes = 2; /* no 640 x 480 */
906 cam->input_flags = V4L2_IN_ST_VFLIP;
907 sd->stop_on_control_change = 1;
915 static int cit_init_model0(struct gspca_dev *gspca_dev)
917 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
918 cit_write_reg(gspca_dev, 0x0001, 0x0112); /* turn on autogain ? */
919 cit_write_reg(gspca_dev, 0x0000, 0x0400);
920 cit_write_reg(gspca_dev, 0x0001, 0x0400);
921 cit_write_reg(gspca_dev, 0x0000, 0x0420);
922 cit_write_reg(gspca_dev, 0x0001, 0x0420);
923 cit_write_reg(gspca_dev, 0x000d, 0x0409);
924 cit_write_reg(gspca_dev, 0x0002, 0x040a);
925 cit_write_reg(gspca_dev, 0x0018, 0x0405);
926 cit_write_reg(gspca_dev, 0x0008, 0x0435);
927 cit_write_reg(gspca_dev, 0x0026, 0x040b);
928 cit_write_reg(gspca_dev, 0x0007, 0x0437);
929 cit_write_reg(gspca_dev, 0x0015, 0x042f);
930 cit_write_reg(gspca_dev, 0x002b, 0x0439);
931 cit_write_reg(gspca_dev, 0x0026, 0x043a);
932 cit_write_reg(gspca_dev, 0x0008, 0x0438);
933 cit_write_reg(gspca_dev, 0x001e, 0x042b);
934 cit_write_reg(gspca_dev, 0x0041, 0x042c);
939 static int cit_init_ibm_netcam_pro(struct gspca_dev *gspca_dev)
941 cit_read_reg(gspca_dev, 0x128, 1);
942 cit_write_reg(gspca_dev, 0x0003, 0x0133);
943 cit_write_reg(gspca_dev, 0x0000, 0x0117);
944 cit_write_reg(gspca_dev, 0x0008, 0x0123);
945 cit_write_reg(gspca_dev, 0x0000, 0x0100);
946 cit_read_reg(gspca_dev, 0x0116, 0);
947 cit_write_reg(gspca_dev, 0x0060, 0x0116);
948 cit_write_reg(gspca_dev, 0x0002, 0x0112);
949 cit_write_reg(gspca_dev, 0x0000, 0x0133);
950 cit_write_reg(gspca_dev, 0x0000, 0x0123);
951 cit_write_reg(gspca_dev, 0x0001, 0x0117);
952 cit_write_reg(gspca_dev, 0x0040, 0x0108);
953 cit_write_reg(gspca_dev, 0x0019, 0x012c);
954 cit_write_reg(gspca_dev, 0x0060, 0x0116);
955 cit_write_reg(gspca_dev, 0x0002, 0x0115);
956 cit_write_reg(gspca_dev, 0x000b, 0x0115);
958 cit_write_reg(gspca_dev, 0x0078, 0x012d);
959 cit_write_reg(gspca_dev, 0x0001, 0x012f);
960 cit_write_reg(gspca_dev, 0xd141, 0x0124);
961 cit_write_reg(gspca_dev, 0x0079, 0x012d);
962 cit_write_reg(gspca_dev, 0x00ff, 0x0130);
963 cit_write_reg(gspca_dev, 0xcd41, 0x0124);
964 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
965 cit_read_reg(gspca_dev, 0x0126, 1);
967 cit_model3_Packet1(gspca_dev, 0x0000, 0x0000);
968 cit_model3_Packet1(gspca_dev, 0x0000, 0x0001);
969 cit_model3_Packet1(gspca_dev, 0x000b, 0x0000);
970 cit_model3_Packet1(gspca_dev, 0x000c, 0x0008);
971 cit_model3_Packet1(gspca_dev, 0x000d, 0x003a);
972 cit_model3_Packet1(gspca_dev, 0x000e, 0x0060);
973 cit_model3_Packet1(gspca_dev, 0x000f, 0x0060);
974 cit_model3_Packet1(gspca_dev, 0x0010, 0x0008);
975 cit_model3_Packet1(gspca_dev, 0x0011, 0x0004);
976 cit_model3_Packet1(gspca_dev, 0x0012, 0x0028);
977 cit_model3_Packet1(gspca_dev, 0x0013, 0x0002);
978 cit_model3_Packet1(gspca_dev, 0x0014, 0x0000);
979 cit_model3_Packet1(gspca_dev, 0x0015, 0x00fb);
980 cit_model3_Packet1(gspca_dev, 0x0016, 0x0002);
981 cit_model3_Packet1(gspca_dev, 0x0017, 0x0037);
982 cit_model3_Packet1(gspca_dev, 0x0018, 0x0036);
983 cit_model3_Packet1(gspca_dev, 0x001e, 0x0000);
984 cit_model3_Packet1(gspca_dev, 0x001f, 0x0008);
985 cit_model3_Packet1(gspca_dev, 0x0020, 0x00c1);
986 cit_model3_Packet1(gspca_dev, 0x0021, 0x0034);
987 cit_model3_Packet1(gspca_dev, 0x0022, 0x0034);
988 cit_model3_Packet1(gspca_dev, 0x0025, 0x0002);
989 cit_model3_Packet1(gspca_dev, 0x0028, 0x0022);
990 cit_model3_Packet1(gspca_dev, 0x0029, 0x000a);
991 cit_model3_Packet1(gspca_dev, 0x002b, 0x0000);
992 cit_model3_Packet1(gspca_dev, 0x002c, 0x0000);
993 cit_model3_Packet1(gspca_dev, 0x002d, 0x00ff);
994 cit_model3_Packet1(gspca_dev, 0x002e, 0x00ff);
995 cit_model3_Packet1(gspca_dev, 0x002f, 0x00ff);
996 cit_model3_Packet1(gspca_dev, 0x0030, 0x00ff);
997 cit_model3_Packet1(gspca_dev, 0x0031, 0x00ff);
998 cit_model3_Packet1(gspca_dev, 0x0032, 0x0007);
999 cit_model3_Packet1(gspca_dev, 0x0033, 0x0005);
1000 cit_model3_Packet1(gspca_dev, 0x0037, 0x0040);
1001 cit_model3_Packet1(gspca_dev, 0x0039, 0x0000);
1002 cit_model3_Packet1(gspca_dev, 0x003a, 0x0000);
1003 cit_model3_Packet1(gspca_dev, 0x003b, 0x0001);
1004 cit_model3_Packet1(gspca_dev, 0x003c, 0x0000);
1005 cit_model3_Packet1(gspca_dev, 0x0040, 0x000c);
1006 cit_model3_Packet1(gspca_dev, 0x0041, 0x00fb);
1007 cit_model3_Packet1(gspca_dev, 0x0042, 0x0002);
1008 cit_model3_Packet1(gspca_dev, 0x0043, 0x0000);
1009 cit_model3_Packet1(gspca_dev, 0x0045, 0x0000);
1010 cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
1011 cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
1012 cit_model3_Packet1(gspca_dev, 0x0048, 0x0000);
1013 cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
1014 cit_model3_Packet1(gspca_dev, 0x004a, 0x00ff);
1015 cit_model3_Packet1(gspca_dev, 0x004b, 0x00ff);
1016 cit_model3_Packet1(gspca_dev, 0x004c, 0x00ff);
1017 cit_model3_Packet1(gspca_dev, 0x004f, 0x0000);
1018 cit_model3_Packet1(gspca_dev, 0x0050, 0x0000);
1019 cit_model3_Packet1(gspca_dev, 0x0051, 0x0002);
1020 cit_model3_Packet1(gspca_dev, 0x0055, 0x0000);
1021 cit_model3_Packet1(gspca_dev, 0x0056, 0x0000);
1022 cit_model3_Packet1(gspca_dev, 0x0057, 0x0000);
1023 cit_model3_Packet1(gspca_dev, 0x0058, 0x0002);
1024 cit_model3_Packet1(gspca_dev, 0x0059, 0x0000);
1025 cit_model3_Packet1(gspca_dev, 0x005c, 0x0016);
1026 cit_model3_Packet1(gspca_dev, 0x005d, 0x0022);
1027 cit_model3_Packet1(gspca_dev, 0x005e, 0x003c);
1028 cit_model3_Packet1(gspca_dev, 0x005f, 0x0050);
1029 cit_model3_Packet1(gspca_dev, 0x0060, 0x0044);
1030 cit_model3_Packet1(gspca_dev, 0x0061, 0x0005);
1031 cit_model3_Packet1(gspca_dev, 0x006a, 0x007e);
1032 cit_model3_Packet1(gspca_dev, 0x006f, 0x0000);
1033 cit_model3_Packet1(gspca_dev, 0x0072, 0x001b);
1034 cit_model3_Packet1(gspca_dev, 0x0073, 0x0005);
1035 cit_model3_Packet1(gspca_dev, 0x0074, 0x000a);
1036 cit_model3_Packet1(gspca_dev, 0x0075, 0x001b);
1037 cit_model3_Packet1(gspca_dev, 0x0076, 0x002a);
1038 cit_model3_Packet1(gspca_dev, 0x0077, 0x003c);
1039 cit_model3_Packet1(gspca_dev, 0x0078, 0x0050);
1040 cit_model3_Packet1(gspca_dev, 0x007b, 0x0000);
1041 cit_model3_Packet1(gspca_dev, 0x007c, 0x0011);
1042 cit_model3_Packet1(gspca_dev, 0x007d, 0x0024);
1043 cit_model3_Packet1(gspca_dev, 0x007e, 0x0043);
1044 cit_model3_Packet1(gspca_dev, 0x007f, 0x005a);
1045 cit_model3_Packet1(gspca_dev, 0x0084, 0x0020);
1046 cit_model3_Packet1(gspca_dev, 0x0085, 0x0033);
1047 cit_model3_Packet1(gspca_dev, 0x0086, 0x000a);
1048 cit_model3_Packet1(gspca_dev, 0x0087, 0x0030);
1049 cit_model3_Packet1(gspca_dev, 0x0088, 0x0070);
1050 cit_model3_Packet1(gspca_dev, 0x008b, 0x0008);
1051 cit_model3_Packet1(gspca_dev, 0x008f, 0x0000);
1052 cit_model3_Packet1(gspca_dev, 0x0090, 0x0006);
1053 cit_model3_Packet1(gspca_dev, 0x0091, 0x0028);
1054 cit_model3_Packet1(gspca_dev, 0x0092, 0x005a);
1055 cit_model3_Packet1(gspca_dev, 0x0093, 0x0082);
1056 cit_model3_Packet1(gspca_dev, 0x0096, 0x0014);
1057 cit_model3_Packet1(gspca_dev, 0x0097, 0x0020);
1058 cit_model3_Packet1(gspca_dev, 0x0098, 0x0000);
1059 cit_model3_Packet1(gspca_dev, 0x00b0, 0x0046);
1060 cit_model3_Packet1(gspca_dev, 0x00b1, 0x0000);
1061 cit_model3_Packet1(gspca_dev, 0x00b2, 0x0000);
1062 cit_model3_Packet1(gspca_dev, 0x00b3, 0x0004);
1063 cit_model3_Packet1(gspca_dev, 0x00b4, 0x0007);
1064 cit_model3_Packet1(gspca_dev, 0x00b6, 0x0002);
1065 cit_model3_Packet1(gspca_dev, 0x00b7, 0x0004);
1066 cit_model3_Packet1(gspca_dev, 0x00bb, 0x0000);
1067 cit_model3_Packet1(gspca_dev, 0x00bc, 0x0001);
1068 cit_model3_Packet1(gspca_dev, 0x00bd, 0x0000);
1069 cit_model3_Packet1(gspca_dev, 0x00bf, 0x0000);
1070 cit_model3_Packet1(gspca_dev, 0x00c0, 0x00c8);
1071 cit_model3_Packet1(gspca_dev, 0x00c1, 0x0014);
1072 cit_model3_Packet1(gspca_dev, 0x00c2, 0x0001);
1073 cit_model3_Packet1(gspca_dev, 0x00c3, 0x0000);
1074 cit_model3_Packet1(gspca_dev, 0x00c4, 0x0004);
1075 cit_model3_Packet1(gspca_dev, 0x00cb, 0x00bf);
1076 cit_model3_Packet1(gspca_dev, 0x00cc, 0x00bf);
1077 cit_model3_Packet1(gspca_dev, 0x00cd, 0x00bf);
1078 cit_model3_Packet1(gspca_dev, 0x00ce, 0x0000);
1079 cit_model3_Packet1(gspca_dev, 0x00cf, 0x0020);
1080 cit_model3_Packet1(gspca_dev, 0x00d0, 0x0040);
1081 cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
1082 cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
1083 cit_model3_Packet1(gspca_dev, 0x00d2, 0x00bf);
1084 cit_model3_Packet1(gspca_dev, 0x00d3, 0x00bf);
1085 cit_model3_Packet1(gspca_dev, 0x00ea, 0x0008);
1086 cit_model3_Packet1(gspca_dev, 0x00eb, 0x0000);
1087 cit_model3_Packet1(gspca_dev, 0x00ec, 0x00e8);
1088 cit_model3_Packet1(gspca_dev, 0x00ed, 0x0001);
1089 cit_model3_Packet1(gspca_dev, 0x00ef, 0x0022);
1090 cit_model3_Packet1(gspca_dev, 0x00f0, 0x0000);
1091 cit_model3_Packet1(gspca_dev, 0x00f2, 0x0028);
1092 cit_model3_Packet1(gspca_dev, 0x00f4, 0x0002);
1093 cit_model3_Packet1(gspca_dev, 0x00f5, 0x0000);
1094 cit_model3_Packet1(gspca_dev, 0x00fa, 0x0000);
1095 cit_model3_Packet1(gspca_dev, 0x00fb, 0x0001);
1096 cit_model3_Packet1(gspca_dev, 0x00fc, 0x0000);
1097 cit_model3_Packet1(gspca_dev, 0x00fd, 0x0000);
1098 cit_model3_Packet1(gspca_dev, 0x00fe, 0x0000);
1099 cit_model3_Packet1(gspca_dev, 0x00ff, 0x0000);
1101 cit_model3_Packet1(gspca_dev, 0x00be, 0x0003);
1102 cit_model3_Packet1(gspca_dev, 0x00c8, 0x0000);
1103 cit_model3_Packet1(gspca_dev, 0x00c9, 0x0020);
1104 cit_model3_Packet1(gspca_dev, 0x00ca, 0x0040);
1105 cit_model3_Packet1(gspca_dev, 0x0053, 0x0001);
1106 cit_model3_Packet1(gspca_dev, 0x0082, 0x000e);
1107 cit_model3_Packet1(gspca_dev, 0x0083, 0x0020);
1108 cit_model3_Packet1(gspca_dev, 0x0034, 0x003c);
1109 cit_model3_Packet1(gspca_dev, 0x006e, 0x0055);
1110 cit_model3_Packet1(gspca_dev, 0x0062, 0x0005);
1111 cit_model3_Packet1(gspca_dev, 0x0063, 0x0008);
1112 cit_model3_Packet1(gspca_dev, 0x0066, 0x000a);
1113 cit_model3_Packet1(gspca_dev, 0x0067, 0x0006);
1114 cit_model3_Packet1(gspca_dev, 0x006b, 0x0010);
1115 cit_model3_Packet1(gspca_dev, 0x005a, 0x0001);
1116 cit_model3_Packet1(gspca_dev, 0x005b, 0x000a);
1117 cit_model3_Packet1(gspca_dev, 0x0023, 0x0006);
1118 cit_model3_Packet1(gspca_dev, 0x0026, 0x0004);
1119 cit_model3_Packet1(gspca_dev, 0x0036, 0x0069);
1120 cit_model3_Packet1(gspca_dev, 0x0038, 0x0064);
1121 cit_model3_Packet1(gspca_dev, 0x003d, 0x0003);
1122 cit_model3_Packet1(gspca_dev, 0x003e, 0x0001);
1123 cit_model3_Packet1(gspca_dev, 0x00b8, 0x0014);
1124 cit_model3_Packet1(gspca_dev, 0x00b9, 0x0014);
1125 cit_model3_Packet1(gspca_dev, 0x00e6, 0x0004);
1126 cit_model3_Packet1(gspca_dev, 0x00e8, 0x0001);
1131 /* this function is called at probe and resume time */
1132 static int sd_init(struct gspca_dev *gspca_dev)
1134 struct sd *sd = (struct sd *) gspca_dev;
1136 switch (sd->model) {
1138 cit_init_model0(gspca_dev);
1139 sd_stop0(gspca_dev);
1145 break; /* All is done in sd_start */
1146 case CIT_IBM_NETCAM_PRO:
1147 cit_init_ibm_netcam_pro(gspca_dev);
1148 sd_stop0(gspca_dev);
1154 static int cit_set_brightness(struct gspca_dev *gspca_dev, s32 val)
1156 struct sd *sd = (struct sd *) gspca_dev;
1159 switch (sd->model) {
1161 case CIT_IBM_NETCAM_PRO:
1162 /* No (known) brightness control for these */
1165 /* Model 1: Brightness range 0 - 63 */
1166 cit_Packet_Format1(gspca_dev, 0x0031, val);
1167 cit_Packet_Format1(gspca_dev, 0x0032, val);
1168 cit_Packet_Format1(gspca_dev, 0x0033, val);
1171 /* Model 2: Brightness range 0x60 - 0xee */
1172 /* Scale 0 - 63 to 0x60 - 0xee */
1173 i = 0x60 + val * 2254 / 1000;
1174 cit_model2_Packet1(gspca_dev, 0x001a, i);
1177 /* Model 3: Brightness range 'i' in [0x0C..0x3F] */
1181 cit_model3_Packet1(gspca_dev, 0x0036, i);
1184 /* Model 4: Brightness range 'i' in [0x04..0xb4] */
1185 /* Scale 0 - 63 to 0x04 - 0xb4 */
1186 i = 0x04 + val * 2794 / 1000;
1187 cit_model4_BrightnessPacket(gspca_dev, i);
1194 static int cit_set_contrast(struct gspca_dev *gspca_dev, s32 val)
1196 struct sd *sd = (struct sd *) gspca_dev;
1198 switch (sd->model) {
1201 /* gain 0-15, 0-20 -> 0-15 */
1202 i = val * 1000 / 1333;
1203 cit_write_reg(gspca_dev, i, 0x0422);
1204 /* gain 0-31, may not be lower then 0x0422, 0-20 -> 0-31 */
1205 i = val * 2000 / 1333;
1206 cit_write_reg(gspca_dev, i, 0x0423);
1207 /* gain 0-127, may not be lower then 0x0423, 0-20 -> 0-63 */
1208 i = val * 4000 / 1333;
1209 cit_write_reg(gspca_dev, i, 0x0424);
1210 /* gain 0-127, may not be lower then 0x0424, , 0-20 -> 0-127 */
1211 i = val * 8000 / 1333;
1212 cit_write_reg(gspca_dev, i, 0x0425);
1217 /* These models do not have this control. */
1221 /* Scale 0 - 20 to 15 - 0 */
1222 int i, new_contrast = (20 - val) * 1000 / 1333;
1223 for (i = 0; i < cit_model1_ntries; i++) {
1224 cit_Packet_Format1(gspca_dev, 0x0014, new_contrast);
1225 cit_send_FF_04_02(gspca_dev);
1230 { /* Preset hardware values */
1231 static const struct {
1236 { 0x05, 0x05, 0x0f }, /* Minimum */
1237 { 0x04, 0x04, 0x16 },
1238 { 0x02, 0x03, 0x16 },
1239 { 0x02, 0x08, 0x16 },
1240 { 0x01, 0x0c, 0x16 },
1241 { 0x01, 0x0e, 0x16 },
1242 { 0x01, 0x10, 0x16 } /* Maximum */
1245 cit_model3_Packet1(gspca_dev, 0x0067, cv[i].cv1);
1246 cit_model3_Packet1(gspca_dev, 0x005b, cv[i].cv2);
1247 cit_model3_Packet1(gspca_dev, 0x005c, cv[i].cv3);
1250 case CIT_IBM_NETCAM_PRO:
1251 cit_model3_Packet1(gspca_dev, 0x005b, val + 1);
1257 static int cit_set_hue(struct gspca_dev *gspca_dev, s32 val)
1259 struct sd *sd = (struct sd *) gspca_dev;
1261 switch (sd->model) {
1264 case CIT_IBM_NETCAM_PRO:
1265 /* No hue control for these models */
1268 cit_model2_Packet1(gspca_dev, 0x0024, val);
1269 /* cit_model2_Packet1(gspca_dev, 0x0020, sat); */
1272 /* Model 3: Brightness range 'i' in [0x05..0x37] */
1273 /* TESTME according to the ibmcam driver this does not work */
1275 /* Scale 0 - 127 to 0x05 - 0x37 */
1276 int i = 0x05 + val * 1000 / 2540;
1277 cit_model3_Packet1(gspca_dev, 0x007e, i);
1282 /* HDG: taken from ibmcam, setting the color gains does not
1283 * really belong here.
1285 * I am not sure r/g/b_gain variables exactly control gain
1286 * of those channels. Most likely they subtly change some
1287 * very internal image processing settings in the camera.
1288 * In any case, here is what they do, and feel free to tweak:
1290 * r_gain: seriously affects red gain
1291 * g_gain: seriously affects green gain
1292 * b_gain: seriously affects blue gain
1293 * hue: changes average color from violet (0) to red (0xFF)
1295 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
1296 cit_write_reg(gspca_dev, 0x001e, 0x012f);
1297 cit_write_reg(gspca_dev, 0xd141, 0x0124);
1298 cit_write_reg(gspca_dev, 160, 0x0127); /* Green gain */
1299 cit_write_reg(gspca_dev, 160, 0x012e); /* Red gain */
1300 cit_write_reg(gspca_dev, 160, 0x0130); /* Blue gain */
1301 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
1302 cit_write_reg(gspca_dev, val, 0x012d); /* Hue */
1303 cit_write_reg(gspca_dev, 0xf545, 0x0124);
1309 static int cit_set_sharpness(struct gspca_dev *gspca_dev, s32 val)
1311 struct sd *sd = (struct sd *) gspca_dev;
1313 switch (sd->model) {
1317 case CIT_IBM_NETCAM_PRO:
1318 /* These models do not have this control */
1322 const unsigned short sa[] = {
1323 0x11, 0x13, 0x16, 0x18, 0x1a, 0x8, 0x0a };
1325 for (i = 0; i < cit_model1_ntries; i++)
1326 cit_PacketFormat2(gspca_dev, 0x0013, sa[val]);
1331 * "Use a table of magic numbers.
1332 * This setting doesn't really change much.
1333 * But that's how Windows does it."
1335 static const struct {
1341 { 0x00, 0x00, 0x05, 0x14 }, /* Smoothest */
1342 { 0x01, 0x04, 0x05, 0x14 },
1343 { 0x02, 0x04, 0x05, 0x14 },
1344 { 0x03, 0x04, 0x05, 0x14 },
1345 { 0x03, 0x05, 0x05, 0x14 },
1346 { 0x03, 0x06, 0x05, 0x14 },
1347 { 0x03, 0x07, 0x05, 0x14 } /* Sharpest */
1349 cit_model3_Packet1(gspca_dev, 0x0060, sv[val].sv1);
1350 cit_model3_Packet1(gspca_dev, 0x0061, sv[val].sv2);
1351 cit_model3_Packet1(gspca_dev, 0x0062, sv[val].sv3);
1352 cit_model3_Packet1(gspca_dev, 0x0063, sv[val].sv4);
1360 * cit_set_lighting()
1363 * We have 3 levels of lighting conditions: 0=Bright, 1=Medium, 2=Low.
1366 * We have 16 levels of lighting, 0 for bright light and up to 15 for
1367 * low light. But values above 5 or so are useless because camera is
1368 * not really capable to produce anything worth viewing at such light.
1369 * This setting may be altered only in certain camera state.
1371 * Low lighting forces slower FPS.
1375 * 2/20/00 Added support for Model 2 cameras.
1377 static void cit_set_lighting(struct gspca_dev *gspca_dev, s32 val)
1379 struct sd *sd = (struct sd *) gspca_dev;
1381 switch (sd->model) {
1386 case CIT_IBM_NETCAM_PRO:
1390 for (i = 0; i < cit_model1_ntries; i++)
1391 cit_Packet_Format1(gspca_dev, 0x0027, val);
1397 static void cit_set_hflip(struct gspca_dev *gspca_dev, s32 val)
1399 struct sd *sd = (struct sd *) gspca_dev;
1401 switch (sd->model) {
1404 cit_write_reg(gspca_dev, 0x0020, 0x0115);
1406 cit_write_reg(gspca_dev, 0x0040, 0x0115);
1412 case CIT_IBM_NETCAM_PRO:
1417 static int cit_restart_stream(struct gspca_dev *gspca_dev)
1419 struct sd *sd = (struct sd *) gspca_dev;
1421 switch (sd->model) {
1424 cit_write_reg(gspca_dev, 0x0001, 0x0114);
1428 cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
1429 usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
1432 case CIT_IBM_NETCAM_PRO:
1433 cit_write_reg(gspca_dev, 0x0001, 0x0114);
1434 cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
1435 usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
1436 /* Clear button events from while we were not streaming */
1437 cit_write_reg(gspca_dev, 0x0001, 0x0113);
1446 static int cit_get_packet_size(struct gspca_dev *gspca_dev)
1448 struct usb_host_interface *alt;
1449 struct usb_interface *intf;
1451 intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
1452 alt = usb_altnum_to_altsetting(intf, gspca_dev->alt);
1454 pr_err("Couldn't get altsetting\n");
1458 if (alt->desc.bNumEndpoints < 1)
1461 return le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
1464 /* Calculate the clockdiv giving us max fps given the available bandwidth */
1465 static int cit_get_clock_div(struct gspca_dev *gspca_dev)
1467 int clock_div = 7; /* 0=30 1=25 2=20 3=15 4=12 5=7.5 6=6 7=3fps ?? */
1468 int fps[8] = { 30, 25, 20, 15, 12, 8, 6, 3 };
1471 packet_size = cit_get_packet_size(gspca_dev);
1472 if (packet_size < 0)
1475 while (clock_div > 3 &&
1476 1000 * packet_size >
1477 gspca_dev->pixfmt.width * gspca_dev->pixfmt.height *
1478 fps[clock_div - 1] * 3 / 2)
1482 "PacketSize: %d, res: %dx%d -> using clockdiv: %d (%d fps)",
1483 packet_size, gspca_dev->pixfmt.width, gspca_dev->pixfmt.height,
1484 clock_div, fps[clock_div]);
1489 static int cit_start_model0(struct gspca_dev *gspca_dev)
1491 const unsigned short compression = 0; /* 0=none, 7=best frame rate */
1494 clock_div = cit_get_clock_div(gspca_dev);
1498 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
1499 cit_write_reg(gspca_dev, 0x0003, 0x0438);
1500 cit_write_reg(gspca_dev, 0x001e, 0x042b);
1501 cit_write_reg(gspca_dev, 0x0041, 0x042c);
1502 cit_write_reg(gspca_dev, 0x0008, 0x0436);
1503 cit_write_reg(gspca_dev, 0x0024, 0x0403);
1504 cit_write_reg(gspca_dev, 0x002c, 0x0404);
1505 cit_write_reg(gspca_dev, 0x0002, 0x0426);
1506 cit_write_reg(gspca_dev, 0x0014, 0x0427);
1508 switch (gspca_dev->pixfmt.width) {
1509 case 160: /* 160x120 */
1510 cit_write_reg(gspca_dev, 0x0004, 0x010b);
1511 cit_write_reg(gspca_dev, 0x0001, 0x010a);
1512 cit_write_reg(gspca_dev, 0x0010, 0x0102);
1513 cit_write_reg(gspca_dev, 0x00a0, 0x0103);
1514 cit_write_reg(gspca_dev, 0x0000, 0x0104);
1515 cit_write_reg(gspca_dev, 0x0078, 0x0105);
1518 case 176: /* 176x144 */
1519 cit_write_reg(gspca_dev, 0x0006, 0x010b);
1520 cit_write_reg(gspca_dev, 0x0000, 0x010a);
1521 cit_write_reg(gspca_dev, 0x0005, 0x0102);
1522 cit_write_reg(gspca_dev, 0x00b0, 0x0103);
1523 cit_write_reg(gspca_dev, 0x0000, 0x0104);
1524 cit_write_reg(gspca_dev, 0x0090, 0x0105);
1527 case 320: /* 320x240 */
1528 cit_write_reg(gspca_dev, 0x0008, 0x010b);
1529 cit_write_reg(gspca_dev, 0x0004, 0x010a);
1530 cit_write_reg(gspca_dev, 0x0005, 0x0102);
1531 cit_write_reg(gspca_dev, 0x00a0, 0x0103);
1532 cit_write_reg(gspca_dev, 0x0010, 0x0104);
1533 cit_write_reg(gspca_dev, 0x0078, 0x0105);
1537 cit_write_reg(gspca_dev, compression, 0x0109);
1538 cit_write_reg(gspca_dev, clock_div, 0x0111);
1543 static int cit_start_model1(struct gspca_dev *gspca_dev)
1545 struct sd *sd = (struct sd *) gspca_dev;
1548 clock_div = cit_get_clock_div(gspca_dev);
1552 cit_read_reg(gspca_dev, 0x0128, 1);
1553 cit_read_reg(gspca_dev, 0x0100, 0);
1554 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */
1555 cit_read_reg(gspca_dev, 0x0100, 0);
1556 cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */
1557 cit_read_reg(gspca_dev, 0x0100, 0);
1558 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */
1559 cit_write_reg(gspca_dev, 0x01, 0x0108);
1561 cit_write_reg(gspca_dev, 0x03, 0x0112);
1562 cit_read_reg(gspca_dev, 0x0115, 0);
1563 cit_write_reg(gspca_dev, 0x06, 0x0115);
1564 cit_read_reg(gspca_dev, 0x0116, 0);
1565 cit_write_reg(gspca_dev, 0x44, 0x0116);
1566 cit_read_reg(gspca_dev, 0x0116, 0);
1567 cit_write_reg(gspca_dev, 0x40, 0x0116);
1568 cit_read_reg(gspca_dev, 0x0115, 0);
1569 cit_write_reg(gspca_dev, 0x0e, 0x0115);
1570 cit_write_reg(gspca_dev, 0x19, 0x012c);
1572 cit_Packet_Format1(gspca_dev, 0x00, 0x1e);
1573 cit_Packet_Format1(gspca_dev, 0x39, 0x0d);
1574 cit_Packet_Format1(gspca_dev, 0x39, 0x09);
1575 cit_Packet_Format1(gspca_dev, 0x3b, 0x00);
1576 cit_Packet_Format1(gspca_dev, 0x28, 0x22);
1577 cit_Packet_Format1(gspca_dev, 0x27, 0x00);
1578 cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
1579 cit_Packet_Format1(gspca_dev, 0x39, 0x08);
1581 for (i = 0; i < cit_model1_ntries; i++)
1582 cit_Packet_Format1(gspca_dev, 0x2c, 0x00);
1584 for (i = 0; i < cit_model1_ntries; i++)
1585 cit_Packet_Format1(gspca_dev, 0x30, 0x14);
1587 cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1588 cit_PacketFormat2(gspca_dev, 0x01, 0xe1);
1589 cit_PacketFormat2(gspca_dev, 0x02, 0xcd);
1590 cit_PacketFormat2(gspca_dev, 0x03, 0xcd);
1591 cit_PacketFormat2(gspca_dev, 0x04, 0xfa);
1592 cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1593 cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1595 cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1596 cit_PacketFormat2(gspca_dev, 0x0a, 0x37);
1597 cit_PacketFormat2(gspca_dev, 0x0b, 0xb8);
1598 cit_PacketFormat2(gspca_dev, 0x0c, 0xf3);
1599 cit_PacketFormat2(gspca_dev, 0x0d, 0xe3);
1600 cit_PacketFormat2(gspca_dev, 0x0e, 0x0d);
1601 cit_PacketFormat2(gspca_dev, 0x0f, 0xf2);
1602 cit_PacketFormat2(gspca_dev, 0x10, 0xd5);
1603 cit_PacketFormat2(gspca_dev, 0x11, 0xba);
1604 cit_PacketFormat2(gspca_dev, 0x12, 0x53);
1605 cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1606 cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1608 cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1609 cit_PacketFormat2(gspca_dev, 0x16, 0x00);
1610 cit_PacketFormat2(gspca_dev, 0x17, 0x28);
1611 cit_PacketFormat2(gspca_dev, 0x18, 0x7d);
1612 cit_PacketFormat2(gspca_dev, 0x19, 0xbe);
1613 cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1614 cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1616 for (i = 0; i < cit_model1_ntries; i++)
1617 cit_Packet_Format1(gspca_dev, 0x00, 0x18);
1618 for (i = 0; i < cit_model1_ntries; i++)
1619 cit_Packet_Format1(gspca_dev, 0x13, 0x18);
1620 for (i = 0; i < cit_model1_ntries; i++)
1621 cit_Packet_Format1(gspca_dev, 0x14, 0x06);
1623 /* TESTME These are handled through controls
1624 KEEP until someone can test leaving this out is ok */
1626 /* This is default brightness */
1627 for (i = 0; i < cit_model1_ntries; i++)
1628 cit_Packet_Format1(gspca_dev, 0x31, 0x37);
1629 for (i = 0; i < cit_model1_ntries; i++)
1630 cit_Packet_Format1(gspca_dev, 0x32, 0x46);
1631 for (i = 0; i < cit_model1_ntries; i++)
1632 cit_Packet_Format1(gspca_dev, 0x33, 0x55);
1635 cit_Packet_Format1(gspca_dev, 0x2e, 0x04);
1636 for (i = 0; i < cit_model1_ntries; i++)
1637 cit_Packet_Format1(gspca_dev, 0x2d, 0x04);
1638 for (i = 0; i < cit_model1_ntries; i++)
1639 cit_Packet_Format1(gspca_dev, 0x29, 0x80);
1640 cit_Packet_Format1(gspca_dev, 0x2c, 0x01);
1641 cit_Packet_Format1(gspca_dev, 0x30, 0x17);
1642 cit_Packet_Format1(gspca_dev, 0x39, 0x08);
1643 for (i = 0; i < cit_model1_ntries; i++)
1644 cit_Packet_Format1(gspca_dev, 0x34, 0x00);
1646 cit_write_reg(gspca_dev, 0x00, 0x0101);
1647 cit_write_reg(gspca_dev, 0x00, 0x010a);
1649 switch (gspca_dev->pixfmt.width) {
1650 case 128: /* 128x96 */
1651 cit_write_reg(gspca_dev, 0x80, 0x0103);
1652 cit_write_reg(gspca_dev, 0x60, 0x0105);
1653 cit_write_reg(gspca_dev, 0x0c, 0x010b);
1654 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1655 cit_write_reg(gspca_dev, 0x0b, 0x011d);
1656 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1657 cit_write_reg(gspca_dev, 0x00, 0x0129);
1659 case 176: /* 176x144 */
1660 cit_write_reg(gspca_dev, 0xb0, 0x0103);
1661 cit_write_reg(gspca_dev, 0x8f, 0x0105);
1662 cit_write_reg(gspca_dev, 0x06, 0x010b);
1663 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1664 cit_write_reg(gspca_dev, 0x0d, 0x011d);
1665 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1666 cit_write_reg(gspca_dev, 0x03, 0x0129);
1668 case 352: /* 352x288 */
1669 cit_write_reg(gspca_dev, 0xb0, 0x0103);
1670 cit_write_reg(gspca_dev, 0x90, 0x0105);
1671 cit_write_reg(gspca_dev, 0x02, 0x010b);
1672 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1673 cit_write_reg(gspca_dev, 0x05, 0x011d);
1674 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1675 cit_write_reg(gspca_dev, 0x00, 0x0129);
1679 cit_write_reg(gspca_dev, 0xff, 0x012b);
1681 /* TESTME These are handled through controls
1682 KEEP until someone can test leaving this out is ok */
1684 /* This is another brightness - don't know why */
1685 for (i = 0; i < cit_model1_ntries; i++)
1686 cit_Packet_Format1(gspca_dev, 0x31, 0xc3);
1687 for (i = 0; i < cit_model1_ntries; i++)
1688 cit_Packet_Format1(gspca_dev, 0x32, 0xd2);
1689 for (i = 0; i < cit_model1_ntries; i++)
1690 cit_Packet_Format1(gspca_dev, 0x33, 0xe1);
1692 /* Default contrast */
1693 for (i = 0; i < cit_model1_ntries; i++)
1694 cit_Packet_Format1(gspca_dev, 0x14, 0x0a);
1696 /* Default sharpness */
1697 for (i = 0; i < cit_model1_ntries2; i++)
1698 cit_PacketFormat2(gspca_dev, 0x13, 0x1a);
1700 /* Default lighting conditions */
1701 cit_Packet_Format1(gspca_dev, 0x0027,
1702 v4l2_ctrl_g_ctrl(sd->lighting));
1706 switch (gspca_dev->pixfmt.width) {
1707 case 128: /* 128x96 */
1708 cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
1709 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1710 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1711 cit_write_reg(gspca_dev, 0x36, 0x0102);
1712 cit_write_reg(gspca_dev, 0x1a, 0x0104);
1713 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1714 cit_write_reg(gspca_dev, 0x2b, 0x011c);
1715 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1717 case 176: /* 176x144 */
1718 cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
1719 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1720 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1721 cit_write_reg(gspca_dev, 0x04, 0x0102);
1722 cit_write_reg(gspca_dev, 0x02, 0x0104);
1723 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1724 cit_write_reg(gspca_dev, 0x2b, 0x011c);
1725 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1727 case 352: /* 352x288 */
1728 cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
1729 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1730 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1731 cit_write_reg(gspca_dev, 0x08, 0x0102);
1732 cit_write_reg(gspca_dev, 0x01, 0x0104);
1733 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1734 cit_write_reg(gspca_dev, 0x2f, 0x011c);
1735 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1739 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */
1740 cit_write_reg(gspca_dev, clock_div, 0x0111);
1745 static int cit_start_model2(struct gspca_dev *gspca_dev)
1747 struct sd *sd = (struct sd *) gspca_dev;
1750 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* LED on */
1751 cit_read_reg(gspca_dev, 0x0116, 0);
1752 cit_write_reg(gspca_dev, 0x0060, 0x0116);
1753 cit_write_reg(gspca_dev, 0x0002, 0x0112);
1754 cit_write_reg(gspca_dev, 0x00bc, 0x012c);
1755 cit_write_reg(gspca_dev, 0x0008, 0x012b);
1756 cit_write_reg(gspca_dev, 0x0000, 0x0108);
1757 cit_write_reg(gspca_dev, 0x0001, 0x0133);
1758 cit_write_reg(gspca_dev, 0x0001, 0x0102);
1759 switch (gspca_dev->pixfmt.width) {
1760 case 176: /* 176x144 */
1761 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */
1762 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */
1763 cit_write_reg(gspca_dev, 0x0024, 0x0105); /* 176x144, 352x288 */
1764 cit_write_reg(gspca_dev, 0x00b9, 0x010a); /* Unique to this mode */
1765 cit_write_reg(gspca_dev, 0x0038, 0x0119); /* Unique to this mode */
1766 /* TESTME HDG: this does not seem right
1767 (it is 2 for all other resolutions) */
1770 case 320: /* 320x240 */
1771 cit_write_reg(gspca_dev, 0x0028, 0x0103); /* Unique to this mode */
1772 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */
1773 cit_write_reg(gspca_dev, 0x001e, 0x0105); /* 320x240, 352x240 */
1774 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */
1775 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */
1779 case VIDEOSIZE_352x240:
1780 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */
1781 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */
1782 cit_write_reg(gspca_dev, 0x001e, 0x0105); /* 320x240, 352x240 */
1783 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */
1784 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */
1788 case 352: /* 352x288 */
1789 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */
1790 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */
1791 cit_write_reg(gspca_dev, 0x0024, 0x0105); /* 176x144, 352x288 */
1792 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */
1793 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */
1798 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* LED on */
1800 switch (gspca_dev->pixfmt.width) {
1801 case 176: /* 176x144 */
1802 cit_write_reg(gspca_dev, 0x0050, 0x0111);
1803 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
1805 case 320: /* 320x240 */
1806 case 352: /* 352x288 */
1807 cit_write_reg(gspca_dev, 0x0040, 0x0111);
1808 cit_write_reg(gspca_dev, 0x00c0, 0x0111);
1811 cit_write_reg(gspca_dev, 0x009b, 0x010f);
1812 cit_write_reg(gspca_dev, 0x00bb, 0x010f);
1815 * Hardware settings, may affect CMOS sensor; not user controls!
1816 * -------------------------------------------------------------
1818 * 0x0006: hardware effect
1820 * 0x000a: stops video stream, probably important h/w setting
1821 * 0x000c: changes color in hardware manner (not user setting)
1822 * 0x0012: changes number of colors (does not affect speed)
1824 * 0x002c: hardware setting (related to scan lines)
1825 * 0x002e: stops video stream, probably important h/w setting
1827 cit_model2_Packet1(gspca_dev, 0x000a, 0x005c);
1828 cit_model2_Packet1(gspca_dev, 0x0004, 0x0000);
1829 cit_model2_Packet1(gspca_dev, 0x0006, 0x00fb);
1830 cit_model2_Packet1(gspca_dev, 0x0008, 0x0000);
1831 cit_model2_Packet1(gspca_dev, 0x000c, 0x0009);
1832 cit_model2_Packet1(gspca_dev, 0x0012, 0x000a);
1833 cit_model2_Packet1(gspca_dev, 0x002a, 0x0000);
1834 cit_model2_Packet1(gspca_dev, 0x002c, 0x0000);
1835 cit_model2_Packet1(gspca_dev, 0x002e, 0x0008);
1838 * Function 0x0030 pops up all over the place. Apparently
1839 * it is a hardware control register, with every bit assigned to
1842 cit_model2_Packet1(gspca_dev, 0x0030, 0x0000);
1845 * Magic control of CMOS sensor. Only lower values like
1846 * 0-3 work, and picture shifts left or right. Don't change.
1848 switch (gspca_dev->pixfmt.width) {
1849 case 176: /* 176x144 */
1850 cit_model2_Packet1(gspca_dev, 0x0014, 0x0002);
1851 cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
1852 cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
1855 case 320: /* 320x240 */
1856 cit_model2_Packet1(gspca_dev, 0x0014, 0x0009);
1857 cit_model2_Packet1(gspca_dev, 0x0016, 0x0005); /* Horizontal shift */
1858 cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Another hardware setting */
1862 case VIDEOSIZE_352x240:
1863 /* This mode doesn't work as Windows programs it; changed to work */
1864 cit_model2_Packet1(gspca_dev, 0x0014, 0x0009); /* Windows sets this to 8 */
1865 cit_model2_Packet1(gspca_dev, 0x0016, 0x0003); /* Horizontal shift */
1866 cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Windows sets this to 0x0045 */
1870 case 352: /* 352x288 */
1871 cit_model2_Packet1(gspca_dev, 0x0014, 0x0003);
1872 cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
1873 cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
1878 /* TESTME These are handled through controls
1879 KEEP until someone can test leaving this out is ok */
1881 cit_model2_Packet1(gspca_dev, 0x001a, 0x005a);
1884 * We have our own frame rate setting varying from 0 (slowest) to 6
1885 * (fastest). The camera model 2 allows frame rate in range [0..0x1F]
1886 # where 0 is also the slowest setting. However for all practical
1887 # reasons high settings make no sense because USB is not fast enough
1888 # to support high FPS. Be aware that the picture datastream will be
1889 # severely disrupted if you ask for frame rate faster than allowed
1890 # for the video size - see below:
1892 * Allowable ranges (obtained experimentally on OHCI, K6-3, 450 MHz):
1893 * -----------------------------------------------------------------
1897 * 352x288: [16..31] I have to raise lower threshold for stability...
1899 * As usual, slower FPS provides better sensitivity.
1901 cit_model2_Packet1(gspca_dev, 0x001c, clock_div);
1904 * This setting does not visibly affect pictures; left it here
1905 * because it was present in Windows USB data stream. This function
1906 * does not allow arbitrary values and apparently is a bit mask, to
1907 * be activated only at appropriate time. Don't change it randomly!
1909 switch (gspca_dev->pixfmt.width) {
1910 case 176: /* 176x144 */
1911 cit_model2_Packet1(gspca_dev, 0x0026, 0x00c2);
1913 case 320: /* 320x240 */
1914 cit_model2_Packet1(gspca_dev, 0x0026, 0x0044);
1917 case VIDEOSIZE_352x240:
1918 cit_model2_Packet1(gspca_dev, 0x0026, 0x0046);
1921 case 352: /* 352x288 */
1922 cit_model2_Packet1(gspca_dev, 0x0026, 0x0048);
1926 cit_model2_Packet1(gspca_dev, 0x0028, v4l2_ctrl_g_ctrl(sd->lighting));
1927 /* model2 cannot change the backlight compensation while streaming */
1928 v4l2_ctrl_grab(sd->lighting, true);
1930 /* color balance rg2 */
1931 cit_model2_Packet1(gspca_dev, 0x001e, 0x002f);
1933 cit_model2_Packet1(gspca_dev, 0x0020, 0x0034);
1934 /* color balance yb */
1935 cit_model2_Packet1(gspca_dev, 0x0022, 0x00a0);
1937 /* Hardware control command */
1938 cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
1943 static int cit_start_model3(struct gspca_dev *gspca_dev)
1945 const unsigned short compression = 0; /* 0=none, 7=best frame rate */
1946 int i, clock_div = 0;
1948 /* HDG not in ibmcam driver, added to see if it helps with
1949 auto-detecting between model3 and ibm netcamera pro */
1950 cit_read_reg(gspca_dev, 0x128, 1);
1952 cit_write_reg(gspca_dev, 0x0000, 0x0100);
1953 cit_read_reg(gspca_dev, 0x0116, 0);
1954 cit_write_reg(gspca_dev, 0x0060, 0x0116);
1955 cit_write_reg(gspca_dev, 0x0002, 0x0112);
1956 cit_write_reg(gspca_dev, 0x0000, 0x0123);
1957 cit_write_reg(gspca_dev, 0x0001, 0x0117);
1958 cit_write_reg(gspca_dev, 0x0040, 0x0108);
1959 cit_write_reg(gspca_dev, 0x0019, 0x012c);
1960 cit_write_reg(gspca_dev, 0x0060, 0x0116);
1961 cit_write_reg(gspca_dev, 0x0002, 0x0115);
1962 cit_write_reg(gspca_dev, 0x0003, 0x0115);
1963 cit_read_reg(gspca_dev, 0x0115, 0);
1964 cit_write_reg(gspca_dev, 0x000b, 0x0115);
1966 /* TESTME HDG not in ibmcam driver, added to see if it helps with
1967 auto-detecting between model3 and ibm netcamera pro */
1969 cit_write_reg(gspca_dev, 0x0078, 0x012d);
1970 cit_write_reg(gspca_dev, 0x0001, 0x012f);
1971 cit_write_reg(gspca_dev, 0xd141, 0x0124);
1972 cit_write_reg(gspca_dev, 0x0079, 0x012d);
1973 cit_write_reg(gspca_dev, 0x00ff, 0x0130);
1974 cit_write_reg(gspca_dev, 0xcd41, 0x0124);
1975 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
1976 cit_read_reg(gspca_dev, 0x0126, 1);
1979 cit_model3_Packet1(gspca_dev, 0x000a, 0x0040);
1980 cit_model3_Packet1(gspca_dev, 0x000b, 0x00f6);
1981 cit_model3_Packet1(gspca_dev, 0x000c, 0x0002);
1982 cit_model3_Packet1(gspca_dev, 0x000d, 0x0020);
1983 cit_model3_Packet1(gspca_dev, 0x000e, 0x0033);
1984 cit_model3_Packet1(gspca_dev, 0x000f, 0x0007);
1985 cit_model3_Packet1(gspca_dev, 0x0010, 0x0000);
1986 cit_model3_Packet1(gspca_dev, 0x0011, 0x0070);
1987 cit_model3_Packet1(gspca_dev, 0x0012, 0x0030);
1988 cit_model3_Packet1(gspca_dev, 0x0013, 0x0000);
1989 cit_model3_Packet1(gspca_dev, 0x0014, 0x0001);
1990 cit_model3_Packet1(gspca_dev, 0x0015, 0x0001);
1991 cit_model3_Packet1(gspca_dev, 0x0016, 0x0001);
1992 cit_model3_Packet1(gspca_dev, 0x0017, 0x0001);
1993 cit_model3_Packet1(gspca_dev, 0x0018, 0x0000);
1994 cit_model3_Packet1(gspca_dev, 0x001e, 0x00c3);
1995 cit_model3_Packet1(gspca_dev, 0x0020, 0x0000);
1996 cit_model3_Packet1(gspca_dev, 0x0028, 0x0010);
1997 cit_model3_Packet1(gspca_dev, 0x0029, 0x0054);
1998 cit_model3_Packet1(gspca_dev, 0x002a, 0x0013);
1999 cit_model3_Packet1(gspca_dev, 0x002b, 0x0007);
2000 cit_model3_Packet1(gspca_dev, 0x002d, 0x0028);
2001 cit_model3_Packet1(gspca_dev, 0x002e, 0x0000);
2002 cit_model3_Packet1(gspca_dev, 0x0031, 0x0000);
2003 cit_model3_Packet1(gspca_dev, 0x0032, 0x0000);
2004 cit_model3_Packet1(gspca_dev, 0x0033, 0x0000);
2005 cit_model3_Packet1(gspca_dev, 0x0034, 0x0000);
2006 cit_model3_Packet1(gspca_dev, 0x0035, 0x0038);
2007 cit_model3_Packet1(gspca_dev, 0x003a, 0x0001);
2008 cit_model3_Packet1(gspca_dev, 0x003c, 0x001e);
2009 cit_model3_Packet1(gspca_dev, 0x003f, 0x000a);
2010 cit_model3_Packet1(gspca_dev, 0x0041, 0x0000);
2011 cit_model3_Packet1(gspca_dev, 0x0046, 0x003f);
2012 cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
2013 cit_model3_Packet1(gspca_dev, 0x0050, 0x0005);
2014 cit_model3_Packet1(gspca_dev, 0x0052, 0x001a);
2015 cit_model3_Packet1(gspca_dev, 0x0053, 0x0003);
2016 cit_model3_Packet1(gspca_dev, 0x005a, 0x006b);
2017 cit_model3_Packet1(gspca_dev, 0x005d, 0x001e);
2018 cit_model3_Packet1(gspca_dev, 0x005e, 0x0030);
2019 cit_model3_Packet1(gspca_dev, 0x005f, 0x0041);
2020 cit_model3_Packet1(gspca_dev, 0x0064, 0x0008);
2021 cit_model3_Packet1(gspca_dev, 0x0065, 0x0015);
2022 cit_model3_Packet1(gspca_dev, 0x0068, 0x000f);
2023 cit_model3_Packet1(gspca_dev, 0x0079, 0x0000);
2024 cit_model3_Packet1(gspca_dev, 0x007a, 0x0000);
2025 cit_model3_Packet1(gspca_dev, 0x007c, 0x003f);
2026 cit_model3_Packet1(gspca_dev, 0x0082, 0x000f);
2027 cit_model3_Packet1(gspca_dev, 0x0085, 0x0000);
2028 cit_model3_Packet1(gspca_dev, 0x0099, 0x0000);
2029 cit_model3_Packet1(gspca_dev, 0x009b, 0x0023);
2030 cit_model3_Packet1(gspca_dev, 0x009c, 0x0022);
2031 cit_model3_Packet1(gspca_dev, 0x009d, 0x0096);
2032 cit_model3_Packet1(gspca_dev, 0x009e, 0x0096);
2033 cit_model3_Packet1(gspca_dev, 0x009f, 0x000a);
2035 switch (gspca_dev->pixfmt.width) {
2037 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2038 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2039 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2040 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2041 cit_write_reg(gspca_dev, 0x0024, 0x010b); /* Differs everywhere */
2042 cit_write_reg(gspca_dev, 0x00a9, 0x0119);
2043 cit_write_reg(gspca_dev, 0x0016, 0x011b);
2044 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
2045 cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
2046 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2047 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2048 cit_write_reg(gspca_dev, 0x0018, 0x0102);
2049 cit_write_reg(gspca_dev, 0x0004, 0x0104);
2050 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2051 cit_write_reg(gspca_dev, 0x0028, 0x011c);
2052 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2053 cit_write_reg(gspca_dev, 0x0000, 0x0118);
2054 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2055 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2056 cit_write_reg(gspca_dev, compression, 0x0109);
2060 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2061 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2062 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2063 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2064 cit_write_reg(gspca_dev, 0x0028, 0x010b); /* Differs everywhere */
2065 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same */
2066 cit_write_reg(gspca_dev, 0x0000, 0x011e);
2067 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2068 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2069 /* 4 commands from 160x120 skipped */
2070 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2071 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2072 cit_write_reg(gspca_dev, compression, 0x0109);
2073 cit_write_reg(gspca_dev, 0x00d9, 0x0119);
2074 cit_write_reg(gspca_dev, 0x0006, 0x011b);
2075 cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
2076 cit_write_reg(gspca_dev, 0x0010, 0x0104);
2077 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2078 cit_write_reg(gspca_dev, 0x003f, 0x011c);
2079 cit_write_reg(gspca_dev, 0x001c, 0x0118);
2080 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2084 cit_write_reg(gspca_dev, 0x00f0, 0x0105);
2085 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2086 cit_write_reg(gspca_dev, 0x0038, 0x010b); /* Differs everywhere */
2087 cit_write_reg(gspca_dev, 0x00d9, 0x0119); /* Same on 320x240, 640x480 */
2088 cit_write_reg(gspca_dev, 0x0006, 0x011b); /* Same on 320x240, 640x480 */
2089 cit_write_reg(gspca_dev, 0x0004, 0x011d); /* NC */
2090 cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
2091 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2092 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2093 cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
2094 cit_write_reg(gspca_dev, 0x0016, 0x0104); /* NC */
2095 cit_write_reg(gspca_dev, 0x0004, 0x011a); /* Same on 320x240, 640x480 */
2096 cit_write_reg(gspca_dev, 0x003f, 0x011c); /* Same on 320x240, 640x480 */
2097 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2098 cit_write_reg(gspca_dev, 0x001c, 0x0118); /* Same on 320x240, 640x480 */
2099 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2100 cit_write_reg(gspca_dev, compression, 0x0109);
2101 cit_write_reg(gspca_dev, 0x0040, 0x0101);
2102 cit_write_reg(gspca_dev, 0x0040, 0x0103);
2103 cit_write_reg(gspca_dev, 0x0000, 0x0132); /* Same on 320x240, 640x480 */
2108 cit_model3_Packet1(gspca_dev, 0x007e, 0x000e); /* Hue */
2109 cit_model3_Packet1(gspca_dev, 0x0036, 0x0011); /* Brightness */
2110 cit_model3_Packet1(gspca_dev, 0x0060, 0x0002); /* Sharpness */
2111 cit_model3_Packet1(gspca_dev, 0x0061, 0x0004); /* Sharpness */
2112 cit_model3_Packet1(gspca_dev, 0x0062, 0x0005); /* Sharpness */
2113 cit_model3_Packet1(gspca_dev, 0x0063, 0x0014); /* Sharpness */
2114 cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0); /* Red sharpness */
2115 cit_model3_Packet1(gspca_dev, 0x0097, 0x0096); /* Blue sharpness */
2116 cit_model3_Packet1(gspca_dev, 0x0067, 0x0001); /* Contrast */
2117 cit_model3_Packet1(gspca_dev, 0x005b, 0x000c); /* Contrast */
2118 cit_model3_Packet1(gspca_dev, 0x005c, 0x0016); /* Contrast */
2119 cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
2120 cit_model3_Packet1(gspca_dev, 0x002c, 0x0003); /* Was 1, broke 640x480 */
2121 cit_model3_Packet1(gspca_dev, 0x002f, 0x002a);
2122 cit_model3_Packet1(gspca_dev, 0x0030, 0x0029);
2123 cit_model3_Packet1(gspca_dev, 0x0037, 0x0002);
2124 cit_model3_Packet1(gspca_dev, 0x0038, 0x0059);
2125 cit_model3_Packet1(gspca_dev, 0x003d, 0x002e);
2126 cit_model3_Packet1(gspca_dev, 0x003e, 0x0028);
2127 cit_model3_Packet1(gspca_dev, 0x0078, 0x0005);
2128 cit_model3_Packet1(gspca_dev, 0x007b, 0x0011);
2129 cit_model3_Packet1(gspca_dev, 0x007d, 0x004b);
2130 cit_model3_Packet1(gspca_dev, 0x007f, 0x0022);
2131 cit_model3_Packet1(gspca_dev, 0x0080, 0x000c);
2132 cit_model3_Packet1(gspca_dev, 0x0081, 0x000b);
2133 cit_model3_Packet1(gspca_dev, 0x0083, 0x00fd);
2134 cit_model3_Packet1(gspca_dev, 0x0086, 0x000b);
2135 cit_model3_Packet1(gspca_dev, 0x0087, 0x000b);
2136 cit_model3_Packet1(gspca_dev, 0x007e, 0x000e);
2137 cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0); /* Red sharpness */
2138 cit_model3_Packet1(gspca_dev, 0x0097, 0x0096); /* Blue sharpness */
2139 cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
2141 /* FIXME we should probably use cit_get_clock_div() here (in
2142 combination with isoc negotiation using the programmable isoc size)
2143 like with the IBM netcam pro). */
2144 cit_write_reg(gspca_dev, clock_div, 0x0111); /* Clock Divider */
2146 switch (gspca_dev->pixfmt.width) {
2148 cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
2149 cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
2150 cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
2151 cit_model3_Packet1(gspca_dev, 0x0040, 0x000a);
2152 cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
2155 cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
2156 cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
2157 cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
2158 cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
2159 cit_model3_Packet1(gspca_dev, 0x0051, 0x000b);
2162 cit_model3_Packet1(gspca_dev, 0x001f, 0x0002); /* !Same */
2163 cit_model3_Packet1(gspca_dev, 0x0039, 0x003e); /* !Same */
2164 cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
2165 cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
2169 /* if (sd->input_index) { */
2171 for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
2172 if (rca_initdata[i][0])
2173 cit_read_reg(gspca_dev, rca_initdata[i][2], 0);
2175 cit_write_reg(gspca_dev, rca_initdata[i][1],
2176 rca_initdata[i][2]);
2183 static int cit_start_model4(struct gspca_dev *gspca_dev)
2185 struct sd *sd = (struct sd *) gspca_dev;
2187 cit_write_reg(gspca_dev, 0x0000, 0x0100);
2188 cit_write_reg(gspca_dev, 0x00c0, 0x0111);
2189 cit_write_reg(gspca_dev, 0x00bc, 0x012c);
2190 cit_write_reg(gspca_dev, 0x0080, 0x012b);
2191 cit_write_reg(gspca_dev, 0x0000, 0x0108);
2192 cit_write_reg(gspca_dev, 0x0001, 0x0133);
2193 cit_write_reg(gspca_dev, 0x009b, 0x010f);
2194 cit_write_reg(gspca_dev, 0x00bb, 0x010f);
2195 cit_model4_Packet1(gspca_dev, 0x0038, 0x0000);
2196 cit_model4_Packet1(gspca_dev, 0x000a, 0x005c);
2198 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2199 cit_write_reg(gspca_dev, 0x0004, 0x012f);
2200 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2201 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2202 cit_write_reg(gspca_dev, 0x00fb, 0x012e);
2203 cit_write_reg(gspca_dev, 0x0000, 0x0130);
2204 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2205 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2206 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2207 cit_write_reg(gspca_dev, 0x000c, 0x0127);
2208 cit_write_reg(gspca_dev, 0x0009, 0x012e);
2209 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2211 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2212 cit_write_reg(gspca_dev, 0x0012, 0x012f);
2213 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2214 cit_write_reg(gspca_dev, 0x0008, 0x0127);
2215 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2216 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2217 cit_write_reg(gspca_dev, 0x002a, 0x012d);
2218 cit_write_reg(gspca_dev, 0x0000, 0x012f);
2219 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2220 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2221 cit_model4_Packet1(gspca_dev, 0x0034, 0x0000);
2223 switch (gspca_dev->pixfmt.width) {
2224 case 128: /* 128x96 */
2225 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2226 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2227 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2228 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2229 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2230 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2231 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2232 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2233 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2234 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2235 cit_write_reg(gspca_dev, 0x000a, 0x0127);
2236 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2237 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2238 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2239 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2240 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2241 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2242 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2243 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2244 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2245 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2246 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2247 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2248 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2249 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2250 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2251 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2252 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2253 cit_write_reg(gspca_dev, 0x00eb, 0x012e);
2254 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2255 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2256 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2257 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2258 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2259 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2260 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2261 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2262 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2263 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2264 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2265 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2266 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2267 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2268 cit_write_reg(gspca_dev, 0x0017, 0x0127);
2269 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2270 cit_write_reg(gspca_dev, 0x0031, 0x0130);
2271 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2272 cit_write_reg(gspca_dev, 0x0017, 0x012d);
2273 cit_write_reg(gspca_dev, 0x0078, 0x012f);
2274 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2275 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2276 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2279 case 160: /* 160x120 */
2280 cit_write_reg(gspca_dev, 0x0038, 0x0119);
2281 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2282 cit_write_reg(gspca_dev, 0x00b9, 0x010a);
2283 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2284 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2285 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2286 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2287 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2288 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2289 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2290 cit_write_reg(gspca_dev, 0x000b, 0x0127);
2291 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2292 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2293 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2294 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2295 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2296 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2297 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2298 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2299 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2300 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2301 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2302 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2303 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2304 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2305 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2306 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2307 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2308 cit_write_reg(gspca_dev, 0x00c7, 0x012e);
2309 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2310 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2311 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2312 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2313 cit_write_reg(gspca_dev, 0x0025, 0x0127);
2314 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2315 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2316 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2317 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2318 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2319 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2320 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2321 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2322 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2323 cit_write_reg(gspca_dev, 0x0048, 0x0127);
2324 cit_write_reg(gspca_dev, 0x0035, 0x012e);
2325 cit_write_reg(gspca_dev, 0x00d0, 0x0130);
2326 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2327 cit_write_reg(gspca_dev, 0x0048, 0x012d);
2328 cit_write_reg(gspca_dev, 0x0090, 0x012f);
2329 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2330 cit_write_reg(gspca_dev, 0x0001, 0x0127);
2331 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2334 case 176: /* 176x144 */
2335 cit_write_reg(gspca_dev, 0x0038, 0x0119);
2336 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2337 cit_write_reg(gspca_dev, 0x00b9, 0x010a);
2338 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2339 cit_write_reg(gspca_dev, 0x002c, 0x0103);
2340 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2341 cit_write_reg(gspca_dev, 0x0024, 0x0105);
2342 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2343 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2344 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2345 cit_write_reg(gspca_dev, 0x0007, 0x0127);
2346 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2347 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2348 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2349 cit_write_reg(gspca_dev, 0x0001, 0x012f);
2350 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2351 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2352 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2353 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2354 cit_write_reg(gspca_dev, 0x005e, 0x012d);
2355 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2356 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2357 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2358 cit_write_reg(gspca_dev, 0x0049, 0x0130);
2359 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2360 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2361 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2362 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2363 cit_write_reg(gspca_dev, 0x00c7, 0x012e);
2364 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2365 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2366 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2367 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2368 cit_write_reg(gspca_dev, 0x0028, 0x0127);
2369 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2370 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2371 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2372 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2373 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2374 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2375 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2376 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2377 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2378 cit_write_reg(gspca_dev, 0x0010, 0x0127);
2379 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2380 cit_write_reg(gspca_dev, 0x002a, 0x0130);
2381 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2382 cit_write_reg(gspca_dev, 0x0010, 0x012d);
2383 cit_write_reg(gspca_dev, 0x006d, 0x012f);
2384 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2385 cit_write_reg(gspca_dev, 0x0001, 0x0127);
2386 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2387 /* TESTME HDG: this does not seem right
2388 (it is 2 for all other resolutions) */
2391 case 320: /* 320x240 */
2392 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2393 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2394 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2395 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2396 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2397 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2398 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2399 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2400 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2401 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2402 cit_write_reg(gspca_dev, 0x000a, 0x0127);
2403 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2404 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2405 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2406 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2407 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2408 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2409 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2410 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2411 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2412 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2413 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2414 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2415 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2416 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2417 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2418 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2419 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2420 cit_write_reg(gspca_dev, 0x00eb, 0x012e);
2421 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2422 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2423 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2424 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2425 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2426 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2427 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2428 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2429 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2430 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2431 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2432 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2433 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2434 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2435 cit_write_reg(gspca_dev, 0x0017, 0x0127);
2436 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2437 cit_write_reg(gspca_dev, 0x0031, 0x0130);
2438 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2439 cit_write_reg(gspca_dev, 0x0017, 0x012d);
2440 cit_write_reg(gspca_dev, 0x0078, 0x012f);
2441 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2442 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2443 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2446 case 352: /* 352x288 */
2447 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2448 cit_write_reg(gspca_dev, 0x00c0, 0x0111);
2449 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2450 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2451 cit_write_reg(gspca_dev, 0x002c, 0x0103);
2452 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2453 cit_write_reg(gspca_dev, 0x0024, 0x0105);
2454 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2455 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2456 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2457 cit_write_reg(gspca_dev, 0x0006, 0x0127);
2458 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2459 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2460 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2461 cit_write_reg(gspca_dev, 0x0002, 0x012f);
2462 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2463 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2464 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2465 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2466 cit_write_reg(gspca_dev, 0x005e, 0x012d);
2467 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2468 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2469 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2470 cit_write_reg(gspca_dev, 0x0049, 0x0130);
2471 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2472 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2473 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2474 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2475 cit_write_reg(gspca_dev, 0x00cf, 0x012e);
2476 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2477 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2478 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2479 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2480 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2481 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2482 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2483 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2484 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2485 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2486 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2487 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2488 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2489 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2490 cit_write_reg(gspca_dev, 0x0010, 0x0127);
2491 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2492 cit_write_reg(gspca_dev, 0x0025, 0x0130);
2493 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2494 cit_write_reg(gspca_dev, 0x0010, 0x012d);
2495 cit_write_reg(gspca_dev, 0x0048, 0x012f);
2496 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2497 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2498 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2503 cit_model4_Packet1(gspca_dev, 0x0038, 0x0004);
2508 static int cit_start_ibm_netcam_pro(struct gspca_dev *gspca_dev)
2510 const unsigned short compression = 0; /* 0=none, 7=best frame rate */
2513 clock_div = cit_get_clock_div(gspca_dev);
2517 cit_write_reg(gspca_dev, 0x0003, 0x0133);
2518 cit_write_reg(gspca_dev, 0x0000, 0x0117);
2519 cit_write_reg(gspca_dev, 0x0008, 0x0123);
2520 cit_write_reg(gspca_dev, 0x0000, 0x0100);
2521 cit_write_reg(gspca_dev, 0x0060, 0x0116);
2522 /* cit_write_reg(gspca_dev, 0x0002, 0x0112); see sd_stop0 */
2523 cit_write_reg(gspca_dev, 0x0000, 0x0133);
2524 cit_write_reg(gspca_dev, 0x0000, 0x0123);
2525 cit_write_reg(gspca_dev, 0x0001, 0x0117);
2526 cit_write_reg(gspca_dev, 0x0040, 0x0108);
2527 cit_write_reg(gspca_dev, 0x0019, 0x012c);
2528 cit_write_reg(gspca_dev, 0x0060, 0x0116);
2529 /* cit_write_reg(gspca_dev, 0x000b, 0x0115); see sd_stop0 */
2531 cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
2533 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2534 cit_write_reg(gspca_dev, 0x003a, 0x0102); /* Hstart */
2535 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2536 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2537 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2538 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
2539 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2540 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2541 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2543 switch (gspca_dev->pixfmt.width) {
2544 case 160: /* 160x120 */
2545 cit_write_reg(gspca_dev, 0x0024, 0x010b);
2546 cit_write_reg(gspca_dev, 0x0089, 0x0119);
2547 cit_write_reg(gspca_dev, 0x000a, 0x011b);
2548 cit_write_reg(gspca_dev, 0x0003, 0x011e);
2549 cit_write_reg(gspca_dev, 0x0007, 0x0104);
2550 cit_write_reg(gspca_dev, 0x0009, 0x011a);
2551 cit_write_reg(gspca_dev, 0x008b, 0x011c);
2552 cit_write_reg(gspca_dev, 0x0008, 0x0118);
2553 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2555 case 320: /* 320x240 */
2556 cit_write_reg(gspca_dev, 0x0028, 0x010b);
2557 cit_write_reg(gspca_dev, 0x00d9, 0x0119);
2558 cit_write_reg(gspca_dev, 0x0006, 0x011b);
2559 cit_write_reg(gspca_dev, 0x0000, 0x011e);
2560 cit_write_reg(gspca_dev, 0x000e, 0x0104);
2561 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2562 cit_write_reg(gspca_dev, 0x003f, 0x011c);
2563 cit_write_reg(gspca_dev, 0x000c, 0x0118);
2564 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2568 cit_model3_Packet1(gspca_dev, 0x0019, 0x0031);
2569 cit_model3_Packet1(gspca_dev, 0x001a, 0x0003);
2570 cit_model3_Packet1(gspca_dev, 0x001b, 0x0038);
2571 cit_model3_Packet1(gspca_dev, 0x001c, 0x0000);
2572 cit_model3_Packet1(gspca_dev, 0x0024, 0x0001);
2573 cit_model3_Packet1(gspca_dev, 0x0027, 0x0001);
2574 cit_model3_Packet1(gspca_dev, 0x002a, 0x0004);
2575 cit_model3_Packet1(gspca_dev, 0x0035, 0x000b);
2576 cit_model3_Packet1(gspca_dev, 0x003f, 0x0001);
2577 cit_model3_Packet1(gspca_dev, 0x0044, 0x0000);
2578 cit_model3_Packet1(gspca_dev, 0x0054, 0x0000);
2579 cit_model3_Packet1(gspca_dev, 0x00c4, 0x0000);
2580 cit_model3_Packet1(gspca_dev, 0x00e7, 0x0001);
2581 cit_model3_Packet1(gspca_dev, 0x00e9, 0x0001);
2582 cit_model3_Packet1(gspca_dev, 0x00ee, 0x0000);
2583 cit_model3_Packet1(gspca_dev, 0x00f3, 0x00c0);
2585 cit_write_reg(gspca_dev, compression, 0x0109);
2586 cit_write_reg(gspca_dev, clock_div, 0x0111);
2588 /* if (sd->input_index) { */
2590 for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
2591 if (rca_initdata[i][0])
2592 cit_read_reg(gspca_dev, rca_initdata[i][2], 0);
2594 cit_write_reg(gspca_dev, rca_initdata[i][1],
2595 rca_initdata[i][2]);
2602 /* -- start the camera -- */
2603 static int sd_start(struct gspca_dev *gspca_dev)
2605 struct sd *sd = (struct sd *) gspca_dev;
2608 packet_size = cit_get_packet_size(gspca_dev);
2609 if (packet_size < 0)
2612 switch (sd->model) {
2614 cit_start_model0(gspca_dev);
2617 cit_start_model1(gspca_dev);
2620 cit_start_model2(gspca_dev);
2623 cit_start_model3(gspca_dev);
2626 cit_start_model4(gspca_dev);
2628 case CIT_IBM_NETCAM_PRO:
2629 cit_start_ibm_netcam_pro(gspca_dev);
2633 /* Program max isoc packet size */
2634 cit_write_reg(gspca_dev, packet_size >> 8, 0x0106);
2635 cit_write_reg(gspca_dev, packet_size & 0xff, 0x0107);
2637 cit_restart_stream(gspca_dev);
2642 static int sd_isoc_init(struct gspca_dev *gspca_dev)
2644 struct usb_interface_cache *intfc;
2645 struct usb_host_interface *alt;
2646 int max_packet_size;
2648 switch (gspca_dev->pixfmt.width) {
2650 max_packet_size = 450;
2653 max_packet_size = 600;
2656 max_packet_size = 1022;
2660 intfc = gspca_dev->dev->actconfig->intf_cache[0];
2662 if (intfc->num_altsetting < 2)
2665 alt = &intfc->altsetting[1];
2667 if (alt->desc.bNumEndpoints < 1)
2670 /* Start isoc bandwidth "negotiation" at max isoc bandwidth */
2671 alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
2676 static int sd_isoc_nego(struct gspca_dev *gspca_dev)
2678 int ret, packet_size, min_packet_size;
2679 struct usb_host_interface *alt;
2681 switch (gspca_dev->pixfmt.width) {
2683 min_packet_size = 200;
2686 min_packet_size = 266;
2689 min_packet_size = 400;
2694 * Existence of altsetting and endpoint was verified in sd_isoc_init()
2696 alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1];
2697 packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
2698 if (packet_size <= min_packet_size)
2702 if (packet_size < min_packet_size)
2703 packet_size = min_packet_size;
2704 alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(packet_size);
2706 ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
2708 pr_err("set alt 1 err %d\n", ret);
2713 static void sd_stopN(struct gspca_dev *gspca_dev)
2715 cit_write_reg(gspca_dev, 0x0000, 0x010c);
2718 static void sd_stop0(struct gspca_dev *gspca_dev)
2720 struct sd *sd = (struct sd *) gspca_dev;
2722 if (!gspca_dev->present)
2725 switch (sd->model) {
2727 /* HDG windows does this, but it causes the cams autogain to
2728 restart from a gain of 0, which does not look good when
2729 changing resolutions. */
2730 /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
2731 cit_write_reg(gspca_dev, 0x00c0, 0x0100); /* LED Off */
2734 cit_send_FF_04_02(gspca_dev);
2735 cit_read_reg(gspca_dev, 0x0100, 0);
2736 cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */
2739 v4l2_ctrl_grab(sd->lighting, false);
2742 cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
2744 cit_write_reg(gspca_dev, 0x0080, 0x0100); /* LED Off */
2745 cit_write_reg(gspca_dev, 0x0020, 0x0111);
2746 cit_write_reg(gspca_dev, 0x00a0, 0x0111);
2748 cit_model2_Packet1(gspca_dev, 0x0030, 0x0002);
2750 cit_write_reg(gspca_dev, 0x0020, 0x0111);
2751 cit_write_reg(gspca_dev, 0x0000, 0x0112);
2754 cit_write_reg(gspca_dev, 0x0006, 0x012c);
2755 cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
2756 cit_read_reg(gspca_dev, 0x0116, 0);
2757 cit_write_reg(gspca_dev, 0x0064, 0x0116);
2758 cit_read_reg(gspca_dev, 0x0115, 0);
2759 cit_write_reg(gspca_dev, 0x0003, 0x0115);
2760 cit_write_reg(gspca_dev, 0x0008, 0x0123);
2761 cit_write_reg(gspca_dev, 0x0000, 0x0117);
2762 cit_write_reg(gspca_dev, 0x0000, 0x0112);
2763 cit_write_reg(gspca_dev, 0x0080, 0x0100);
2765 case CIT_IBM_NETCAM_PRO:
2766 cit_model3_Packet1(gspca_dev, 0x0049, 0x00ff);
2767 cit_write_reg(gspca_dev, 0x0006, 0x012c);
2768 cit_write_reg(gspca_dev, 0x0000, 0x0116);
2769 /* HDG windows does this, but I cannot get the camera
2770 to restart with this without redoing the entire init
2771 sequence which makes switching modes really slow */
2772 /* cit_write_reg(gspca_dev, 0x0006, 0x0115); */
2773 cit_write_reg(gspca_dev, 0x0008, 0x0123);
2774 cit_write_reg(gspca_dev, 0x0000, 0x0117);
2775 cit_write_reg(gspca_dev, 0x0003, 0x0133);
2776 cit_write_reg(gspca_dev, 0x0000, 0x0111);
2777 /* HDG windows does this, but I get a green picture when
2778 restarting the stream after this */
2779 /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
2780 cit_write_reg(gspca_dev, 0x00c0, 0x0100);
2784 #if IS_ENABLED(CONFIG_INPUT)
2785 /* If the last button state is pressed, release it now! */
2786 if (sd->button_state) {
2787 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
2788 input_sync(gspca_dev->input_dev);
2789 sd->button_state = 0;
2794 static u8 *cit_find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
2796 struct sd *sd = (struct sd *) gspca_dev;
2797 u8 byte3 = 0, byte4 = 0;
2800 switch (sd->model) {
2804 case CIT_IBM_NETCAM_PRO:
2805 switch (gspca_dev->pixfmt.width) {
2806 case 160: /* 160x120 */
2810 case 176: /* 176x144 */
2814 case 320: /* 320x240 */
2818 case 352: /* 352x288 */
2828 /* These have a different byte3 */
2829 if (sd->model <= CIT_MODEL1)
2832 for (i = 0; i < len; i++) {
2833 /* For this model the SOF always starts at offset 0
2834 so no need to search the entire frame */
2835 if (sd->model == CIT_MODEL0 && sd->sof_read != i)
2838 switch (sd->sof_read) {
2840 if (data[i] == 0x00)
2844 if (data[i] == 0xff)
2846 else if (data[i] == 0x00)
2852 if (data[i] == byte3)
2854 else if (data[i] == 0x00)
2860 if (data[i] == byte4) {
2862 return data + i + (sd->sof_len - 3);
2864 if (byte3 == 0x00 && data[i] == 0xff)
2866 else if (data[i] == 0x00)
2876 /* TESTME we need to find a longer sof signature to avoid
2878 for (i = 0; i < len; i++) {
2879 switch (sd->sof_read) {
2881 if (data[i] == 0x00)
2886 if (data[i] == 0xff) {
2889 "header found at offset: %d: %02x %02x 00 %3ph\n",
2896 "header found at offset: %d: 00 %3ph\n",
2899 return data + i + (sd->sof_len - 1);
2909 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
2912 struct sd *sd = (struct sd *) gspca_dev;
2915 sof = cit_find_sof(gspca_dev, data, len);
2919 /* finish decoding current frame */
2921 if (n > sd->sof_len)
2925 gspca_frame_add(gspca_dev, LAST_PACKET,
2927 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
2932 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
2935 #if IS_ENABLED(CONFIG_INPUT)
2936 static void cit_check_button(struct gspca_dev *gspca_dev)
2938 int new_button_state;
2939 struct sd *sd = (struct sd *)gspca_dev;
2941 switch (sd->model) {
2943 case CIT_IBM_NETCAM_PRO:
2945 default: /* TEST ME unknown if this works on other models too */
2949 /* Read the button state */
2950 cit_read_reg(gspca_dev, 0x0113, 0);
2951 new_button_state = !gspca_dev->usb_buf[0];
2953 /* Tell the cam we've seen the button press, notice that this
2954 is a nop (iow the cam keeps reporting pressed) until the
2955 button is actually released. */
2956 if (new_button_state)
2957 cit_write_reg(gspca_dev, 0x01, 0x0113);
2959 if (sd->button_state != new_button_state) {
2960 input_report_key(gspca_dev->input_dev, KEY_CAMERA,
2962 input_sync(gspca_dev->input_dev);
2963 sd->button_state = new_button_state;
2968 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
2970 struct gspca_dev *gspca_dev =
2971 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
2972 struct sd *sd = (struct sd *)gspca_dev;
2974 gspca_dev->usb_err = 0;
2976 if (!gspca_dev->streaming)
2979 if (sd->stop_on_control_change)
2980 sd_stopN(gspca_dev);
2982 case V4L2_CID_BRIGHTNESS:
2983 cit_set_brightness(gspca_dev, ctrl->val);
2985 case V4L2_CID_CONTRAST:
2986 cit_set_contrast(gspca_dev, ctrl->val);
2989 cit_set_hue(gspca_dev, ctrl->val);
2991 case V4L2_CID_HFLIP:
2992 cit_set_hflip(gspca_dev, ctrl->val);
2994 case V4L2_CID_SHARPNESS:
2995 cit_set_sharpness(gspca_dev, ctrl->val);
2997 case V4L2_CID_BACKLIGHT_COMPENSATION:
2998 cit_set_lighting(gspca_dev, ctrl->val);
3001 if (sd->stop_on_control_change)
3002 cit_restart_stream(gspca_dev);
3003 return gspca_dev->usb_err;
3006 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
3007 .s_ctrl = sd_s_ctrl,
3010 static int sd_init_controls(struct gspca_dev *gspca_dev)
3012 struct sd *sd = (struct sd *)gspca_dev;
3013 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
3014 bool has_brightness;
3021 has_brightness = has_contrast = has_hue =
3022 has_sharpness = has_hflip = has_lighting = false;
3023 switch (sd->model) {
3025 has_contrast = has_hflip = true;
3028 has_brightness = has_contrast =
3029 has_sharpness = has_lighting = true;
3032 has_brightness = has_hue = has_lighting = true;
3035 has_brightness = has_contrast = has_sharpness = true;
3038 has_brightness = has_hue = true;
3040 case CIT_IBM_NETCAM_PRO:
3041 has_brightness = has_hue =
3042 has_sharpness = has_hflip = has_lighting = true;
3045 gspca_dev->vdev.ctrl_handler = hdl;
3046 v4l2_ctrl_handler_init(hdl, 5);
3048 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3049 V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
3051 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3052 V4L2_CID_CONTRAST, 0, 20, 1, 10);
3054 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3055 V4L2_CID_HUE, 0, 127, 1, 63);
3057 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3058 V4L2_CID_SHARPNESS, 0, 6, 1, 3);
3060 sd->lighting = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3061 V4L2_CID_BACKLIGHT_COMPENSATION, 0, 2, 1, 1);
3063 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3064 V4L2_CID_HFLIP, 0, 1, 1, 0);
3067 pr_err("Could not initialize controls\n");
3073 /* sub-driver description */
3074 static const struct sd_desc sd_desc = {
3075 .name = MODULE_NAME,
3076 .config = sd_config,
3078 .init_controls = sd_init_controls,
3082 .pkt_scan = sd_pkt_scan,
3083 #if IS_ENABLED(CONFIG_INPUT)
3084 .dq_callback = cit_check_button,
3089 static const struct sd_desc sd_desc_isoc_nego = {
3090 .name = MODULE_NAME,
3091 .config = sd_config,
3093 .init_controls = sd_init_controls,
3095 .isoc_init = sd_isoc_init,
3096 .isoc_nego = sd_isoc_nego,
3099 .pkt_scan = sd_pkt_scan,
3100 #if IS_ENABLED(CONFIG_INPUT)
3101 .dq_callback = cit_check_button,
3106 /* -- module initialisation -- */
3107 static const struct usb_device_id device_table[] = {
3108 { USB_DEVICE_VER(0x0545, 0x8080, 0x0001, 0x0001), .driver_info = CIT_MODEL0 },
3109 { USB_DEVICE_VER(0x0545, 0x8080, 0x0002, 0x0002), .driver_info = CIT_MODEL1 },
3110 { USB_DEVICE_VER(0x0545, 0x8080, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
3111 { USB_DEVICE_VER(0x0545, 0x8080, 0x0301, 0x0301), .driver_info = CIT_MODEL3 },
3112 { USB_DEVICE_VER(0x0545, 0x8002, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
3113 { USB_DEVICE_VER(0x0545, 0x800c, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
3114 { USB_DEVICE_VER(0x0545, 0x800d, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
3117 MODULE_DEVICE_TABLE(usb, device_table);
3119 /* -- device connect -- */
3120 static int sd_probe(struct usb_interface *intf,
3121 const struct usb_device_id *id)
3123 const struct sd_desc *desc = &sd_desc;
3125 switch (id->driver_info) {
3128 if (intf->cur_altsetting->desc.bInterfaceNumber != 2)
3133 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
3137 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
3139 /* FIXME this likely applies to all model3 cams and probably
3140 to other models too. */
3142 desc = &sd_desc_isoc_nego;
3146 return gspca_dev_probe2(intf, id, desc, sizeof(struct sd), THIS_MODULE);
3149 static struct usb_driver sd_driver = {
3150 .name = MODULE_NAME,
3151 .id_table = device_table,
3153 .disconnect = gspca_disconnect,
3155 .suspend = gspca_suspend,
3156 .resume = gspca_resume,
3157 .reset_resume = gspca_resume,
3161 module_usb_driver(sd_driver);