Lines Matching defs:zr
100 struct zoran *zr = (struct zoran *)codec->master_data->data;
103 if (post_office_wait(zr) || post_office_write(zr, 0, 1, reg >> 8) ||
104 post_office_write(zr, 0, 2, reg & 0xff))
107 data = post_office_read(zr, 0, 3) & 0xff;
113 struct zoran *zr = (struct zoran *)codec->master_data->data;
115 if (post_office_wait(zr) || post_office_write(zr, 0, 1, reg >> 8) ||
116 post_office_write(zr, 0, 2, reg & 0xff))
119 post_office_write(zr, 0, 3, val & 0xff);
125 struct zoran *zr = (struct zoran *)codec->master_data->data;
128 if (post_office_wait(zr) || post_office_write(zr, 1, 0, reg >> 2)) // reg. HIGHBYTES
131 data = post_office_read(zr, 0, reg & 0x03) & 0xff; // reg. LOWBYTES + read
137 struct zoran *zr = (struct zoran *)codec->master_data->data;
139 if (post_office_wait(zr) || post_office_write(zr, 1, 0, reg >> 2)) // reg. HIGHBYTES
142 post_office_write(zr, 0, reg & 0x03, val & 0xff); // reg. LOWBYTES + wr. data
148 struct zoran *zr = (struct zoran *)codec->master_data->data;
151 if (post_office_wait(zr))
154 data = post_office_read(zr, 2, reg & 0x03) & 0xff; // read
161 struct zoran *zr = (struct zoran *)codec->master_data->data;
163 if (post_office_wait(zr))
166 post_office_write(zr, 2, reg & 0x03, val & 0x0ff); // wr. data
173 static void dc10_init(struct zoran *zr)
176 GPIO(zr, 4, 0);
177 GPIO(zr, 5, 1);
179 GPIO(zr, 7, 0);
182 static void dc10plus_init(struct zoran *zr)
186 static void buz_init(struct zoran *zr)
189 pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
190 pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
191 pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
194 static void lml33_init(struct zoran *zr)
196 GPIO(zr, 2, 1); // Set Composite input/output
199 static void avs6eyes_init(struct zoran *zr)
208 GPIO(zr, 4, 1); /* Bt866 SLEEP on */
211 GPIO(zr, 0, 1); /* ZR36060 /RESET on */
212 GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
213 GPIO(zr, 2, mux & 1); /* MUX S0 */
214 GPIO(zr, 3, 0); /* /FRAME on */
215 GPIO(zr, 4, 0); /* Bt866 SLEEP off */
216 GPIO(zr, 5, mux & 2); /* MUX S1 */
217 GPIO(zr, 6, 0); /* ? */
218 GPIO(zr, 7, mux & 4); /* MUX S2 */
240 static int codec_init(struct zoran *zr, u16 codecid)
247 pci_err(zr->pci_dev, "ZR36060 support is not enabled\n");
255 pci_err(zr->pci_dev, "ZR36050 support is not enabled\n");
263 pci_err(zr->pci_dev, "ZR36016 support is not enabled\n");
269 pci_err(zr->pci_dev, "unknown codec id %x\n", codecid);
273 static void codec_exit(struct zoran *zr, u16 codecid)
294 static int videocodec_init(struct zoran *zr)
299 codec_name = codecid_to_modulename(zr->card.video_codec);
301 result = codec_init(zr, zr->card.video_codec);
303 pci_err(zr->pci_dev, "failed to load video codec %s: %d\n",
308 vfe_name = codecid_to_modulename(zr->card.video_vfe);
310 result = codec_init(zr, zr->card.video_vfe);
312 pci_err(zr->pci_dev, "failed to load video vfe %s: %d\n",
315 codec_exit(zr, zr->card.video_codec);
322 static void videocodec_exit(struct zoran *zr)
324 if (zr->card.video_codec != CODEC_TYPE_NONE)
325 codec_exit(zr, zr->card.video_codec);
326 if (zr->card.video_vfe != CODEC_TYPE_NONE)
327 codec_exit(zr, zr->card.video_vfe);
659 struct zoran *zr = (struct zoran *)data;
666 struct zoran *zr = (struct zoran *)data;
673 struct zoran *zr = (struct zoran *)data;
676 zr->i2cbr |= 2;
678 zr->i2cbr &= ~2;
679 btwrite(zr->i2cbr, ZR36057_I2CBR);
684 struct zoran *zr = (struct zoran *)data;
687 zr->i2cbr |= 1;
689 zr->i2cbr &= ~1;
690 btwrite(zr->i2cbr, ZR36057_I2CBR);
702 static int zoran_register_i2c(struct zoran *zr)
704 zr->i2c_algo = zoran_i2c_bit_data_template;
705 zr->i2c_algo.data = zr;
706 strscpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
707 sizeof(zr->i2c_adapter.name));
708 i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
709 zr->i2c_adapter.algo_data = &zr->i2c_algo;
710 zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
711 return i2c_bit_add_bus(&zr->i2c_adapter);
714 static void zoran_unregister_i2c(struct zoran *zr)
716 i2c_del_adapter(&zr->i2c_adapter);
720 int zoran_check_jpg_settings(struct zoran *zr,
725 pci_dbg(zr->pci_dev, "%s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
728 pci_dbg(zr->pci_dev, "%s - x: %d, y: %d, w: %d, y: %d\n", __func__,
758 if (zr->card.type == DC10_NEW) {
759 pci_dbg(zr->pci_dev,
781 (zr->card.type == DC10_NEW || settings->hor_dcm != 4)) {
836 pci_err(zr->pci_dev, "%s - error in params for decimation = 0\n", __func__);
841 pci_err(zr->pci_dev, "%s - decimation = %d, must be 0, 1, 2 or 4\n",
868 static int zoran_init_video_device(struct zoran *zr, struct video_device *video_dev, int dir)
874 video_dev->v4l2_dev = &zr->v4l2_dev;
875 video_dev->lock = &zr->lock;
878 strscpy(video_dev->name, ZR_DEVNAME(zr), sizeof(video_dev->name));
880 zoran_queue_init(zr, &zr->vq, V4L2_BUF_TYPE_VIDEO_CAPTURE);
882 err = video_register_device(video_dev, VFL_TYPE_VIDEO, video_nr[zr->id]);
885 video_set_drvdata(video_dev, zr);
889 static void zoran_exit_video_devices(struct zoran *zr)
891 video_unregister_device(zr->video_dev);
892 kfree(zr->video_dev);
895 static int zoran_init_video_devices(struct zoran *zr)
899 zr->video_dev = video_device_alloc();
900 if (!zr->video_dev)
903 err = zoran_init_video_device(zr, zr->video_dev, V4L2_CAP_VIDEO_CAPTURE);
905 kfree(zr->video_dev);
910 * v4l2_device_unregister() will care about removing zr->encoder/zr->decoder
913 static int zoran_i2c_init(struct zoran *zr)
917 pci_info(zr->pci_dev, "Initializing i2c bus...\n");
919 err = zoran_register_i2c(zr);
921 pci_err(zr->pci_dev, "%s - cannot initialize i2c bus\n", __func__);
925 zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, &zr->i2c_adapter,
926 zr->card.i2c_decoder, 0,
927 zr->card.addrs_decoder);
928 if (!zr->decoder) {
929 pci_err(zr->pci_dev, "Fail to get decoder %s\n", zr->card.i2c_decoder);
934 if (zr->card.i2c_encoder) {
935 zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, &zr->i2c_adapter,
936 zr->card.i2c_encoder, 0,
937 zr->card.addrs_encoder);
938 if (!zr->encoder) {
939 pci_err(zr->pci_dev, "Fail to get encoder %s\n", zr->card.i2c_encoder);
947 zoran_unregister_i2c(zr);
951 static void zoran_i2c_exit(struct zoran *zr)
953 zoran_unregister_i2c(zr);
956 void zoran_open_init_params(struct zoran *zr)
960 zr->v4l_settings.width = 192;
961 zr->v4l_settings.height = 144;
962 zr->v4l_settings.format = &zoran_formats[7]; /* YUY2 - YUV-4:2:2 packed */
963 zr->v4l_settings.bytesperline = zr->v4l_settings.width *
964 ((zr->v4l_settings.format->depth + 7) / 8);
967 zr->jpg_settings.decimation = 1;
968 zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
969 if (zr->card.type != BUZ)
970 zr->jpg_settings.odd_even = 1;
972 zr->jpg_settings.odd_even = 0;
973 zr->jpg_settings.jpg_comp.APPn = 0;
974 zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */
975 memset(zr->jpg_settings.jpg_comp.APP_data, 0,
976 sizeof(zr->jpg_settings.jpg_comp.APP_data));
977 zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */
978 memset(zr->jpg_settings.jpg_comp.COM_data, 0,
979 sizeof(zr->jpg_settings.jpg_comp.COM_data));
980 zr->jpg_settings.jpg_comp.jpeg_markers =
982 i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
984 pci_err(zr->pci_dev, "%s internal error\n", __func__);
986 zr->buffer_size = zr->v4l_settings.bytesperline * zr->v4l_settings.height;
988 clear_interrupt_counters(zr);
991 static int zr36057_init(struct zoran *zr)
995 pci_info(zr->pci_dev, "initializing card[%d]\n", zr->id);
1001 zr->norm = V4L2_STD_PAL;
1002 zr->timing = zr->card.tvn[ZR_NORM_PAL];
1004 zr->norm = V4L2_STD_NTSC;
1005 zr->timing = zr->card.tvn[ZR_NORM_NTSC];
1007 zr->norm = V4L2_STD_SECAM;
1008 zr->timing = zr->card.tvn[ZR_NORM_SECAM];
1010 if (!zr->timing) {
1011 pci_warn(zr->pci_dev,
1014 zr->norm = V4L2_STD_PAL;
1015 zr->timing = zr->card.tvn[ZR_NORM_PAL];
1018 if (default_input > zr->card.inputs - 1) {
1019 pci_warn(zr->pci_dev, "default_input value %d out of range (0-%d)\n",
1020 default_input, zr->card.inputs - 1);
1023 zr->input = default_input;
1026 zoran_open_init_params(zr);
1029 zr->stat_com = dma_alloc_coherent(&zr->pci_dev->dev,
1031 &zr->p_sc, GFP_KERNEL);
1032 if (!zr->stat_com)
1036 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1038 zr->stat_comb = dma_alloc_coherent(&zr->pci_dev->dev,
1040 &zr->p_scb, GFP_KERNEL);
1041 if (!zr->stat_comb) {
1046 err = zoran_init_video_devices(zr);
1050 zoran_init_hardware(zr);
1052 decoder_call(zr, video, s_stream, 0);
1053 encoder_call(zr, video, s_routing, 2, 0, 0);
1056 zr->initialized = 1;
1060 dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32) * 2,
1061 zr->stat_comb, zr->p_scb);
1063 dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32),
1064 zr->stat_com, zr->p_sc);
1071 struct zoran *zr = to_zoran(v4l2_dev);
1073 if (!zr->initialized)
1076 debugfs_remove_recursive(zr->dbgfs_dir);
1078 zoran_queue_exit(zr);
1081 if (zr->codec)
1082 videocodec_detach(zr->codec);
1083 if (zr->vfe)
1084 videocodec_detach(zr->vfe);
1085 videocodec_exit(zr);
1088 zoran_i2c_exit(zr);
1090 zoran_set_pci_master(zr, 0);
1093 pci_free_irq(zr->pci_dev, 0, zr);
1095 dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32),
1096 zr->stat_com, zr->p_sc);
1097 dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32) * 2,
1098 zr->stat_comb, zr->p_scb);
1100 pci_disable_device(zr->pci_dev);
1101 zoran_exit_video_devices(zr);
1103 v4l2_ctrl_handler_free(&zr->hdl);
1104 v4l2_device_unregister(&zr->v4l2_dev);
1112 static struct videocodec_master *zoran_setup_videocodec(struct zoran *zr,
1117 m = devm_kmalloc(&zr->pci_dev->dev, sizeof(*m), GFP_KERNEL);
1130 strscpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1131 m->data = zr;
1156 struct zoran *zr = to_zoran(sd->v4l2_dev);
1163 GPIO(zr, 7, 0);
1165 GPIO(zr, 7, 1);
1170 struct zoran *zr = container_of(ctrl->handler, struct zoran, hdl);
1174 zr->jpg_settings.jpg_comp.quality = ctrl->val;
1175 return zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
1189 struct zoran *zr = seq->private;
1191 seq_printf(seq, "Running mode %x\n", zr->running);
1192 seq_printf(seq, "Codec mode %x\n", zr->codec_mode);
1193 seq_printf(seq, "Norm %llx\n", zr->norm);
1194 seq_printf(seq, "Input %d\n", zr->input);
1195 seq_printf(seq, "Buffersize %d\n", zr->buffer_size);
1197 seq_printf(seq, "V4L width %dx%d\n", zr->v4l_settings.width, zr->v4l_settings.height);
1198 seq_printf(seq, "V4L bytesperline %d\n", zr->v4l_settings.bytesperline);
1200 seq_printf(seq, "JPG decimation %u\n", zr->jpg_settings.decimation);
1201 seq_printf(seq, "JPG hor_dcm %u\n", zr->jpg_settings.hor_dcm);
1202 seq_printf(seq, "JPG ver_dcm %u\n", zr->jpg_settings.ver_dcm);
1203 seq_printf(seq, "JPG tmp_dcm %u\n", zr->jpg_settings.tmp_dcm);
1204 seq_printf(seq, "JPG odd_even %u\n", zr->jpg_settings.odd_even);
1206 zr->jpg_settings.img_x,
1207 zr->jpg_settings.img_y,
1208 zr->jpg_settings.img_width,
1209 zr->jpg_settings.img_height);
1211 seq_printf(seq, "Prepared %u\n", zr->prepared);
1212 seq_printf(seq, "Queued %u\n", zr->queued);
1227 struct zoran *zr;
1255 zr = devm_kzalloc(&pdev->dev, sizeof(*zr), GFP_KERNEL);
1256 if (!zr)
1259 zr->v4l2_dev.notify = zoran_subdev_notify;
1260 if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1262 zr->pci_dev = pdev;
1263 zr->id = nr;
1264 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1265 if (v4l2_ctrl_handler_init(&zr->hdl, 10))
1267 zr->v4l2_dev.ctrl_handler = &zr->hdl;
1268 v4l2_ctrl_new_std(&zr->hdl, &zoran_video_ctrl_ops,
1271 spin_lock_init(&zr->spinlock);
1272 mutex_init(&zr->lock);
1275 zr->revision = zr->pci_dev->revision;
1277 pci_info(zr->pci_dev, "Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
1278 zr->revision < 2 ? '5' : '6', zr->revision,
1279 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
1280 if (zr->revision >= 2)
1281 pci_info(zr->pci_dev, "Subsystem vendor=0x%04x id=0x%04x\n",
1282 zr->pci_dev->subsystem_vendor, zr->pci_dev->subsystem_device);
1286 if (zr->revision < 2) {
1297 pci_info(zr->pci_dev, "%s() - card %s detected\n", __func__,
1315 zr->card = zoran_cards[card_num];
1316 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "%s[%u]",
1317 zr->card.name, zr->id);
1319 err = pci_request_regions(pdev, ZR_DEVNAME(zr));
1323 zr->zr36057_mem = devm_ioremap(&pdev->dev, pci_resource_start(pdev, 0),
1325 if (!zr->zr36057_mem) {
1330 result = pci_request_irq(pdev, 0, zoran_irq, NULL, zr, ZR_DEVNAME(zr));
1336 __func__, zr->pci_dev->irq);
1344 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1346 need_latency = zr->revision > 1 ? 32 : 48;
1348 pci_info(zr->pci_dev, "Changing PCI latency from %d to %d\n",
1350 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, need_latency);
1353 zr36057_restart(zr);
1355 err = zoran_i2c_init(zr);
1359 pci_info(zr->pci_dev, "Initializing videocodec bus...\n");
1360 err = videocodec_init(zr);
1365 jpeg_codec_sleep(zr, 1);
1366 jpeg_codec_reset(zr);
1369 if (zr->card.video_codec != 0) {
1370 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1373 zr->codec = videocodec_attach(master_codec);
1374 if (!zr->codec) {
1378 if (zr->codec->type != zr->card.video_codec) {
1383 if (zr->card.video_vfe != 0) {
1384 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1387 zr->vfe = videocodec_attach(master_vfe);
1388 if (!zr->vfe) {
1392 if (zr->vfe->type != zr->card.video_vfe) {
1399 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1)
1400 pci_info(zr->pci_dev, "ZR36057/Natoma bug, max. buffer size is 128K\n");
1402 if (zr36057_init(zr) < 0)
1405 zr->map_mode = ZORAN_MAP_MODE_RAW;
1407 zr->dbgfs_dir = debugfs_create_dir(ZR_DEVNAME(zr), NULL);
1408 debugfs_create_file("debug", 0444, zr->dbgfs_dir, zr,
1413 videocodec_detach(zr->vfe);
1415 videocodec_detach(zr->codec);
1417 videocodec_exit(zr);
1419 zoran_i2c_exit(zr);
1422 pci_free_irq(zr->pci_dev, 0, zr);
1426 v4l2_ctrl_handler_free(&zr->hdl);
1427 v4l2_device_unregister(&zr->v4l2_dev);