Lines Matching defs:bktr
4 /* $FreeBSD: src/sys/dev/bktr/bktr_core.c,v 1.114 2000/10/31 13:09:56 roger Exp$ */
144 #include <dev/bktr/bktr_reg.h>
145 #include <dev/bktr/bktr_tuner.h>
146 #include <dev/bktr/bktr_card.h>
147 #include <dev/bktr/bktr_audio.h>
148 #include <dev/bktr/bktr_os.h>
149 #include <dev/bktr/bktr_core.h>
151 #include <dev/bktr/bktr_mem.h>
155 #include <dev/bktr/bktr_i2c.h>
163 bktr_name(bktr_ptr_t bktr)
165 return bktr->bktr_xname;
208 #include <dev/pci/bktr/bktr_reg.h>
209 #include <dev/pci/bktr/bktr_tuner.h>
210 #include <dev/pci/bktr/bktr_card.h>
211 #include <dev/pci/bktr/bktr_audio.h>
212 #include <dev/pci/bktr/bktr_core.h>
213 #include <dev/pci/bktr/bktr_os.h>
218 bktr_name(bktr_ptr_t bktr)
220 return device_xname(bktr->bktr_dev);
420 static int dump_bt848(bktr_ptr_t bktr);
423 static void yuvpack_prog(bktr_ptr_t bktr, char i_flag, int cols,
425 static void yuv422_prog(bktr_ptr_t bktr, char i_flag, int cols,
427 static void yuv12_prog(bktr_ptr_t bktr, char i_flag, int cols,
429 static void rgb_prog(bktr_ptr_t bktr, char i_flag, int cols,
431 static void rgb_vbi_prog(bktr_ptr_t bktr, char i_flag, int cols,
433 static void build_dma_prog(bktr_ptr_t bktr, char i_flag);
440 static void start_capture(bktr_ptr_t bktr, unsigned type);
441 static void set_fps(bktr_ptr_t bktr, u_short fps);
448 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote);
454 static int common_ioctl(bktr_ptr_t bktr, ioctl_cmd_t cmd, void *arg);
461 static void i2c_start(bktr_ptr_t bktr);
462 static void i2c_stop(bktr_ptr_t bktr);
463 static int i2c_write_byte(bktr_ptr_t bktr, unsigned char data);
464 static int i2c_read_byte(bktr_ptr_t bktr, unsigned char *data, int last);
474 common_bktr_attach(bktr_ptr_t bktr, int unit, u_int pci_id, u_int rev)
487 bktr->dma_prog = get_bktr_mem(bktr, &bktr->dm_prog,
489 if (bktr->dma_prog == 0)
491 bktr->odd_dma_prog = get_bktr_mem(bktr, &bktr->dm_oprog,
493 if (bktr->odd_dma_prog == 0)
497 bktr->vbidata = get_bktr_mem(bktr, &bktr->dm_vbidata,
499 if (bktr->vbidata == 0)
501 bktr->vbibuffer = get_bktr_mem(bktr, &bktr->dm_vbibuffer,
503 if (bktr->vbibuffer == 0)
508 sbuf = get_bktr_mem(bktr, &bktr->dm_mem, BROOKTREE_ALLOC);
522 bktr->dma_prog = bktr_retrieve_address(unit, BKTR_MEM_DMA_PROG);
523 bktr->odd_dma_prog = bktr_retrieve_address(unit, BKTR_MEM_ODD_DMA_PROG);
524 bktr->vbidata = bktr_retrieve_address(unit, BKTR_MEM_VBIDATA);
525 bktr->vbibuffer = bktr_retrieve_address(unit, BKTR_MEM_VBIBUFFER);
533 bktr->dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC);
534 bktr->odd_dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC);
537 bktr->vbidata = get_bktr_mem(unit, VBI_DATA_SIZE);
538 bktr->vbibuffer = get_bktr_mem(unit, VBI_BUFFER_SIZE);
551 bktr_store_address(unit, BKTR_MEM_DMA_PROG, bktr->dma_prog);
552 bktr_store_address(unit, BKTR_MEM_ODD_DMA_PROG, bktr->odd_dma_prog);
553 bktr_store_address(unit, BKTR_MEM_VBIDATA, bktr->vbidata);
554 bktr_store_address(unit, BKTR_MEM_VBIBUFFER, bktr->vbibuffer);
561 bktr_name(bktr), BROOKTREE_ALLOC,
562 (void *)(uintptr_t)bktr->dm_mem->dm_segs[0].ds_addr);
566 bktr->bigbuf = sbuf;
567 bktr->alloc_pages = BROOKTREE_ALLOC_PAGES;
568 memset((void *) bktr->bigbuf, 0, BROOKTREE_ALLOC);
570 bktr->alloc_pages = 0;
574 bktr->flags = METEOR_INITIALIZED | METEOR_AUTOMODE |
576 bktr->dma_prog_loaded = FALSE;
577 bktr->cols = 640;
578 bktr->rows = 480;
579 bktr->frames = 1; /* one frame */
580 bktr->format = METEOR_GEO_RGB16;
581 bktr->pixfmt = oformat_meteor_to_bt(bktr->format);
582 bktr->pixfmt_compat = TRUE;
585 bktr->vbiinsert = 0;
586 bktr->vbistart = 0;
587 bktr->vbisize = 0;
588 bktr->vbiflags = 0;
598 bktr->id = BROOKTREE_848A;
600 bktr->id = BROOKTREE_848;
603 bktr->id = BROOKTREE_849A;
606 bktr->id = BROOKTREE_878;
609 bktr->id = BROOKTREE_879;
614 bktr->clr_on_start = FALSE;
617 bktr->tflags = TUNER_INITIALIZED;
618 bktr->tuner.frequency = 0;
619 bktr->tuner.channel = 0;
620 bktr->tuner.chnlset = DEFAULT_CHNLSET;
621 bktr->tuner.afc = 0;
622 bktr->tuner.radio_mode = 0;
623 bktr->audio_mux_select = 0;
624 bktr->audio_mute_state = FALSE;
625 bktr->bt848_card = -1;
626 bktr->bt848_tuner = -1;
627 bktr->reverse_mute = -1;
628 bktr->slow_msp_audio = 0;
629 bktr->msp_use_mono_source = 0;
630 bktr->msp_source_selected = -1;
631 bktr->audio_mux_present = 1;
633 probeCard(bktr, TRUE, unit);
636 init_audio_devices(bktr);
637 bktr->sih = softint_establish(SOFTINT_MPSAFE | SOFTINT_CLOCK,
638 bktr_softintr, bktr);
649 static void vbidecode(bktr_ptr_t bktr) {
654 if (bktr->vbisize + VBI_DATA_SIZE > VBI_BUFFER_SIZE) return;
658 dest = (unsigned char *)bktr->vbibuffer + bktr->vbiinsert;
659 memcpy(dest, (unsigned char*)bktr->vbidata, VBI_DATA_SIZE);
663 seq_dest = (unsigned int *)((unsigned char *)bktr->vbibuffer
664 + bktr->vbiinsert
665 + (VBI_DATA_SIZE - sizeof(bktr->vbi_sequence_number)));
666 *seq_dest = bktr->vbi_sequence_number;
670 bktr->vbi_sequence_number++;
675 bktr->vbiinsert += VBI_DATA_SIZE;
676 bktr->vbiinsert = (bktr->vbiinsert % VBI_BUFFER_SIZE);
679 bktr->vbisize = bktr->vbisize + VBI_DATA_SIZE;
693 bktr_ptr_t bktr;
700 bktr = (bktr_ptr_t) arg;
707 if (INL(bktr, BKTR_INT_MASK) == ALL_INTS_DISABLED)
711 if (!(bktr->flags & METEOR_OPEN)) {
712 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
713 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
718 bktr_status = INL(bktr, BKTR_INT_STAT);
719 OUTL(bktr, BKTR_INT_STAT, bktr_status & ~I2C_BITS); /* don't touch i2c */
722 dstatus = INB(bktr, BKTR_DSTATUS);
723 OUTB(bktr, BKTR_DSTATUS, 0x00);
730 /* printf("%s: STATUS %x %x %x \n", bktr_name(bktr),
731 dstatus, bktr_status, INL(bktr, BKTR_RISC_COUNT));
744 || ((INB(bktr, BKTR_TDEC) == 0) && (bktr_status & TDEC_BITS))) {
746 u_short tdec_save = INB(bktr, BKTR_TDEC);
748 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
749 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
751 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
754 OUTB(bktr, BKTR_TDEC, 0);
755 OUTB(bktr, BKTR_TDEC, tdec_save);
758 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
759 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
761 bktr->flags |= METEOR_WANT_ODD;
764 bktr->flags |= METEOR_WANT_EVEN;
767 bktr->flags |= METEOR_WANT_MASK;
772 OUTL(bktr, BKTR_RISC_STRT_ADD,
773 bktr->dm_prog->dm_segs[0].ds_addr);
774 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
775 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
777 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
782 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
791 printf("%s: intr status %x %x %x\n", bktr_name(bktr),
792 bktr_status, dstatus, INL(bktr, BKTR_RISC_COUNT));
801 if (!(bktr->flags & METEOR_CAP_MASK))
802 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
814 if ((bktr->vbiflags & VBI_CAPTURE)
815 &&(bktr->vbiflags & VBI_OPEN)
818 vbidecode(bktr);
821 if (bktr->vbi_read_blocked) {
822 bktr->vbi_read_blocked = FALSE;
827 selnotify(&bktr->vbi_select, 0, 0);
834 switch (bktr->flags & METEOR_WANT_MASK) {
839 switch (bktr->flags & METEOR_ONLY_FIELDS_MASK) {
847 bktr->flags &= ~METEOR_WANT_EVEN;
850 bktr->flags &= ~METEOR_WANT_ODD;
853 bktr->flags &= ~METEOR_WANT_ODD;
856 bktr->flags &= ~METEOR_WANT_ODD;
857 bktr->flags |= METEOR_WANT_EVEN;
861 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
862 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
864 bktr->flags |= METEOR_WANT_ODD;
867 bktr->flags |= METEOR_WANT_EVEN;
870 bktr->flags |= METEOR_WANT_MASK;
880 if (!(bktr->flags & METEOR_WANT_MASK)) {
881 bktr->frames_captured++;
885 if (bktr->flags & METEOR_WANT_TS) {
888 if ((u_int) bktr->alloc_pages * PAGE_SIZE
889 <= (bktr->frame_size + sizeof(struct timeval))) {
890 ts =(struct timeval *)bktr->bigbuf +
891 bktr->frame_size;
903 if (bktr->flags & METEOR_SINGLE) {
906 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
909 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
918 if (bktr->proc && !(bktr->signal & METEOR_SIG_MODE_MASK)) {
919 softint_schedule(bktr->sih);
936 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
937 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
939 bktr->flags |= METEOR_WANT_ODD;
942 bktr->flags |= METEOR_WANT_EVEN;
945 bktr->flags |= METEOR_WANT_MASK;
957 bktr_ptr_t bktr;
959 bktr = cookie;
962 if (bktr->proc && !(bktr->signal & METEOR_SIG_MODE_MASK)) {
963 psignal(bktr->proc,
964 bktr->signal&(~METEOR_SIG_MODE_MASK));
973 video_open(bktr_ptr_t bktr)
977 if (bktr->flags & METEOR_OPEN) /* device is busy */
981 bktr->proc = NULL;
984 bktr->flags |= METEOR_OPEN;
990 bktr->clr_on_start = FALSE;
992 OUTB(bktr, BKTR_DSTATUS, 0x00); /* clear device status reg. */
994 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
1009 OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_NTSCM);
1010 bktr->format_params = BT848_IFORM_F_NTSCM;
1013 OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_PALBDGHI);
1014 bktr->format_params = BT848_IFORM_F_PALBDGHI;
1018 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | format_params[bktr->format_params].iform_xtsel);
1021 if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
1022 (bktr->id==BROOKTREE_878 || bktr->id==BROOKTREE_879))
1023 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
1025 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
1027 OUTB(bktr, BKTR_ADELAY, format_params[bktr->format_params].adelay);
1028 OUTB(bktr, BKTR_BDELAY, format_params[bktr->format_params].bdelay);
1029 frame_rate = format_params[bktr->format_params].frame_rate;
1032 if (bktr->xtal_pll_mode == BT848_USE_PLL) {
1033 OUTB(bktr, BKTR_TGCTRL, 0);
1034 OUTB(bktr, BKTR_PLL_F_LO, 0xf9);
1035 OUTB(bktr, BKTR_PLL_F_HI, 0xdc);
1036 OUTB(bktr, BKTR_PLL_F_XCI, 0x8e);
1039 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) | METEOR_DEV0;
1041 bktr->max_clip_node = 0;
1043 OUTB(bktr, BKTR_COLOR_CTL, BT848_COLOR_CTL_GAMMA | BT848_COLOR_CTL_RGB_DED);
1045 OUTB(bktr, BKTR_E_HSCALE_LO, 170);
1046 OUTB(bktr, BKTR_O_HSCALE_LO, 170);
1048 OUTB(bktr, BKTR_E_DELAY_LO, 0x72);
1049 OUTB(bktr, BKTR_O_DELAY_LO, 0x72);
1050 OUTB(bktr, BKTR_E_SCLOOP, 0);
1051 OUTB(bktr, BKTR_O_SCLOOP, 0);
1053 OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
1054 OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
1056 bktr->fifo_errors = 0;
1057 bktr->dma_errors = 0;
1058 bktr->frames_captured = 0;
1059 bktr->even_fields_captured = 0;
1060 bktr->odd_fields_captured = 0;
1061 set_fps(bktr, frame_rate);
1062 bktr->video.addr = 0;
1063 bktr->video.width = 0;
1064 bktr->video.banksize = 0;
1065 bktr->video.ramsize = 0;
1066 bktr->pixfmt_compat = TRUE;
1067 bktr->format = METEOR_GEO_RGB16;
1068 bktr->pixfmt = oformat_meteor_to_bt(bktr->format);
1070 bktr->capture_area_enabled = FALSE;
1072 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT); /* if you take this out triton
1079 vbi_open(bktr_ptr_t bktr)
1081 if (bktr->vbiflags & VBI_OPEN) /* device is busy */
1084 bktr->vbiflags |= VBI_OPEN;
1087 bktr->vbiinsert = 0;
1088 bktr->vbistart = 0;
1089 bktr->vbisize = 0;
1090 bktr->vbi_sequence_number = 0;
1091 bktr->vbi_read_blocked = FALSE;
1093 memset((void *) bktr->vbibuffer, 0, VBI_BUFFER_SIZE);
1094 memset((void *) bktr->vbidata, 0, VBI_DATA_SIZE);
1103 tuner_open(bktr_ptr_t bktr)
1105 if (!(bktr->tflags & TUNER_INITIALIZED)) /* device not found */
1108 if (bktr->tflags & TUNER_OPEN) /* already open */
1111 bktr->tflags |= TUNER_OPEN;
1112 bktr->tuner.frequency = 0;
1113 bktr->tuner.channel = 0;
1114 bktr->tuner.chnlset = DEFAULT_CHNLSET;
1115 bktr->tuner.afc = 0;
1116 bktr->tuner.radio_mode = 0;
1119 OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) | bktr->card.gpio_mux_bits);
1122 set_audio(bktr, AUDIO_UNMUTE);
1125 init_audio_devices(bktr);
1137 video_close(bktr_ptr_t bktr)
1139 bktr->flags &= ~(METEOR_OPEN |
1144 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1145 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
1147 bktr->dma_prog_loaded = FALSE;
1148 OUTB(bktr, BKTR_TDEC, 0);
1149 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1152 OUTL(bktr, BKTR_SRESET, 0xf);
1153 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
1164 tuner_close(bktr_ptr_t bktr)
1166 bktr->tflags &= ~TUNER_OPEN;
1169 set_audio(bktr, AUDIO_MUTE);
1172 OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) & ~bktr->card.gpio_mux_bits);
1178 vbi_close(bktr_ptr_t bktr)
1181 bktr->vbiflags &= ~VBI_OPEN;
1190 video_read(bktr_ptr_t bktr, int unit, dev_t dev,
1197 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */
1200 if (bktr->flags & METEOR_CAP_MASK)
1203 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
1206 count = bktr->rows * bktr->cols *
1207 pixfmt_table[bktr->pixfmt].public.Bpp;
1212 bktr->flags &= ~(METEOR_CAP_MASK | METEOR_WANT_MASK);
1215 start_capture(bktr, METEOR_SINGLE);
1217 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
1218 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1219 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1220 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1228 status = uiomove((void *)bktr->bigbuf, count, uio);
1231 bktr_name(bktr), status);
1233 bktr->flags &= ~(METEOR_SINGLE | METEOR_WANT_MASK);
1246 vbi_read(bktr_ptr_t bktr, struct uio *uio, int ioflag)
1252 while(bktr->vbisize == 0) {
1257 bktr->vbi_read_blocked = TRUE;
1270 if (readsize > bktr->vbisize) readsize = bktr->vbisize;
1274 if((bktr->vbistart + readsize) >= VBI_BUFFER_SIZE) {
1277 readsize2 = VBI_BUFFER_SIZE - bktr->vbistart;
1278 status = uiomove((char *)bktr->vbibuffer + bktr->vbistart, readsize2, uio);
1279 status += uiomove((char *)bktr->vbibuffer, (readsize - readsize2), uio);
1282 status = uiomove((char *)bktr->vbibuffer + bktr->vbistart, readsize, uio);
1286 bktr->vbisize -= readsize;
1289 bktr->vbistart += readsize;
1290 bktr->vbistart = bktr->vbistart % VBI_BUFFER_SIZE; /* wrap around if needed */
1303 video_ioctl(bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, void *arg, struct thread* td)
1306 video_ioctl(bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, void *arg,
1329 bktr->max_clip_node = 0;
1330 memcpy(&bktr->clip_list, arg, sizeof(bktr->clip_list));
1333 if (bktr->clip_list[i].y_min == 0 &&
1334 bktr->clip_list[i].y_max == 0)
1337 bktr->max_clip_node = i;
1351 if (bktr->max_clip_node == 0 &&
1352 (bktr->clip_list[0].y_min != 0 &&
1353 bktr->clip_list[0].y_max != 0)) {
1358 if (bktr->clip_list[i].y_min == 0 &&
1359 bktr->clip_list[i].y_max == 0) {
1362 if (bktr->clip_list[i+1].y_min != 0 &&
1363 bktr->clip_list[i+1].y_max != 0 &&
1364 bktr->clip_list[i].x_min > bktr->clip_list[i+1].x_min) {
1366 bktr->max_clip_node = 0;
1371 if (bktr->clip_list[i].x_min >= bktr->clip_list[i].x_max ||
1372 bktr->clip_list[i].y_min >= bktr->clip_list[i].y_max ||
1373 bktr->clip_list[i].x_min < 0 ||
1374 bktr->clip_list[i].x_max < 0 ||
1375 bktr->clip_list[i].y_min < 0 ||
1376 bktr->clip_list[i].y_max < 0) {
1377 bktr->max_clip_node = 0;
1382 bktr->dma_prog_loaded = FALSE;
1387 c_temp = INB(bktr, BKTR_DSTATUS);
1396 temp_iform = INB(bktr, BKTR_IFORM);
1399 OUTB(bktr, BKTR_IFORM, (temp_iform | temp | format_params[temp].iform_xtsel));
1402 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1408 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1410 OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay);
1411 OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay);
1412 bktr->format_params = temp;
1420 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1422 OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay);
1423 OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay);
1424 bktr->format_params = temp;
1428 bktr->dma_prog_loaded = FALSE;
1432 temp_iform = INB(bktr, BKTR_IFORM);
1438 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1440 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_NTSCM |
1442 OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_NTSCM].adelay);
1443 OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_NTSCM].bdelay);
1444 bktr->format_params = BT848_IFORM_F_NTSCM;
1448 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1450 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_PALBDGHI |
1452 OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_PALBDGHI].adelay);
1453 OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_PALBDGHI].bdelay);
1454 bktr->format_params = BT848_IFORM_F_PALBDGHI;
1458 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1460 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_AUTO |
1467 bktr->dma_prog_loaded = FALSE;
1471 *(u_int *)arg = bktr->flags & METEOR_FORM_MASK;
1476 *(u_int *)arg = INB(bktr, BKTR_IFORM) & BT848_IFORM_FORMAT;
1481 bktr->fifo_errors = counts->fifo_errors;
1482 bktr->dma_errors = counts->dma_errors;
1483 bktr->frames_captured = counts->frames_captured;
1484 bktr->even_fields_captured = counts->even_fields_captured;
1485 bktr->odd_fields_captured = counts->odd_fields_captured;
1490 counts->fifo_errors = bktr->fifo_errors;
1491 counts->dma_errors = bktr->dma_errors;
1492 counts->frames_captured = bktr->frames_captured;
1493 counts->even_fields_captured = bktr->even_fields_captured;
1494 counts->odd_fields_captured = bktr->odd_fields_captured;
1499 video->addr = bktr->video.addr;
1500 video->width = bktr->video.width;
1501 video->banksize = bktr->video.banksize;
1502 video->ramsize = bktr->video.ramsize;
1507 bktr->video.addr = video->addr;
1508 bktr->video.width = video->width;
1509 bktr->video.banksize = video->banksize;
1510 bktr->video.ramsize = video->ramsize;
1514 set_fps(bktr, *(u_short *)arg);
1518 *(u_short *)arg = bktr->fps;
1522 OUTB(bktr, BKTR_HUE, (*(u_char *) arg) & 0xff);
1526 *(u_char *)arg = INB(bktr, BKTR_HUE);
1531 OUTB(bktr, BKTR_BRIGHT, char_temp);
1536 *(u_char *)arg = INB(bktr, BKTR_BRIGHT) + 128;
1542 OUTB(bktr, BKTR_SAT_U_LO, (temp << 1) & 0xff);
1543 OUTB(bktr, BKTR_SAT_V_LO, (temp << 1) & 0xff);
1544 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL)
1547 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL)
1552 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL)
1555 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL)
1562 temp = (INB(bktr, BKTR_SAT_V_LO) >> 1) & 0xff;
1563 if (INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB)
1571 OUTB(bktr, BKTR_CONTRAST_LO, temp & 0xff);
1572 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_CON_MSB);
1573 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_CON_MSB);
1574 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) |
1576 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) |
1581 temp = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
1582 temp |= ((int)INB(bktr, BKTR_O_CONTROL) & 0x04) << 6;
1587 bktr->clr_on_start = (*(int *)arg != 0);
1591 *(int *)arg = (int) bktr->clr_on_start;
1601 bktr->signal = *(int *) arg;
1603 bktr->proc = td->td_proc;
1605 bktr->proc = l->l_proc;
1611 *(int *)arg = bktr->signal;
1615 temp = bktr->flags;
1619 if (bktr->bigbuf==0) /* no frame buffer allocated */
1627 start_capture(bktr, METEOR_SINGLE);
1630 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
1631 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1632 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1634 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1639 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
1645 bktr_name(bktr), error,
1646 INL(bktr, BKTR_RISC_COUNT));
1650 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1653 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1656 bktr->flags &= ~(METEOR_SINGLE|METEOR_WANT_MASK);
1661 if (bktr->bigbuf==0) /* no frame buffer allocated */
1668 start_capture(bktr, METEOR_CONTIN);
1671 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
1673 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1674 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1675 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
1677 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1687 if (bktr->flags & METEOR_CONTIN) {
1689 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1690 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
1691 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1692 bktr->flags &=
1701 if (bktr->flags & METEOR_CAP_MASK)
1712 bktr_name(bktr));
1718 bktr->flags |= METEOR_ONLY_ODD_FIELDS;
1720 bktr->flags &= ~METEOR_ONLY_ODD_FIELDS;
1722 bktr->flags |= METEOR_ONLY_EVEN_FIELDS;
1724 bktr->flags &= ~METEOR_ONLY_EVEN_FIELDS;
1729 bktr_name(bktr), geo->columns);
1735 bktr_name(bktr), geo->columns);
1742 bktr_name(bktr), geo->rows);
1750 bktr_name(bktr), geo->rows);
1756 bktr_name(bktr));
1764 bktr->dma_prog_loaded = FALSE;
1765 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1767 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1776 if ((int) temp > bktr->alloc_pages
1777 && bktr->video.addr == 0) {
1785 sbuf = get_bktr_mem(bktr, &dmamap,
1788 free_bktr_mem(bktr, bktr->dm_mem,
1789 bktr->bigbuf);
1790 bktr->dm_mem = dmamap;
1795 kmem_free(kernel_map, bktr->bigbuf,
1796 (bktr->alloc_pages * PAGE_SIZE));
1799 bktr->bigbuf = sbuf;
1800 bktr->alloc_pages = temp;
1804 bktr_name(bktr), temp*PAGE_SIZE);
1814 bktr->rows = geo->rows;
1815 bktr->cols = geo->columns;
1816 bktr->frames = geo->frames;
1819 if (bktr->pixfmt_compat) {
1820 bktr->format = METEOR_GEO_YUV_422;
1824 bktr->format = METEOR_GEO_RGB16;
1827 bktr->format = METEOR_GEO_RGB24;
1830 bktr->format = METEOR_GEO_YUV_422;
1832 bktr->format = METEOR_GEO_YUV_12;
1835 bktr->format = METEOR_GEO_YUV_PACKED;
1838 bktr->pixfmt = oformat_meteor_to_bt(bktr->format);
1841 if (bktr->flags & METEOR_CAP_MASK) {
1843 if (bktr->flags & (METEOR_CONTIN|METEOR_SYNCAP)) {
1844 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
1846 bktr->flags |= METEOR_WANT_ODD;
1849 bktr->flags |= METEOR_WANT_EVEN;
1852 bktr->flags |= METEOR_WANT_MASK;
1856 start_capture(bktr, METEOR_CONTIN);
1857 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
1858 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1859 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1860 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1887 if (bktr->flags & METEOR_CAP_MASK)
1891 bktr->capture_area_x_offset = cap_area->x_offset;
1892 bktr->capture_area_y_offset = cap_area->y_offset;
1893 bktr->capture_area_x_size = cap_area->x_size;
1894 bktr->capture_area_y_size = cap_area->y_size;
1895 bktr->capture_area_enabled = TRUE;
1897 bktr->dma_prog_loaded = FALSE;
1902 if (bktr->capture_area_enabled == FALSE) {
1906 bktr->format_params].scaled_hactive;
1908 bktr->format_params].vactive;
1910 cap_area->x_offset = bktr->capture_area_x_offset;
1911 cap_area->y_offset = bktr->capture_area_y_offset;
1912 cap_area->x_size = bktr->capture_area_x_size;
1913 cap_area->y_size = bktr->capture_area_y_size;
1918 return common_ioctl(bktr, cmd, arg);
1929 tuner_ioctl(bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, void *arg, struct thread* td)
1932 tuner_ioctl(bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, void *arg,
1951 if (bktr->remote_control == 0) return (EINVAL);
1952 remote_read(bktr, (struct bktr_remote *)arg);
1957 bktr->tuner.afc = (*(int *)arg != 0);
1961 *(int *)arg = bktr->tuner.afc;
1967 temp_mute(bktr, TRUE);
1968 temp = tv_channel(bktr, (int)*(unsigned int *)arg);
1973 if (bktr->card.msp3400c)
1974 msp_autodetect(bktr);
1977 if (bktr->card.dpl3518a)
1978 dpl_autodetect(bktr);
1980 temp_mute(bktr, FALSE);
1984 *(unsigned int *)arg = bktr->tuner.channel;
1991 bktr->tuner.chnlset = temp;
1995 *(unsigned int *)arg = bktr->tuner.chnlset;
1999 temp = get_tuner_status(bktr);
2004 temp_mute(bktr, TRUE);
2005 temp = tv_freq(bktr, (int)*(unsigned int *)arg, TV_FREQUENCY);
2006 temp_mute(bktr, FALSE);
2011 if (bktr->card.msp3400c)
2012 msp_autodetect(bktr);
2015 if (bktr->card.dpl3518a)
2016 dpl_autodetect(bktr);
2018 temp_mute(bktr, FALSE);
2022 *(unsigned int *)arg = bktr->tuner.frequency;
2029 if (set_audio(bktr, *(int*)arg) < 0)
2035 OUTB(bktr, BKTR_HUE, (u_char)(*(int*)arg & 0xff));
2039 *(int*)arg = (signed char)(INB(bktr, BKTR_HUE) & 0xff);
2044 OUTB(bktr, BKTR_BRIGHT, (u_char)(*(int *)arg & 0xff));
2048 *(int *)arg = (signed char)(INB(bktr, BKTR_BRIGHT) & 0xff);
2055 temp = INB(bktr, BKTR_E_CONTROL);
2056 temp1 = INB(bktr, BKTR_O_CONTROL);
2070 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
2071 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
2072 OUTB(bktr, BKTR_E_CONTROL, temp);
2073 OUTB(bktr, BKTR_O_CONTROL, temp1);
2077 tmp_int = (int)(INB(bktr, BKTR_SAT_V_LO) & 0xff);
2078 if (INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB)
2087 temp = INB(bktr, BKTR_E_CONTROL);
2088 temp1 = INB(bktr, BKTR_O_CONTROL);
2098 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
2099 OUTB(bktr, BKTR_E_CONTROL, temp);
2100 OUTB(bktr, BKTR_O_CONTROL, temp1);
2104 tmp_int = (int)INB(bktr, BKTR_SAT_V_LO) & 0xff;
2105 if (INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB)
2114 temp = INB(bktr, BKTR_E_CONTROL);
2115 temp1 = INB(bktr, BKTR_O_CONTROL);
2125 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
2126 OUTB(bktr, BKTR_E_CONTROL, temp);
2127 OUTB(bktr, BKTR_O_CONTROL, temp1);
2131 tmp_int = (int)INB(bktr, BKTR_SAT_U_LO) & 0xff;
2132 if (INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_U_MSB)
2141 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~0xe0);
2142 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~0xe0);
2143 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | tmp_int);
2144 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | tmp_int);
2148 *(int *)arg = (int) ((INB(bktr, BKTR_E_CONTROL) & 0xe0) >> 5);
2156 temp = INB(bktr, BKTR_E_CONTROL);
2157 temp1 = INB(bktr, BKTR_O_CONTROL);
2167 OUTB(bktr, BKTR_CONTRAST_LO, (u_char)(tmp_int & 0xff));
2168 OUTB(bktr, BKTR_E_CONTROL, temp);
2169 OUTB(bktr, BKTR_O_CONTROL, temp1);
2173 tmp_int = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
2174 if (INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_CON_MSB)
2184 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_COLOR_BARS);
2188 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) & ~(BT848_COLOR_CTL_COLOR_BARS));
2192 temp = bktr->audio_mux_select;
2193 if (bktr->audio_mute_state == TRUE)
2199 if (set_BTSC(bktr, *(int*)arg) < 0)
2207 if (writeEEProm(bktr, offset, count, sbuf) < 0)
2215 if (readEEProm(bktr, offset, count, sbuf) < 0)
2223 if (signCard(bktr, offset, count, sbuf) < 0)
2230 *(int*)arg = INL(bktr, BKTR_GPIO_OUT_EN);
2234 OUTL(bktr, BKTR_GPIO_OUT_EN, *(int*)arg);
2238 *(int*)arg = INL(bktr, BKTR_GPIO_DATA);
2242 OUTL(bktr, BKTR_GPIO_DATA, *(int*)arg);
2249 *(unsigned char *)arg = bktr->tuner.radio_mode;
2253 bktr->tuner.radio_mode = *(unsigned char *)arg;
2257 *(unsigned int *)arg = bktr->tuner.frequency;
2268 printf("%s: arg=%d temp=%d\n", bktr_name(bktr),
2276 printf("%s: Radio frequency out of range\n", bktr_name(bktr));
2280 temp_mute(bktr, TRUE);
2281 temp = tv_freq(bktr, temp, FM_RADIO_FREQUENCY);
2282 temp_mute(bktr, FALSE);
2285 printf("%s: tv_freq returned: %d\n", bktr_name(bktr), temp);
2299 i2cWrite(bktr, i2c_addr, i2c_port, data);
2301 data = i2cRead(bktr, i2c_addr);
2313 msp->data = msp_dpl_read(bktr, bktr->msp_addr,
2322 msp_dpl_write(bktr, bktr->msp_addr, msp->function,
2328 msp_dpl_reset(bktr, bktr->msp_addr);
2333 return common_ioctl(bktr, cmd, arg);
2344 common_ioctl(bktr_ptr_t bktr, ioctl_cmd_t cmd, void *arg)
2367 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2369 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM)
2373 if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
2374 (bktr->id==BROOKTREE_878 ||
2375 bktr->id==BROOKTREE_879))
2376 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
2378 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
2380 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2381 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2382 set_audio(bktr, AUDIO_EXTERN);
2387 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2389 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2390 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX0);
2391 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2392 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2393 set_audio(bktr, AUDIO_TUNER);
2398 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2400 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2401 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
2402 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2403 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_O_CONTROL_COMP);
2404 set_audio(bktr, AUDIO_EXTERN);
2409 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2411 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2412 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
2413 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_COMP);
2414 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_COMP);
2415 set_audio(bktr, AUDIO_EXTERN);
2419 if ((bktr->id == BROOKTREE_848A) ||
2420 (bktr->id == BROOKTREE_849A) ||
2421 (bktr->id == BROOKTREE_878) ||
2422 (bktr->id == BROOKTREE_879)) {
2423 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2425 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2428 if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
2429 (bktr->id==BROOKTREE_878 ||
2430 bktr->id==BROOKTREE_879))
2431 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
2433 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
2435 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2436 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2437 set_audio(bktr, AUDIO_EXTERN);
2449 *(u_int *)arg = bktr->flags & METEOR_DEV_MASK;
2457 bktr->pixfmt = *(int *)arg;
2458 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
2459 | pixfmt_swap_flags(bktr->pixfmt));
2460 bktr->pixfmt_compat = FALSE;
2464 *(int *)arg = bktr->pixfmt;
2514 dump_bt848(bktr_ptr_t bktr)
2528 bktr_name(bktr),
2529 r[i], INL(bktr, r[i]),
2530 r[i+1], INL(bktr, r[i+1]),
2531 r[i+2], INL(bktr, r[i+2]),
2532 r[i+3], INL(bktr, r[i+3]));
2535 printf("%s: INT STAT %x \n", bktr_name(bktr),
2536 INL(bktr, BKTR_INT_STAT));
2537 printf("%s: Reg INT_MASK %x \n", bktr_name(bktr),
2538 INL(bktr, BKTR_INT_MASK));
2539 printf("%s: Reg GPIO_DMA_CTL %x \n", bktr_name(bktr),
2540 INW(bktr, BKTR_GPIO_DMA_CTL));
2590 static bool_t notclipped (bktr_reg_t * bktr, int x, int width) {
2593 bktr->clip_start = -1;
2594 bktr->last_y = 0;
2595 bktr->y = 0;
2596 bktr->y2 = width;
2597 bktr->line_length = width;
2598 bktr->yclip = -1;
2599 bktr->yclip2 = -1;
2600 bktr->current_col = 0;
2602 if (bktr->max_clip_node == 0) return TRUE;
2603 clip_node = (bktr_clip_t *) &bktr->clip_list[0];
2606 for (i = 0; i < bktr->max_clip_node; i++) {
2607 clip_node = (bktr_clip_t *) &bktr->clip_list[i];
2609 bktr->clip_start = i;
2617 static bool_t getline(bktr_reg_t *bktr, int x) {
2621 if (bktr->line_length == 0 ||
2622 bktr->current_col >= bktr->line_length) return FALSE;
2624 bktr->y = uimin(bktr->last_y, bktr->line_length);
2625 bktr->y2 = bktr->line_length;
2627 bktr->yclip = bktr->yclip2 = -1;
2628 for (i = bktr->clip_start; i < bktr->max_clip_node; i++) {
2629 clip_node = (bktr_clip_t *) &bktr->clip_list[i];
2631 if (bktr->last_y <= clip_node->y_min) {
2632 bktr->y = uimin(bktr->last_y, bktr->line_length);
2633 bktr->y2 = uimin(clip_node->y_min, bktr->line_length);
2634 bktr->yclip = uimin(clip_node->y_min, bktr->line_length);
2635 bktr->yclip2 = uimin(clip_node->y_max, bktr->line_length);
2636 bktr->last_y = bktr->yclip2;
2637 bktr->clip_start = i;
2639 for (j = i+1; j < bktr->max_clip_node; j++) {
2640 clip_node = (bktr_clip_t *) &bktr->clip_list[j];
2642 if (bktr->last_y >= clip_node->y_min) {
2643 bktr->yclip2 = uimin(clip_node->y_max, bktr->line_length);
2644 bktr->last_y = bktr->yclip2;
2645 bktr->clip_start = j;
2654 if (bktr->current_col <= bktr->line_length) {
2655 bktr->current_col = bktr->line_length;
2661 static bool_t split(bktr_reg_t * bktr, volatile u_int **dma_prog, int width ,
2666 const struct meteor_pixfmt *pf = &pixfmt_table[bktr->pixfmt].public;
2683 } else if (bktr->current_col == 0) {
2685 } else if (bktr->current_col == cols) {
2702 bktr->current_col += width;
2706 if (bktr->current_col == 0 && width == cols) {
2709 } else if (bktr->current_col == 0) {
2712 } else if (bktr->current_col >= cols) {
2738 bktr->current_col += width;
2749 rgb_vbi_prog(bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace)
2757 const struct meteor_pixfmt_internal *pf_int = &pixfmt_table[bktr->pixfmt];
2763 vbisamples = format_params[bktr->format_params].vbi_num_samples;
2764 vbilines = format_params[bktr->format_params].vbi_num_lines;
2767 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2768 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2769 OUTB(bktr, BKTR_VBI_PACK_SIZE, ((num_dwords)) & 0xff);
2770 OUTB(bktr, BKTR_VBI_PACK_DEL, ((num_dwords)>> 8) & 0x01); /* no hdelay */
2773 OUTB(bktr, BKTR_OFORM, 0x00);
2775 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
2776 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
2777 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
2778 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
2781 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
2784 OUTB(bktr, BKTR_E_VTC, 0);
2785 OUTB(bktr, BKTR_O_VTC, 0);
2787 OUTB(bktr, BKTR_E_VTC, 1);
2788 OUTB(bktr, BKTR_O_VTC, 1);
2790 bktr->capcontrol = 3 << 2 | 3;
2792 dma_prog = (u_int *) bktr->dma_prog;
2796 if (bktr->video.addr) {
2797 target_buffer = (u_int) bktr->video.addr;
2798 pitch = bktr->video.width;
2801 target_buffer = (u_int) bktr->dm_mem->dm_segs[0].ds_addr;
2813 loop_point = bktr->dm_prog->dm_segs[0].ds_addr;
2822 bktr->dm_vbidata->dm_segs[0].ds_addr + (i * VBI_LINE_SIZE));
2833 if (notclipped(bktr, i, width)) {
2834 split(bktr, (volatile u_int **) &dma_prog,
2835 bktr->y2 - bktr->y, OP_WRITE,
2839 while(getline(bktr, i)) {
2840 if (bktr->y != bktr->y2) {
2841 split(bktr, (volatile u_int **) &dma_prog,
2842 bktr->y2 - bktr->y, OP_WRITE,
2845 if (bktr->yclip != bktr->yclip2) {
2846 split(bktr,(volatile u_int **) &dma_prog,
2847 bktr->yclip2 - bktr->yclip,
2873 bktr->dm_vbidata->dm_segs[0].ds_addr +
2891 if (notclipped(bktr, i, width)) {
2892 split(bktr, (volatile u_int **) &dma_prog,
2893 bktr->y2 - bktr->y, OP_WRITE,
2896 while(getline(bktr, i)) {
2897 if (bktr->y != bktr->y2) {
2898 split(bktr, (volatile u_int **) &dma_prog,
2899 bktr->y2 - bktr->y, OP_WRITE,
2903 if (bktr->yclip != bktr->yclip2) {
2904 split(bktr, (volatile u_int **) &dma_prog,
2905 bktr->yclip2 - bktr->yclip, OP_SKIP,
2932 rgb_prog(bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace)
2938 const struct meteor_pixfmt_internal *pf_int = &pixfmt_table[bktr->pixfmt];
2941 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2942 OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
2943 OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
2944 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2946 OUTB(bktr, BKTR_OFORM, 0x00);
2948 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
2949 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
2950 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
2951 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
2954 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
2957 OUTB(bktr, BKTR_E_VTC, 0);
2958 OUTB(bktr, BKTR_O_VTC, 0);
2960 OUTB(bktr, BKTR_E_VTC, 1);
2961 OUTB(bktr, BKTR_O_VTC, 1);
2963 bktr->capcontrol = 3 << 2 | 3;
2965 dma_prog = (u_int *) bktr->dma_prog;
2969 if (bktr->video.addr) {
2970 target_buffer = (u_int) bktr->video.addr;
2971 pitch = bktr->video.width;
2974 target_buffer = (u_int) bktr->dm_mem->dm_segs[0].ds_addr;
2988 if (notclipped(bktr, i, width)) {
2989 split(bktr, (volatile u_int **) &dma_prog,
2990 bktr->y2 - bktr->y, OP_WRITE,
2994 while(getline(bktr, i)) {
2995 if (bktr->y != bktr->y2) {
2996 split(bktr, (volatile u_int **) &dma_prog,
2997 bktr->y2 - bktr->y, OP_WRITE,
3000 if (bktr->yclip != bktr->yclip2) {
3001 split(bktr,(volatile u_int **) &dma_prog,
3002 bktr->yclip2 - bktr->yclip,
3022 bktr->dm_prog->dm_segs[0].ds_addr);
3032 bktr->dm_prog->dm_segs[0].ds_addr);
3041 bktr->dm_oprog->dm_segs[0].ds_addr);
3049 dma_prog = (u_int *) bktr->odd_dma_prog;
3057 if (notclipped(bktr, i, width)) {
3058 split(bktr, (volatile u_int **) &dma_prog,
3059 bktr->y2 - bktr->y, OP_WRITE,
3062 while(getline(bktr, i)) {
3063 if (bktr->y != bktr->y2) {
3064 split(bktr, (volatile u_int **) &dma_prog,
3065 bktr->y2 - bktr->y, OP_WRITE,
3069 if (bktr->yclip != bktr->yclip2) {
3070 split(bktr, (volatile u_int **) &dma_prog,
3071 bktr->yclip2 - bktr->yclip, OP_SKIP,
3088 *dma_prog++ = htole32((u_int) bktr->dm_prog->dm_segs[0].ds_addr);
3097 yuvpack_prog(bktr_ptr_t bktr, char i_flag,
3105 const struct meteor_pixfmt_internal *pf_int = &pixfmt_table[bktr->pixfmt];
3108 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3110 OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* enable chroma comb */
3111 OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
3113 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_RGB_DED | BT848_COLOR_CTL_GAMMA);
3114 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3116 bktr->capcontrol = 1 << 6 | 1 << 4 | 1 << 2 | 3;
3117 bktr->capcontrol = 3 << 2 | 3;
3119 dma_prog = (u_int *) bktr->dma_prog;
3128 if (bktr->video.addr)
3129 target_buffer = (u_int) bktr->video.addr;
3131 target_buffer = (u_int) bktr->dm_mem->dm_segs[0].ds_addr;
3158 (u_int)bktr->dm_prog->dm_segs[0].ds_addr);
3167 bktr->dm_prog->dm_segs[0].ds_addr);
3176 bktr->dm_oprog->dm_segs[0].ds_addr);
3184 dma_prog = (u_int *) bktr->odd_dma_prog;
3203 *dma_prog++ = htole32((u_int) bktr->dm_prog->dm_segs[0].ds_addr);
3206 *dma_prog++ = htole32((u_int)bktr->dm_prog->dm_segs[0].ds_addr);
3215 yuv422_prog(bktr_ptr_t bktr, char i_flag,
3222 const struct meteor_pixfmt_internal *pf_int = &pixfmt_table[bktr->pixfmt];
3224 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3226 dma_prog = (u_int *) bktr->dma_prog;
3228 bktr->capcontrol = 1 << 6 | 1 << 4 | 3;
3230 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3231 OUTB(bktr, BKTR_OFORM, 0x00);
3233 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_LDEC); /* disable luma decimation */
3234 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_LDEC);
3236 OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* chroma agc enable */
3237 OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
3239 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
3240 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
3241 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
3242 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
3245 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
3249 if (bktr->video.addr)
3250 target_buffer = (u_int) bktr->video.addr;
3252 target_buffer = (u_int) bktr->dm_mem->dm_segs[0].ds_addr;
3278 bktr->dm_prog->dm_segs[0].ds_addr);
3287 bktr->dm_prog->dm_segs[0].ds_addr);
3296 bktr->dm_oprog->dm_segs[0].ds_addr);
3302 dma_prog = (u_int *) bktr->odd_dma_prog;
3322 *dma_prog++ = htole32((u_int)bktr->dm_prog->dm_segs[0].ds_addr);
3331 yuv12_prog(bktr_ptr_t bktr, char i_flag,
3339 const struct meteor_pixfmt_internal *pf_int = &pixfmt_table[bktr->pixfmt];
3341 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3343 dma_prog = (u_int *) bktr->dma_prog;
3345 bktr->capcontrol = 1 << 6 | 1 << 4 | 3;
3347 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3348 OUTB(bktr, BKTR_OFORM, 0x0);
3353 if (bktr->video.addr)
3354 target_buffer = (u_int) bktr->video.addr;
3356 target_buffer = (u_int) bktr->dm_mem->dm_segs[0].ds_addr;
3385 bktr->dm_prog->dm_segs[0].ds_addr);
3394 bktr->dm_prog->dm_segs[0].ds_addr);
3402 bktr->dm_oprog->dm_segs[0].ds_addr);
3408 dma_prog = (u_int *) bktr->odd_dma_prog;
3435 *dma_prog++ = htole32((u_int)bktr->dm_prog->dm_segs[0].ds_addr);
3445 build_dma_prog(bktr_ptr_t bktr, char i_flag)
3451 const struct meteor_pixfmt_internal *pf_int = &pixfmt_table[bktr->pixfmt];
3454 fp = &format_params[bktr->format_params];
3456 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
3459 OUTW(bktr, BKTR_GPIO_DMA_CTL, INW(bktr, BKTR_GPIO_DMA_CTL) & ~FIFO_RISC_ENABLED);
3462 if (bktr->capture_area_enabled)
3463 temp = ((quad_t) fp->htotal* (quad_t) bktr->capture_area_x_size * 4096
3464 / fp->scaled_htotal / bktr->cols) - 4096;
3467 / fp->scaled_htotal / bktr->cols) - 4096;
3469 /* printf("%s: HSCALE value is %d\n", bktr_name(bktr), temp); */
3470 OUTB(bktr, BKTR_E_HSCALE_LO, temp & 0xff);
3471 OUTB(bktr, BKTR_O_HSCALE_LO, temp & 0xff);
3472 OUTB(bktr, BKTR_E_HSCALE_HI, (temp >> 8) & 0xff);
3473 OUTB(bktr, BKTR_O_HSCALE_HI, (temp >> 8) & 0xff);
3476 temp = bktr->cols;
3477 /* printf("%s: HACTIVE value is %d\n", bktr_name(bktr), temp); */
3478 OUTB(bktr, BKTR_E_HACTIVE_LO, temp & 0xff);
3479 OUTB(bktr, BKTR_O_HACTIVE_LO, temp & 0xff);
3480 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0x3);
3481 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0x3);
3482 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 8) & 0x3));
3483 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 8) & 0x3));
3486 if (bktr->capture_area_enabled)
3487 temp = ((fp->hdelay* fp->scaled_hactive + bktr->capture_area_x_offset* fp->scaled_htotal)
3488 * bktr->cols) / (bktr->capture_area_x_size * fp->hactive);
3490 temp = (fp->hdelay * bktr->cols) / fp->hactive;
3494 /* printf("%s: HDELAY value is %d\n", bktr_name(bktr), temp); */
3495 OUTB(bktr, BKTR_E_DELAY_LO, temp & 0xff);
3496 OUTB(bktr, BKTR_O_DELAY_LO, temp & 0xff);
3497 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0xc);
3498 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0xc);
3499 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 6) & 0xc));
3500 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 6) & 0xc));
3504 if (bktr->capture_area_enabled) {
3505 if (bktr->flags & METEOR_ONLY_ODD_FIELDS ||
3506 bktr->flags & METEOR_ONLY_EVEN_FIELDS)
3508 (((bktr->capture_area_y_size * 256 + (bktr->rows/2)) / bktr->rows) - 512);
3511 (((bktr->capture_area_y_size * 512 + (bktr->rows / 2)) / bktr->rows) - 512);
3514 if (bktr->flags & METEOR_ONLY_ODD_FIELDS ||
3515 bktr->flags & METEOR_ONLY_EVEN_FIELDS)
3517 (((fp->vactive * 256 + (bktr->rows/2)) / bktr->rows) - 512);
3520 (((fp->vactive * 512 + (bktr->rows / 2)) / bktr->rows) - 512);
3525 /* printf("%s: VSCALE value is %d\n", bktr_name(bktr), tmp_int); */
3526 OUTB(bktr, BKTR_E_VSCALE_LO, tmp_int & 0xff);
3527 OUTB(bktr, BKTR_O_VSCALE_LO, tmp_int & 0xff);
3528 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x1f);
3529 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x1f);
3530 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | ((tmp_int >> 8) & 0x1f));
3531 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | ((tmp_int >> 8) & 0x1f));
3535 if (bktr->capture_area_enabled)
3536 temp = bktr->capture_area_y_size;
3539 /* printf("%s: VACTIVE is %d\n", bktr_name(bktr), temp); */
3540 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0x30);
3541 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 4) & 0x30));
3542 OUTB(bktr, BKTR_E_VACTIVE_LO, temp & 0xff);
3543 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0x30);
3544 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 4) & 0x30));
3545 OUTB(bktr, BKTR_O_VACTIVE_LO, temp & 0xff);
3548 if (bktr->capture_area_enabled)
3549 temp = fp->vdelay + (bktr->capture_area_y_offset);
3552 /* printf("%s: VDELAY is %d\n", bktr_name(bktr), temp); */
3553 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0xC0);
3554 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 2) & 0xC0));
3555 OUTB(bktr, BKTR_E_VDELAY_LO, temp & 0xff);
3556 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0xC0);
3557 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 2) & 0xC0));
3558 OUTB(bktr, BKTR_O_VDELAY_LO, temp & 0xff);
3562 if ((bktr->xtal_pll_mode == BT848_USE_PLL)
3564 OUTB(bktr, BKTR_TGCTRL, BT848_TGCTRL_TGCKI_PLL); /* Select PLL mode */
3566 OUTB(bktr, BKTR_TGCTRL, BT848_TGCTRL_TGCKI_XTAL); /* Select Normal xtal 0/xtal 1 mode */
3572 bktr->bktr_cap_ctl =
3574 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x20);
3575 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x20);
3579 bktr->bktr_cap_ctl =
3581 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x20);
3582 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x20);
3586 bktr->bktr_cap_ctl =
3589 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x20);
3590 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x20);
3595 OUTL(bktr, BKTR_RISC_STRT_ADD, bktr->dm_prog->dm_segs[0].ds_addr);
3597 rows = bktr->rows;
3598 cols = bktr->cols;
3600 bktr->vbiflags &= ~VBI_CAPTURE; /* default - no vbi capture */
3606 if ((bktr->vbiflags & VBI_OPEN)
3607 ||(bktr->format_params == BT848_IFORM_F_PALBDGHI)
3608 ||(bktr->format_params == BT848_IFORM_F_SECAM)) {
3609 bktr->bktr_cap_ctl |=
3611 bktr->vbiflags |= VBI_CAPTURE;
3612 rgb_vbi_prog(bktr, i_flag, cols, rows, interlace);
3615 rgb_prog(bktr, i_flag, cols, rows, interlace);
3621 yuv422_prog(bktr, i_flag, cols, rows, interlace);
3622 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3623 | pixfmt_swap_flags(bktr->pixfmt));
3628 yuvpack_prog(bktr, i_flag, cols, rows, interlace);
3629 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3630 | pixfmt_swap_flags(bktr->pixfmt));
3635 yuv12_prog(bktr, i_flag, cols, rows, interlace);
3636 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3637 | pixfmt_swap_flags(bktr->pixfmt));
3653 start_capture(bktr_ptr_t bktr, unsigned type)
3658 fp = &format_params[bktr->format_params];
3661 if (bktr->clr_on_start && (bktr->video.addr == 0)) {
3662 memset((void *)bktr->bigbuf, 0,
3663 (size_t)bktr->rows * bktr->cols * bktr->frames *
3664 pixfmt_table[bktr->pixfmt].public.Bpp);
3667 OUTB(bktr, BKTR_DSTATUS, 0);
3668 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
3670 bktr->flags |= type;
3671 bktr->flags &= ~METEOR_WANT_MASK;
3672 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
3674 bktr->flags |= METEOR_WANT_EVEN;
3678 bktr->flags |= METEOR_WANT_ODD;
3682 bktr->flags |= METEOR_WANT_MASK;
3689 u_short fps_save = bktr->fps;
3691 set_fps(bktr, fp->frame_rate);
3692 bktr->fps = fps_save;
3695 set_fps(bktr, bktr->fps);
3697 if (bktr->dma_prog_loaded == FALSE) {
3698 build_dma_prog(bktr, i_flag);
3699 bktr->dma_prog_loaded = TRUE;
3703 OUTL(bktr, BKTR_RISC_STRT_ADD, bktr->dm_prog->dm_segs[0].ds_addr);
3712 set_fps(bktr_ptr_t bktr, u_short fps)
3717 fp = &format_params[bktr->format_params];
3719 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
3721 bktr->flags |= METEOR_WANT_EVEN;
3725 bktr->flags |= METEOR_WANT_ODD;
3729 bktr->flags |= METEOR_WANT_MASK;
3734 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
3735 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
3737 bktr->fps = fps;
3738 OUTB(bktr, BKTR_TDEC, 0);
3741 OUTB(bktr, BKTR_TDEC, i_flag*(fp->frame_rate - fps) & 0x3f);
3743 OUTB(bktr, BKTR_TDEC, 0);
3853 i2cWrite(bktr_ptr_t bktr, int addr, int byte1, int byte2)
3857 if (bktr->id == BROOKTREE_848 ||
3858 bktr->id == BROOKTREE_848A ||
3859 bktr->id == BROOKTREE_849A)
3865 if (smbus_writew(bktr->i2c_sc.smbus, addr, cmd,
3869 if (smbus_writeb(bktr->i2c_sc.smbus, addr, cmd,
3879 i2cRead(bktr_ptr_t bktr, int addr)
3884 if (bktr->id == BROOKTREE_848 ||
3885 bktr->id == BROOKTREE_848A ||
3886 bktr->id == BROOKTREE_849A)
3891 if (smbus_readb(bktr->i2c_sc.smbus, addr, cmd, &result))
3897 #define IICBUS(bktr) ((bktr)->i2c_sc.iicbus)
3905 msp_dpl_write(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr, unsigned int data)
3914 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3916 iicbus_write_byte(IICBUS(bktr), dev, 0);
3917 iicbus_write_byte(IICBUS(bktr), addr_h, 0);
3918 iicbus_write_byte(IICBUS(bktr), addr_l, 0);
3919 iicbus_write_byte(IICBUS(bktr), data_h, 0);
3920 iicbus_write_byte(IICBUS(bktr), data_l, 0);
3922 iicbus_stop(IICBUS(bktr));
3929 msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr)
3941 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3943 iicbus_write_byte(IICBUS(bktr), dev_r, 0);
3944 iicbus_write_byte(IICBUS(bktr), addr_h, 0);
3945 iicbus_write_byte(IICBUS(bktr), addr_l, 0);
3947 iicbus_repeated_start(IICBUS(bktr), i2c_addr +1, 0 /* no timeout? */);
3948 iicbus_read(IICBUS(bktr), data_read, 2, &read, IIC_LAST_READ, 0);
3949 iicbus_stop(IICBUS(bktr));
3961 msp_dpl_reset(bktr_ptr_t bktr, int i2c_addr)
3966 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3967 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3968 iicbus_write_byte(IICBUS(bktr), 0x80, 0);
3969 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3970 iicbus_stop(IICBUS(bktr));
3973 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3974 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3975 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3976 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3977 iicbus_stop(IICBUS(bktr));
3982 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) {
3986 iicbus_start(IICBUS(bktr), bktr->remote_control_addr, 0 /* no timeout? */);
3987 iicbus_read(IICBUS(bktr), remote->data, 3, &read, IIC_LAST_READ, 0);
3988 iicbus_stop(IICBUS(bktr));
3999 i2cWrite(bktr_ptr_t bktr, int addr, int byte1, int byte2)
4005 OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE);
4008 if (bktr->id == BROOKTREE_848 ||
4009 bktr->id == BROOKTREE_848A ||
4010 bktr->id == BROOKTREE_849A) {
4021 OUTL(bktr, BKTR_I2C_DATA_CTL, data);
4025 if (INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE)
4030 if (!x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK))
4042 i2cRead(bktr_ptr_t bktr, int addr)
4047 OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE);
4052 if (bktr->id == BROOKTREE_848 ||
4053 bktr->id == BROOKTREE_848A ||
4054 bktr->id == BROOKTREE_849A) {
4055 OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND);
4057 OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND_878);
4062 if (INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE)
4067 if (!x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK))
4071 return((INL(bktr, BKTR_I2C_DATA_CTL) >> 8) & 0xff);
4081 static void i2c_start(bktr_ptr_t bktr) {
4082 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY(BITD); /* release data */
4083 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY(BITD); /* release clock */
4084 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY(BITD); /* lower data */
4085 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY(BITD); /* lower clock */
4088 static void i2c_stop(bktr_ptr_t bktr) {
4089 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY(BITD); /* lower clock & data */
4090 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY(BITD); /* release clock */
4091 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY(BITD); /* release data */
4094 static int i2c_write_byte(bktr_ptr_t bktr, unsigned char data) {
4101 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4103 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4105 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4109 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4111 OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
4113 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4119 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY(BITD); /* float data */
4120 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY(BITD); /* strobe clock */
4121 status = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the ACK bit */
4122 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY(BITD); /* release clock */
4127 static int i2c_read_byte(bktr_ptr_t bktr, unsigned char *data, int last) {
4133 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4136 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4138 bit = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the data bit */
4140 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4146 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4148 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4150 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4153 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4155 OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
4157 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4167 void msp_dpl_write(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr,
4176 i2c_start(bktr);
4177 i2c_write_byte(bktr, msp_w_addr);
4178 i2c_write_byte(bktr, dev);
4179 i2c_write_byte(bktr, addr_h);
4180 i2c_write_byte(bktr, addr_l);
4181 i2c_write_byte(bktr, data_h);
4182 i2c_write_byte(bktr, data_l);
4183 i2c_stop(bktr);
4187 unsigned int msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr) {
4194 i2c_start(bktr);
4195 i2c_write_byte(bktr,i2c_addr);
4196 i2c_write_byte(bktr,dev_r);
4197 i2c_write_byte(bktr,addr_h);
4198 i2c_write_byte(bktr,addr_l);
4200 i2c_start(bktr);
4201 i2c_write_byte(bktr,i2c_addr+1);
4202 i2c_read_byte(bktr,&data_1, 0);
4203 i2c_read_byte(bktr,&data_2, 1);
4204 i2c_stop(bktr);
4213 void msp_dpl_reset(bktr_ptr_t bktr, int i2c_addr) {
4217 i2c_start(bktr);
4218 i2c_write_byte(bktr, i2c_addr);
4219 i2c_write_byte(bktr, 0x00);
4220 i2c_write_byte(bktr, 0x80);
4221 i2c_write_byte(bktr, 0x00);
4222 i2c_stop(bktr);
4225 i2c_start(bktr);
4226 i2c_write_byte(bktr, i2c_addr);
4227 i2c_write_byte(bktr, 0x00);
4228 i2c_write_byte(bktr, 0x00);
4229 i2c_write_byte(bktr, 0x00);
4230 i2c_stop(bktr);
4236 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) {
4239 i2c_start(bktr);
4240 i2c_write_byte(bktr,bktr->remote_control_addr);
4241 i2c_read_byte(bktr,&(remote->data[0]), 0);
4242 i2c_read_byte(bktr,&(remote->data[1]), 0);
4243 i2c_read_byte(bktr,&(remote->data[2]), 0);
4244 i2c_stop(bktr);
4262 static int i2cProbe(bktr_ptr_t bktr, int addr);
4270 i2cProbe(bktr_ptr_t bktr, int addr)
4276 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY(BITD); /* release data */
4277 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY(BITD); /* release clock */
4279 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY(BITD); /* lower data */
4280 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY(BITD); /* lower clock */
4285 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4287 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4289 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4293 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4295 OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
4297 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4303 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY(BITD); /* float data */
4304 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY(BITD); /* strobe clock */
4305 status = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the ACK bit */
4306 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY(BITD); /* release clock */
4309 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY(BITD); /* lower clock & data */
4310 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY(BITD); /* release clock */
4311 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY(BITD); /* release data */