Lines Matching defs:bktr
138 #include <dev/bktr/ioctl_meteor.h>
139 #include <dev/bktr/ioctl_bt848.h> /* extensions to ioctl_meteor.h */
140 #include <dev/bktr/bktr_reg.h>
141 #include <dev/bktr/bktr_tuner.h>
142 #include <dev/bktr/bktr_card.h>
143 #include <dev/bktr/bktr_audio.h>
144 #include <dev/bktr/bktr_os.h>
145 #include <dev/bktr/bktr_core.h>
147 #include <dev/bktr/bktr_mem.h>
151 #include <dev/bktr/bktr_i2c.h>
159 bktr_name(bktr_ptr_t bktr)
161 return bktr->bktr_xname;
199 #include <dev/pci/bktr/bktr_reg.h>
200 #include <dev/pci/bktr/bktr_tuner.h>
201 #include <dev/pci/bktr/bktr_card.h>
202 #include <dev/pci/bktr/bktr_audio.h>
203 #include <dev/pci/bktr/bktr_core.h>
204 #include <dev/pci/bktr/bktr_os.h>
209 bktr_name(bktr_ptr_t bktr)
211 return (bktr->bktr_dev.dv_xname);
410 static int dump_bt848( bktr_ptr_t bktr );
413 static void yuvpack_prog( bktr_ptr_t bktr, char i_flag, int cols,
415 static void yuv422_prog( bktr_ptr_t bktr, char i_flag, int cols,
417 static void yuv12_prog( bktr_ptr_t bktr, char i_flag, int cols,
419 static void rgb_prog( bktr_ptr_t bktr, char i_flag, int cols,
421 static void rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols,
423 static void build_dma_prog( bktr_ptr_t bktr, char i_flag );
430 static void start_capture( bktr_ptr_t bktr, unsigned type );
431 static void set_fps( bktr_ptr_t bktr, u_short fps );
438 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote);
444 static int common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg );
451 static void i2c_start( bktr_ptr_t bktr);
452 static void i2c_stop( bktr_ptr_t bktr);
453 static int i2c_write_byte( bktr_ptr_t bktr, unsigned char data);
454 static int i2c_read_byte( bktr_ptr_t bktr, unsigned char *data, int last );
463 common_bktr_attach( bktr_ptr_t bktr, int unit, u_long pci_id, u_int rev )
476 bktr->dma_prog = get_bktr_mem(bktr, &bktr->dm_prog,
478 bktr->odd_dma_prog = get_bktr_mem(bktr, &bktr->dm_oprog,
482 bktr->vbidata = get_bktr_mem(bktr, &bktr->dm_vbidata,
484 bktr->vbibuffer = get_bktr_mem(bktr, &bktr->dm_vbibuffer,
489 buf = get_bktr_mem(bktr, &bktr->dm_mem, BROOKTREE_ALLOC);
500 bktr->dma_prog = bktr_retrieve_address(unit, BKTR_MEM_DMA_PROG);
501 bktr->odd_dma_prog = bktr_retrieve_address(unit, BKTR_MEM_ODD_DMA_PROG);
502 bktr->vbidata = bktr_retrieve_address(unit, BKTR_MEM_VBIDATA);
503 bktr->vbibuffer = bktr_retrieve_address(unit, BKTR_MEM_VBIBUFFER);
511 bktr->dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC);
512 bktr->odd_dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC);
515 bktr->vbidata = get_bktr_mem(unit, VBI_DATA_SIZE);
516 bktr->vbibuffer = get_bktr_mem(unit, VBI_BUFFER_SIZE);
527 mtx_init(&bktr->vbimutex, "bktr vbi lock", NULL, MTX_DEF);
532 bktr_store_address(unit, BKTR_MEM_DMA_PROG, bktr->dma_prog);
533 bktr_store_address(unit, BKTR_MEM_ODD_DMA_PROG, bktr->odd_dma_prog);
534 bktr_store_address(unit, BKTR_MEM_VBIDATA, bktr->vbidata);
535 bktr_store_address(unit, BKTR_MEM_VBIBUFFER, bktr->vbibuffer);
542 bktr_name(bktr), (int)BROOKTREE_ALLOC,
547 bktr->bigbuf = buf;
548 bktr->alloc_pages = BROOKTREE_ALLOC_PAGES;
549 bzero((caddr_t) bktr->bigbuf, BROOKTREE_ALLOC);
551 bktr->alloc_pages = 0;
555 bktr->flags = METEOR_INITALIZED | METEOR_AUTOMODE |
557 bktr->dma_prog_loaded = FALSE;
558 bktr->cols = 640;
559 bktr->rows = 480;
560 bktr->frames = 1; /* one frame */
561 bktr->format = METEOR_GEO_RGB16;
562 bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
563 bktr->pixfmt_compat = TRUE;
566 bktr->vbiinsert = 0;
567 bktr->vbistart = 0;
568 bktr->vbisize = 0;
569 bktr->vbiflags = 0;
579 bktr->id = BROOKTREE_848A;
581 bktr->id = BROOKTREE_848;
584 bktr->id = BROOKTREE_849A;
587 bktr->id = BROOKTREE_878;
590 bktr->id = BROOKTREE_879;
595 bktr->clr_on_start = FALSE;
598 bktr->tflags = TUNER_INITALIZED;
599 bktr->tuner.frequency = 0;
600 bktr->tuner.channel = 0;
601 bktr->tuner.chnlset = DEFAULT_CHNLSET;
602 bktr->tuner.afc = 0;
603 bktr->tuner.radio_mode = 0;
604 bktr->audio_mux_select = 0;
605 bktr->audio_mute_state = FALSE;
606 bktr->bt848_card = -1;
607 bktr->bt848_tuner = -1;
608 bktr->reverse_mute = -1;
609 bktr->slow_msp_audio = 0;
610 bktr->msp_use_mono_source = 0;
611 bktr->msp_source_selected = -1;
612 bktr->audio_mux_present = 1;
618 if ( (err = resource_int_value("bktr", unit, "mspsimple",
619 &(bktr->mspsimple)) ) != 0 )
620 bktr->mspsimple = -1; /* fall back to default */
624 probeCard( bktr, TRUE, unit );
627 init_audio_devices( bktr );
631 err = msp_attach( bktr );
633 bktr->card.msp3400c = 0;
646 static void vbidecode(bktr_ptr_t bktr) {
651 if (bktr->vbisize + VBI_DATA_SIZE > VBI_BUFFER_SIZE) return;
655 dest = (unsigned char *)bktr->vbibuffer + bktr->vbiinsert;
656 memcpy(dest, (unsigned char*)bktr->vbidata, VBI_DATA_SIZE);
660 seq_dest = (unsigned int *)((unsigned char *)bktr->vbibuffer
661 + bktr->vbiinsert
662 + (VBI_DATA_SIZE - sizeof(bktr->vbi_sequence_number)));
663 *seq_dest = bktr->vbi_sequence_number;
667 bktr->vbi_sequence_number++;
672 bktr->vbiinsert += VBI_DATA_SIZE;
673 bktr->vbiinsert = (bktr->vbiinsert % VBI_BUFFER_SIZE);
676 bktr->vbisize = bktr->vbisize + VBI_DATA_SIZE;
690 bktr_ptr_t bktr;
697 bktr = (bktr_ptr_t) arg;
704 if (INL(bktr, BKTR_INT_MASK) == ALL_INTS_DISABLED)
708 if (!(bktr->flags & METEOR_OPEN)) {
709 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
710 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
715 bktr_status = INL(bktr, BKTR_INT_STAT);
716 OUTL(bktr, BKTR_INT_STAT, bktr_status & ~I2C_BITS); /* don't touch i2c */
719 dstatus = INB(bktr, BKTR_DSTATUS);
720 OUTB(bktr, BKTR_DSTATUS, 0x00);
727 /* printf( "%s: STATUS %x %x %x \n", bktr_name(bktr),
728 dstatus, bktr_status, INL(bktr, BKTR_RISC_COUNT) );
741 || ((INB(bktr, BKTR_TDEC) == 0) && (bktr_status & TDEC_BITS)) ) {
743 u_short tdec_save = INB(bktr, BKTR_TDEC);
745 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
746 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
748 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
751 OUTB(bktr, BKTR_TDEC, 0);
752 OUTB(bktr, BKTR_TDEC, tdec_save);
755 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
756 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
758 bktr->flags |= METEOR_WANT_ODD;
761 bktr->flags |= METEOR_WANT_EVEN;
764 bktr->flags |= METEOR_WANT_MASK;
769 OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog));
770 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
771 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
773 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
778 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
787 printf( "%s: intr status %x %x %x\n", bktr_name(bktr),
788 bktr_status, dstatus, INL(bktr, BKTR_RISC_COUNT) );
797 if (!(bktr->flags & METEOR_CAP_MASK))
798 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
810 LOCK_VBI(bktr);
811 if ( (bktr->vbiflags & VBI_CAPTURE)
812 &&(bktr->vbiflags & VBI_OPEN)
815 vbidecode(bktr);
818 if (bktr->vbi_read_blocked) {
819 bktr->vbi_read_blocked = FALSE;
824 if (SEL_WAITING(&bktr->vbi_select)) {
825 selwakeuppri(&bktr->vbi_select, VBIPRI);
830 UNLOCK_VBI(bktr);
836 switch ( bktr->flags & METEOR_WANT_MASK ) {
841 switch ( bktr->flags & METEOR_ONLY_FIELDS_MASK ) {
849 bktr->flags &= ~METEOR_WANT_EVEN;
852 bktr->flags &= ~METEOR_WANT_ODD;
855 bktr->flags &= ~METEOR_WANT_ODD;
858 bktr->flags &= ~METEOR_WANT_ODD;
859 bktr->flags |= METEOR_WANT_EVEN;
863 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
864 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
866 bktr->flags |= METEOR_WANT_ODD;
869 bktr->flags |= METEOR_WANT_EVEN;
872 bktr->flags |= METEOR_WANT_MASK;
882 if (!(bktr->flags & METEOR_WANT_MASK)) {
883 bktr->frames_captured++;
887 if (bktr->flags & METEOR_WANT_TS) {
890 if ((u_int) bktr->alloc_pages * PAGE_SIZE
891 <= (bktr->frame_size + sizeof(struct timeval))) {
892 ts =(struct timeval *)bktr->bigbuf +
893 bktr->frame_size;
905 if (bktr->flags & METEOR_SINGLE) {
908 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
911 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
920 if (bktr->proc != NULL) {
921 PROC_LOCK(bktr->proc);
922 kern_psignal( bktr->proc, bktr->signal);
923 PROC_UNLOCK(bktr->proc);
940 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
941 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
943 bktr->flags |= METEOR_WANT_ODD;
946 bktr->flags |= METEOR_WANT_EVEN;
949 bktr->flags |= METEOR_WANT_MASK;
966 video_open( bktr_ptr_t bktr )
970 if (bktr->flags & METEOR_OPEN) /* device is busy */
973 bktr->flags |= METEOR_OPEN;
979 bktr->clr_on_start = FALSE;
981 OUTB(bktr, BKTR_DSTATUS, 0x00); /* clear device status reg. */
983 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
998 OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_NTSCM);
999 bktr->format_params = BT848_IFORM_F_NTSCM;
1002 OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_PALBDGHI);
1003 bktr->format_params = BT848_IFORM_F_PALBDGHI;
1007 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | format_params[bktr->format_params].iform_xtsel);
1010 if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
1011 (bktr->id==BROOKTREE_878 || bktr->id==BROOKTREE_879) )
1012 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
1014 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
1016 OUTB(bktr, BKTR_ADELAY, format_params[bktr->format_params].adelay);
1017 OUTB(bktr, BKTR_BDELAY, format_params[bktr->format_params].bdelay);
1018 frame_rate = format_params[bktr->format_params].frame_rate;
1021 if (bktr->xtal_pll_mode == BT848_USE_PLL) {
1022 OUTB(bktr, BKTR_TGCTRL, 0);
1023 OUTB(bktr, BKTR_PLL_F_LO, 0xf9);
1024 OUTB(bktr, BKTR_PLL_F_HI, 0xdc);
1025 OUTB(bktr, BKTR_PLL_F_XCI, 0x8e);
1028 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) | METEOR_DEV0;
1030 bktr->max_clip_node = 0;
1032 OUTB(bktr, BKTR_COLOR_CTL, BT848_COLOR_CTL_GAMMA | BT848_COLOR_CTL_RGB_DED);
1034 OUTB(bktr, BKTR_E_HSCALE_LO, 170);
1035 OUTB(bktr, BKTR_O_HSCALE_LO, 170);
1037 OUTB(bktr, BKTR_E_DELAY_LO, 0x72);
1038 OUTB(bktr, BKTR_O_DELAY_LO, 0x72);
1039 OUTB(bktr, BKTR_E_SCLOOP, 0);
1040 OUTB(bktr, BKTR_O_SCLOOP, 0);
1042 OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
1043 OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
1045 bktr->fifo_errors = 0;
1046 bktr->dma_errors = 0;
1047 bktr->frames_captured = 0;
1048 bktr->even_fields_captured = 0;
1049 bktr->odd_fields_captured = 0;
1050 bktr->proc = NULL;
1051 set_fps(bktr, frame_rate);
1052 bktr->video.addr = 0;
1053 bktr->video.width = 0;
1054 bktr->video.banksize = 0;
1055 bktr->video.ramsize = 0;
1056 bktr->pixfmt_compat = TRUE;
1057 bktr->format = METEOR_GEO_RGB16;
1058 bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
1060 bktr->capture_area_enabled = FALSE;
1062 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT); /* if you take this out triton
1069 vbi_open( bktr_ptr_t bktr )
1072 LOCK_VBI(bktr);
1074 if (bktr->vbiflags & VBI_OPEN) { /* device is busy */
1075 UNLOCK_VBI(bktr);
1079 bktr->vbiflags |= VBI_OPEN;
1082 bktr->vbiinsert = 0;
1083 bktr->vbistart = 0;
1084 bktr->vbisize = 0;
1085 bktr->vbi_sequence_number = 0;
1086 bktr->vbi_read_blocked = FALSE;
1088 bzero((caddr_t) bktr->vbibuffer, VBI_BUFFER_SIZE);
1089 bzero((caddr_t) bktr->vbidata, VBI_DATA_SIZE);
1091 UNLOCK_VBI(bktr);
1100 tuner_open( bktr_ptr_t bktr )
1102 if ( !(bktr->tflags & TUNER_INITALIZED) ) /* device not found */
1105 if ( bktr->tflags & TUNER_OPEN ) /* already open */
1108 bktr->tflags |= TUNER_OPEN;
1109 bktr->tuner.frequency = 0;
1110 bktr->tuner.channel = 0;
1111 bktr->tuner.chnlset = DEFAULT_CHNLSET;
1112 bktr->tuner.afc = 0;
1113 bktr->tuner.radio_mode = 0;
1116 OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) | bktr->card.gpio_mux_bits);
1119 set_audio( bktr, AUDIO_UNMUTE );
1122 init_audio_devices( bktr );
1134 video_close( bktr_ptr_t bktr )
1136 bktr->flags &= ~(METEOR_OPEN |
1141 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1142 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
1144 bktr->dma_prog_loaded = FALSE;
1145 OUTB(bktr, BKTR_TDEC, 0);
1146 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1149 OUTL(bktr, BKTR_SRESET, 0xf);
1150 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
1161 tuner_close( bktr_ptr_t bktr )
1163 bktr->tflags &= ~TUNER_OPEN;
1166 set_audio( bktr, AUDIO_MUTE );
1169 OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) & ~bktr->card.gpio_mux_bits);
1175 vbi_close( bktr_ptr_t bktr )
1178 LOCK_VBI(bktr);
1180 bktr->vbiflags &= ~VBI_OPEN;
1182 UNLOCK_VBI(bktr);
1191 video_read(bktr_ptr_t bktr, int unit, struct cdev *dev, struct uio *uio)
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((caddr_t)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)
1255 LOCK_VBI(bktr);
1257 while(bktr->vbisize == 0) {
1263 bktr->vbi_read_blocked = TRUE;
1265 if ((status = msleep(VBI_SLEEP, &bktr->vbimutex, VBIPRI, "vbi",
1283 if (readsize > bktr->vbisize) readsize = bktr->vbisize;
1287 if((bktr->vbistart + readsize) >= VBI_BUFFER_SIZE) {
1290 readsize2 = VBI_BUFFER_SIZE - bktr->vbistart;
1291 start = bktr->vbistart;
1292 UNLOCK_VBI(bktr);
1293 status = uiomove((caddr_t)bktr->vbibuffer + start, readsize2, uio);
1295 status = uiomove((caddr_t)bktr->vbibuffer, (readsize - readsize2), uio);
1297 UNLOCK_VBI(bktr);
1299 status = uiomove((caddr_t)bktr->vbibuffer + bktr->vbistart, readsize, uio);
1302 LOCK_VBI(bktr);
1305 bktr->vbisize -= readsize;
1308 bktr->vbistart += readsize;
1309 bktr->vbistart = bktr->vbistart % VBI_BUFFER_SIZE; /* wrap around if needed */
1312 UNLOCK_VBI(bktr);
1324 video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td )
1342 bktr->max_clip_node = 0;
1343 memcpy(&bktr->clip_list, arg, sizeof(bktr->clip_list));
1346 if (bktr->clip_list[i].y_min == 0 &&
1347 bktr->clip_list[i].y_max == 0)
1350 bktr->max_clip_node = i;
1364 if (bktr->max_clip_node == 0 &&
1365 (bktr->clip_list[0].y_min != 0 &&
1366 bktr->clip_list[0].y_max != 0)) {
1371 if (bktr->clip_list[i].y_min == 0 &&
1372 bktr->clip_list[i].y_max == 0) {
1375 if ( bktr->clip_list[i+1].y_min != 0 &&
1376 bktr->clip_list[i+1].y_max != 0 &&
1377 bktr->clip_list[i].x_min > bktr->clip_list[i+1].x_min ) {
1379 bktr->max_clip_node = 0;
1384 if (bktr->clip_list[i].x_min >= bktr->clip_list[i].x_max ||
1385 bktr->clip_list[i].y_min >= bktr->clip_list[i].y_max ||
1386 bktr->clip_list[i].x_min < 0 ||
1387 bktr->clip_list[i].x_max < 0 ||
1388 bktr->clip_list[i].y_min < 0 ||
1389 bktr->clip_list[i].y_max < 0 ) {
1390 bktr->max_clip_node = 0;
1395 bktr->dma_prog_loaded = FALSE;
1400 c_temp = INB(bktr, BKTR_DSTATUS);
1409 temp_iform = INB(bktr, BKTR_IFORM);
1412 OUTB(bktr, BKTR_IFORM, (temp_iform | temp | format_params[temp].iform_xtsel));
1415 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1421 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1423 OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay);
1424 OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay);
1425 bktr->format_params = temp;
1433 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1435 OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay);
1436 OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay);
1437 bktr->format_params = temp;
1441 bktr->dma_prog_loaded = FALSE;
1445 temp_iform = INB(bktr, BKTR_IFORM);
1451 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1453 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_NTSCM |
1455 OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_NTSCM].adelay);
1456 OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_NTSCM].bdelay);
1457 bktr->format_params = BT848_IFORM_F_NTSCM;
1461 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1463 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_PALBDGHI |
1465 OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_PALBDGHI].adelay);
1466 OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_PALBDGHI].bdelay);
1467 bktr->format_params = BT848_IFORM_F_PALBDGHI;
1471 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1473 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_AUTO |
1480 bktr->dma_prog_loaded = FALSE;
1484 *(u_long *)arg = bktr->flags & METEOR_FORM_MASK;
1489 *(u_long *)arg = INB(bktr, BKTR_IFORM) & BT848_IFORM_FORMAT;
1494 bktr->fifo_errors = counts->fifo_errors;
1495 bktr->dma_errors = counts->dma_errors;
1496 bktr->frames_captured = counts->frames_captured;
1497 bktr->even_fields_captured = counts->even_fields_captured;
1498 bktr->odd_fields_captured = counts->odd_fields_captured;
1503 counts->fifo_errors = bktr->fifo_errors;
1504 counts->dma_errors = bktr->dma_errors;
1505 counts->frames_captured = bktr->frames_captured;
1506 counts->even_fields_captured = bktr->even_fields_captured;
1507 counts->odd_fields_captured = bktr->odd_fields_captured;
1512 video->addr = bktr->video.addr;
1513 video->width = bktr->video.width;
1514 video->banksize = bktr->video.banksize;
1515 video->ramsize = bktr->video.ramsize;
1520 bktr->video.addr = video->addr;
1521 bktr->video.width = video->width;
1522 bktr->video.banksize = video->banksize;
1523 bktr->video.ramsize = video->ramsize;
1527 set_fps(bktr, *(u_short *)arg);
1531 *(u_short *)arg = bktr->fps;
1535 OUTB(bktr, BKTR_HUE, (*(u_char *) arg) & 0xff);
1539 *(u_char *)arg = INB(bktr, BKTR_HUE);
1544 OUTB(bktr, BKTR_BRIGHT, char_temp);
1549 *(u_char *)arg = INB(bktr, BKTR_BRIGHT);
1555 OUTB(bktr, BKTR_SAT_U_LO, (temp << 1) & 0xff);
1556 OUTB(bktr, BKTR_SAT_V_LO, (temp << 1) & 0xff);
1557 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL)
1560 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL)
1565 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL)
1568 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL)
1575 temp = (INB(bktr, BKTR_SAT_V_LO) >> 1) & 0xff;
1576 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
1584 OUTB(bktr, BKTR_CONTRAST_LO, temp & 0xff);
1585 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_CON_MSB);
1586 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_CON_MSB);
1587 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) |
1589 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) |
1594 temp = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
1595 temp |= ((int)INB(bktr, BKTR_O_CONTROL) & 0x04) << 6;
1600 bktr->clr_on_start = (*(int *)arg != 0);
1604 *(int *)arg = (int) bktr->clr_on_start;
1616 bktr->signal = sig;
1617 bktr->proc = sig ? td->td_proc : NULL;
1621 *(int *)arg = bktr->signal;
1625 temp = bktr->flags;
1629 if (bktr->bigbuf==0) /* no frame buffer allocated */
1637 start_capture(bktr, METEOR_SINGLE);
1640 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
1641 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1642 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1644 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1649 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
1655 bktr_name(bktr), error,
1656 INL(bktr, BKTR_RISC_COUNT));
1660 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1663 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1666 bktr->flags &= ~(METEOR_SINGLE|METEOR_WANT_MASK);
1671 if (bktr->bigbuf==0) /* no frame buffer allocated */
1678 start_capture(bktr, METEOR_CONTIN);
1681 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
1683 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1684 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1685 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
1687 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1697 if (bktr->flags & METEOR_CONTIN) {
1699 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1700 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
1701 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1702 bktr->flags &=
1711 if (bktr->flags & METEOR_CAP_MASK)
1722 bktr_name(bktr));
1728 bktr->flags |= METEOR_ONLY_ODD_FIELDS;
1730 bktr->flags &= ~METEOR_ONLY_ODD_FIELDS;
1732 bktr->flags |= METEOR_ONLY_EVEN_FIELDS;
1734 bktr->flags &= ~METEOR_ONLY_EVEN_FIELDS;
1739 bktr_name(bktr), geo->columns);
1745 bktr_name(bktr), geo->columns);
1752 bktr_name(bktr), geo->rows);
1760 bktr_name(bktr), geo->rows);
1766 bktr_name(bktr));
1774 bktr->dma_prog_loaded = FALSE;
1775 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1777 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1786 if ((int) temp > bktr->alloc_pages
1787 && bktr->video.addr == 0) {
1795 buf = get_bktr_mem(bktr, &dmamap,
1798 free_bktr_mem(bktr, bktr->dm_mem,
1799 bktr->bigbuf);
1800 bktr->dm_mem = dmamap;
1806 (void *)(uintptr_t)bktr->bigbuf,
1807 (bktr->alloc_pages * PAGE_SIZE),
1811 bktr->bigbuf = buf;
1812 bktr->alloc_pages = temp;
1815 bktr_name(bktr), (int)(temp*PAGE_SIZE));
1825 bktr->rows = geo->rows;
1826 bktr->cols = geo->columns;
1827 bktr->frames = geo->frames;
1830 if ( bktr->pixfmt_compat ) {
1831 bktr->format = METEOR_GEO_YUV_422;
1835 bktr->format = METEOR_GEO_RGB16;
1838 bktr->format = METEOR_GEO_RGB24;
1841 bktr->format = METEOR_GEO_YUV_422;
1843 bktr->format = METEOR_GEO_YUV_12;
1846 bktr->format = METEOR_GEO_YUV_PACKED;
1849 bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
1852 if (bktr->flags & METEOR_CAP_MASK) {
1854 if (bktr->flags & (METEOR_CONTIN|METEOR_SYNCAP)) {
1855 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
1857 bktr->flags |= METEOR_WANT_ODD;
1860 bktr->flags |= METEOR_WANT_EVEN;
1863 bktr->flags |= METEOR_WANT_MASK;
1867 start_capture(bktr, METEOR_CONTIN);
1868 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
1869 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1870 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1871 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1898 if (bktr->flags & METEOR_CAP_MASK)
1902 bktr->capture_area_x_offset = cap_area->x_offset;
1903 bktr->capture_area_y_offset = cap_area->y_offset;
1904 bktr->capture_area_x_size = cap_area->x_size;
1905 bktr->capture_area_y_size = cap_area->y_size;
1906 bktr->capture_area_enabled = TRUE;
1908 bktr->dma_prog_loaded = FALSE;
1913 if (bktr->capture_area_enabled == FALSE) {
1917 bktr->format_params].scaled_hactive;
1919 bktr->format_params].vactive;
1921 cap_area->x_offset = bktr->capture_area_x_offset;
1922 cap_area->y_offset = bktr->capture_area_y_offset;
1923 cap_area->x_size = bktr->capture_area_x_size;
1924 cap_area->y_size = bktr->capture_area_y_size;
1929 return common_ioctl( bktr, cmd, arg );
1939 tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td )
1956 if (bktr->remote_control == 0) return (EINVAL);
1957 remote_read(bktr, (struct bktr_remote *)arg);
1962 bktr->tuner.afc = (*(int *)arg != 0);
1966 *(int *)arg = bktr->tuner.afc;
1972 temp_mute( bktr, TRUE );
1973 temp = tv_channel( bktr, (int)*(unsigned long *)arg );
1975 temp_mute( bktr, FALSE );
1982 if ( bktr->card.msp3400c )
1983 msp_autodetect( bktr );
1986 if ( bktr->card.dpl3518a )
1987 dpl_autodetect( bktr );
1989 temp_mute( bktr, FALSE );
1993 *(unsigned long *)arg = bktr->tuner.channel;
2000 bktr->tuner.chnlset = temp;
2004 *(unsigned long *)arg = bktr->tuner.chnlset;
2008 temp = get_tuner_status( bktr );
2013 temp_mute( bktr, TRUE );
2014 temp = tv_freq( bktr, (int)*(unsigned long *)arg, TV_FREQUENCY);
2015 temp_mute( bktr, FALSE );
2017 temp_mute( bktr, FALSE );
2024 if ( bktr->card.msp3400c )
2025 msp_autodetect( bktr );
2028 if ( bktr->card.dpl3518a )
2029 dpl_autodetect( bktr );
2031 temp_mute( bktr, FALSE );
2035 *(unsigned long *)arg = bktr->tuner.frequency;
2042 if ( set_audio( bktr, *(int*)arg ) < 0 )
2048 OUTB(bktr, BKTR_HUE, (u_char)(*(int*)arg & 0xff));
2052 *(int*)arg = (signed char)(INB(bktr, BKTR_HUE) & 0xff);
2057 OUTB(bktr, BKTR_BRIGHT, (u_char)(*(int *)arg & 0xff));
2061 *(int *)arg = (signed char)(INB(bktr, BKTR_BRIGHT) & 0xff);
2068 temp = INB(bktr, BKTR_E_CONTROL);
2069 temp1 = INB(bktr, BKTR_O_CONTROL);
2083 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
2084 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
2085 OUTB(bktr, BKTR_E_CONTROL, temp);
2086 OUTB(bktr, BKTR_O_CONTROL, temp1);
2090 tmp_int = (int)(INB(bktr, BKTR_SAT_V_LO) & 0xff);
2091 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
2100 temp = INB(bktr, BKTR_E_CONTROL);
2101 temp1 = INB(bktr, BKTR_O_CONTROL);
2111 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
2112 OUTB(bktr, BKTR_E_CONTROL, temp);
2113 OUTB(bktr, BKTR_O_CONTROL, temp1);
2117 tmp_int = (int)INB(bktr, BKTR_SAT_V_LO) & 0xff;
2118 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
2127 temp = INB(bktr, BKTR_E_CONTROL);
2128 temp1 = INB(bktr, BKTR_O_CONTROL);
2138 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
2139 OUTB(bktr, BKTR_E_CONTROL, temp);
2140 OUTB(bktr, BKTR_O_CONTROL, temp1);
2144 tmp_int = (int)INB(bktr, BKTR_SAT_U_LO) & 0xff;
2145 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_U_MSB )
2154 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~0xe0);
2155 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~0xe0);
2156 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | tmp_int);
2157 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | tmp_int);
2161 *(int *)arg = (int) ( (INB(bktr, BKTR_E_CONTROL) & 0xe0) >> 5) ;
2169 temp = INB(bktr, BKTR_E_CONTROL);
2170 temp1 = INB(bktr, BKTR_O_CONTROL);
2180 OUTB(bktr, BKTR_CONTRAST_LO, (u_char)(tmp_int & 0xff));
2181 OUTB(bktr, BKTR_E_CONTROL, temp);
2182 OUTB(bktr, BKTR_O_CONTROL, temp1);
2186 tmp_int = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
2187 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_CON_MSB )
2197 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_COLOR_BARS);
2201 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) & ~(BT848_COLOR_CTL_COLOR_BARS));
2205 temp = bktr->audio_mux_select;
2206 if ( bktr->audio_mute_state == TRUE )
2212 if ( set_BTSC( bktr, *(int*)arg ) < 0 )
2220 if ( writeEEProm( bktr, offset, count, buf ) < 0 )
2228 if ( readEEProm( bktr, offset, count, buf ) < 0 )
2236 if ( signCard( bktr, offset, count, buf ) < 0 )
2243 *(int*)arg = INL(bktr, BKTR_GPIO_OUT_EN);
2247 OUTL(bktr, BKTR_GPIO_OUT_EN, *(int*)arg);
2251 *(int*)arg = INL(bktr, BKTR_GPIO_DATA);
2255 OUTL(bktr, BKTR_GPIO_DATA, *(int*)arg);
2262 *(unsigned char *)arg = bktr->tuner.radio_mode;
2266 bktr->tuner.radio_mode = *(unsigned char *)arg;
2270 *(unsigned long *)arg = bktr->tuner.frequency;
2281 printf("%s: arg=%d temp=%d\n", bktr_name(bktr),
2289 printf("%s: Radio frequency out of range\n", bktr_name(bktr));
2293 temp_mute( bktr, TRUE );
2294 temp = tv_freq( bktr, temp, FM_RADIO_FREQUENCY );
2295 temp_mute( bktr, FALSE );
2298 printf("%s: tv_freq returned: %d\n", bktr_name(bktr), temp);
2314 i2cWrite( bktr, i2c_addr, i2c_port, data);
2316 data = i2cRead( bktr, i2c_addr);
2328 msp->data = msp_dpl_read(bktr, bktr->msp_addr,
2337 msp_dpl_write(bktr, bktr->msp_addr, msp->function,
2343 msp_dpl_reset(bktr, bktr->msp_addr);
2348 return common_ioctl( bktr, cmd, arg );
2359 common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg )
2382 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2384 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM)
2388 if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
2389 (bktr->id==BROOKTREE_878 ||
2390 bktr->id==BROOKTREE_879) )
2391 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
2393 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
2395 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2396 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2397 set_audio( bktr, AUDIO_EXTERN );
2402 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2404 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2405 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX0);
2406 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2407 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2408 set_audio( bktr, AUDIO_TUNER );
2413 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2415 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2416 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
2417 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2418 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_O_CONTROL_COMP);
2419 set_audio( bktr, AUDIO_EXTERN );
2424 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2426 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2427 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
2428 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_COMP);
2429 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_COMP);
2430 set_audio( bktr, AUDIO_EXTERN );
2434 if ((bktr->id == BROOKTREE_848A) ||
2435 (bktr->id == BROOKTREE_849A) ||
2436 (bktr->id == BROOKTREE_878) ||
2437 (bktr->id == BROOKTREE_879) ) {
2438 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2440 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2443 if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
2444 (bktr->id==BROOKTREE_878 ||
2445 bktr->id==BROOKTREE_879) )
2446 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
2448 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
2450 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2451 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2452 set_audio( bktr, AUDIO_EXTERN );
2463 *(u_long *)arg = bktr->flags & METEOR_DEV_MASK;
2471 bktr->pixfmt = *(int *)arg;
2472 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
2473 | pixfmt_swap_flags( bktr->pixfmt ));
2474 bktr->pixfmt_compat = FALSE;
2478 *(int *)arg = bktr->pixfmt;
2528 dump_bt848( bktr_ptr_t bktr )
2542 bktr_name(bktr),
2543 r[i], INL(bktr, r[i]),
2544 r[i+1], INL(bktr, r[i+1]),
2545 r[i+2], INL(bktr, r[i+2]),
2546 r[i+3], INL(bktr, r[i+3]]));
2549 printf("%s: INT STAT %x \n", bktr_name(bktr),
2550 INL(bktr, BKTR_INT_STAT));
2551 printf("%s: Reg INT_MASK %x \n", bktr_name(bktr),
2552 INL(bktr, BKTR_INT_MASK));
2553 printf("%s: Reg GPIO_DMA_CTL %x \n", bktr_name(bktr),
2554 INW(bktr, BKTR_GPIO_DMA_CTL));
2604 static bool_t notclipped (bktr_reg_t * bktr, int x, int width) {
2607 bktr->clip_start = -1;
2608 bktr->last_y = 0;
2609 bktr->y = 0;
2610 bktr->y2 = width;
2611 bktr->line_length = width;
2612 bktr->yclip = -1;
2613 bktr->yclip2 = -1;
2614 bktr->current_col = 0;
2616 if (bktr->max_clip_node == 0 ) return TRUE;
2617 clip_node = (bktr_clip_t *) &bktr->clip_list[0];
2620 for (i = 0; i < bktr->max_clip_node; i++ ) {
2621 clip_node = (bktr_clip_t *) &bktr->clip_list[i];
2623 bktr->clip_start = i;
2631 static bool_t getline(bktr_reg_t *bktr, int x ) {
2635 if (bktr->line_length == 0 ||
2636 bktr->current_col >= bktr->line_length) return FALSE;
2638 bktr->y = min(bktr->last_y, bktr->line_length);
2639 bktr->y2 = bktr->line_length;
2641 bktr->yclip = bktr->yclip2 = -1;
2642 for (i = bktr->clip_start; i < bktr->max_clip_node; i++ ) {
2643 clip_node = (bktr_clip_t *) &bktr->clip_list[i];
2645 if (bktr->last_y <= clip_node->y_min) {
2646 bktr->y = min(bktr->last_y, bktr->line_length);
2647 bktr->y2 = min(clip_node->y_min, bktr->line_length);
2648 bktr->yclip = min(clip_node->y_min, bktr->line_length);
2649 bktr->yclip2 = min(clip_node->y_max, bktr->line_length);
2650 bktr->last_y = bktr->yclip2;
2651 bktr->clip_start = i;
2653 for (j = i+1; j < bktr->max_clip_node; j++ ) {
2654 clip_node = (bktr_clip_t *) &bktr->clip_list[j];
2656 if (bktr->last_y >= clip_node->y_min) {
2657 bktr->yclip2 = min(clip_node->y_max, bktr->line_length);
2658 bktr->last_y = bktr->yclip2;
2659 bktr->clip_start = j;
2668 if (bktr->current_col <= bktr->line_length) {
2669 bktr->current_col = bktr->line_length;
2675 static bool_t split(bktr_reg_t * bktr, volatile uint32_t **dma_prog, int width ,
2680 struct meteor_pixfmt *pf = &pixfmt_table[ bktr->pixfmt ].public;
2697 } else if (bktr->current_col == 0 ) {
2699 } else if (bktr->current_col == cols) {
2715 bktr->current_col += width;
2719 if (bktr->current_col == 0 && width == cols) {
2722 } else if (bktr->current_col == 0 ) {
2725 } else if (bktr->current_col >= cols) {
2751 bktr->current_col += width;
2762 rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace )
2770 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
2776 vbisamples = format_params[bktr->format_params].vbi_num_samples;
2777 vbilines = format_params[bktr->format_params].vbi_num_lines;
2780 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2781 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2782 OUTB(bktr, BKTR_VBI_PACK_SIZE, ((num_dwords)) & 0xff);
2783 OUTB(bktr, BKTR_VBI_PACK_DEL, ((num_dwords)>> 8) & 0x01); /* no hdelay */
2786 OUTB(bktr, BKTR_OFORM, 0x00);
2788 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
2789 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
2790 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
2791 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
2794 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
2797 OUTB(bktr, BKTR_E_VTC, 0);
2798 OUTB(bktr, BKTR_O_VTC, 0);
2800 OUTB(bktr, BKTR_E_VTC, 1);
2801 OUTB(bktr, BKTR_O_VTC, 1);
2803 bktr->capcontrol = 3 << 2 | 3;
2805 dma_prog = (uint32_t *) bktr->dma_prog;
2809 if (bktr->video.addr) {
2810 target_buffer = (u_long) bktr->video.addr;
2811 pitch = bktr->video.width;
2814 target_buffer = (u_long) vtophys(bktr->bigbuf);
2834 *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata +
2846 if ( notclipped(bktr, i, width)) {
2847 split(bktr, (volatile uint32_t **) &dma_prog,
2848 bktr->y2 - bktr->y, OP_WRITE,
2852 while(getline(bktr, i)) {
2853 if (bktr->y != bktr->y2 ) {
2854 split(bktr, (volatile uint32_t **) &dma_prog,
2855 bktr->y2 - bktr->y, OP_WRITE,
2858 if (bktr->yclip != bktr->yclip2 ) {
2859 split(bktr,(volatile uint32_t **) &dma_prog,
2860 bktr->yclip2 - bktr->yclip,
2885 *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata +
2903 if ( notclipped(bktr, i, width)) {
2904 split(bktr, (volatile uint32_t **) &dma_prog,
2905 bktr->y2 - bktr->y, OP_WRITE,
2908 while(getline(bktr, i)) {
2909 if (bktr->y != bktr->y2 ) {
2910 split(bktr, (volatile uint32_t **) &dma_prog,
2911 bktr->y2 - bktr->y, OP_WRITE,
2915 if (bktr->yclip != bktr->yclip2 ) {
2916 split(bktr, (volatile uint32_t **) &dma_prog,
2917 bktr->yclip2 - bktr->yclip, OP_SKIP,
2944 rgb_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace )
2950 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
2953 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2954 OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
2955 OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
2956 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2958 OUTB(bktr, BKTR_OFORM, 0x00);
2960 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
2961 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
2962 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
2963 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
2966 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
2969 OUTB(bktr, BKTR_E_VTC, 0);
2970 OUTB(bktr, BKTR_O_VTC, 0);
2972 OUTB(bktr, BKTR_E_VTC, 1);
2973 OUTB(bktr, BKTR_O_VTC, 1);
2975 bktr->capcontrol = 3 << 2 | 3;
2977 dma_prog = (uint32_t *) bktr->dma_prog;
2981 if (bktr->video.addr) {
2982 target_buffer = (uint32_t) bktr->video.addr;
2983 pitch = bktr->video.width;
2986 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
3000 if ( notclipped(bktr, i, width)) {
3001 split(bktr, (volatile uint32_t **) &dma_prog,
3002 bktr->y2 - bktr->y, OP_WRITE,
3006 while(getline(bktr, i)) {
3007 if (bktr->y != bktr->y2 ) {
3008 split(bktr, (volatile uint32_t **) &dma_prog,
3009 bktr->y2 - bktr->y, OP_WRITE,
3012 if (bktr->yclip != bktr->yclip2 ) {
3013 split(bktr,(volatile uint32_t **) &dma_prog,
3014 bktr->yclip2 - bktr->yclip,
3033 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog);
3042 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog);
3050 *dma_prog = (uint32_t ) vtophys(bktr->odd_dma_prog);
3058 dma_prog = (uint32_t *) bktr->odd_dma_prog;
3066 if ( notclipped(bktr, i, width)) {
3067 split(bktr, (volatile uint32_t **) &dma_prog,
3068 bktr->y2 - bktr->y, OP_WRITE,
3071 while(getline(bktr, i)) {
3072 if (bktr->y != bktr->y2 ) {
3073 split(bktr, (volatile uint32_t **) &dma_prog,
3074 bktr->y2 - bktr->y, OP_WRITE,
3078 if (bktr->yclip != bktr->yclip2 ) {
3079 split(bktr, (volatile uint32_t **) &dma_prog,
3080 bktr->yclip2 - bktr->yclip, OP_SKIP,
3097 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog) ;
3106 yuvpack_prog( bktr_ptr_t bktr, char i_flag,
3114 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
3117 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3119 OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* enable chroma comb */
3120 OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
3122 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_RGB_DED | BT848_COLOR_CTL_GAMMA);
3123 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3125 bktr->capcontrol = 1 << 6 | 1 << 4 | 1 << 2 | 3;
3126 bktr->capcontrol = 3 << 2 | 3;
3128 dma_prog = (uint32_t *) bktr->dma_prog;
3137 if (bktr->video.addr)
3138 target_buffer = (uint32_t) bktr->video.addr;
3140 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
3166 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3174 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3182 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog);
3190 dma_prog = (uint32_t *) bktr->odd_dma_prog;
3209 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3212 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3221 yuv422_prog( bktr_ptr_t bktr, char i_flag,
3228 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
3230 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3232 dma_prog = (uint32_t*) bktr->dma_prog;
3234 bktr->capcontrol = 1 << 6 | 1 << 4 | 3;
3236 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3237 OUTB(bktr, BKTR_OFORM, 0x00);
3239 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_LDEC); /* disable luma decimation */
3240 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_LDEC);
3242 OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* chroma agc enable */
3243 OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
3245 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
3246 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
3247 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
3248 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
3251 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
3255 if (bktr->video.addr)
3256 target_buffer = (uint32_t) bktr->video.addr;
3258 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
3283 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3291 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3299 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog);
3305 dma_prog = (uint32_t *) bktr->odd_dma_prog;
3325 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog) ;
3334 yuv12_prog( bktr_ptr_t bktr, char i_flag,
3342 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
3344 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3346 dma_prog = (uint32_t *) bktr->dma_prog;
3348 bktr->capcontrol = 1 << 6 | 1 << 4 | 3;
3350 OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3351 OUTB(bktr, BKTR_OFORM, 0x0);
3356 if (bktr->video.addr)
3357 target_buffer = (uint32_t) bktr->video.addr;
3359 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
3387 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3395 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3402 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog);
3408 dma_prog = (uint32_t *) bktr->odd_dma_prog;
3435 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3445 build_dma_prog( bktr_ptr_t bktr, char i_flag )
3451 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, vtophys(bktr->dma_prog));
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)
3610 bktr->bktr_cap_ctl |=
3612 bktr->vbiflags |= VBI_CAPTURE;
3613 rgb_vbi_prog(bktr, i_flag, cols, rows, interlace);
3616 rgb_prog(bktr, i_flag, cols, rows, interlace);
3622 yuv422_prog(bktr, i_flag, cols, rows, interlace);
3623 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3624 | pixfmt_swap_flags( bktr->pixfmt ));
3629 yuvpack_prog(bktr, i_flag, cols, rows, interlace);
3630 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3631 | pixfmt_swap_flags( bktr->pixfmt ));
3636 yuv12_prog(bktr, i_flag, cols, rows, interlace);
3637 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3638 | pixfmt_swap_flags( bktr->pixfmt ));
3654 start_capture( bktr_ptr_t bktr, unsigned type )
3659 fp = &format_params[bktr->format_params];
3662 if (bktr->clr_on_start && (bktr->video.addr == 0)) {
3663 bzero((caddr_t)bktr->bigbuf,
3664 (size_t)bktr->rows * bktr->cols * bktr->frames *
3665 pixfmt_table[ bktr->pixfmt ].public.Bpp);
3668 OUTB(bktr, BKTR_DSTATUS, 0);
3669 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
3671 bktr->flags |= type;
3672 bktr->flags &= ~METEOR_WANT_MASK;
3673 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
3675 bktr->flags |= METEOR_WANT_EVEN;
3679 bktr->flags |= METEOR_WANT_ODD;
3683 bktr->flags |= METEOR_WANT_MASK;
3690 u_short fps_save = bktr->fps;
3692 set_fps(bktr, fp->frame_rate);
3693 bktr->fps = fps_save;
3696 set_fps(bktr, bktr->fps);
3698 if (bktr->dma_prog_loaded == FALSE) {
3699 build_dma_prog(bktr, i_flag);
3700 bktr->dma_prog_loaded = TRUE;
3704 OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog));
3713 set_fps( bktr_ptr_t bktr, u_short fps )
3718 fp = &format_params[bktr->format_params];
3720 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
3722 bktr->flags |= METEOR_WANT_EVEN;
3726 bktr->flags |= METEOR_WANT_ODD;
3730 bktr->flags |= METEOR_WANT_MASK;
3735 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
3736 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
3738 bktr->fps = fps;
3739 OUTB(bktr, BKTR_TDEC, 0);
3742 OUTB(bktr, BKTR_TDEC, i_flag*(fp->frame_rate - fps) & 0x3f);
3744 OUTB(bktr, BKTR_TDEC, 0);
3847 i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 )
3851 if (bktr->id == BROOKTREE_848 ||
3852 bktr->id == BROOKTREE_848A ||
3853 bktr->id == BROOKTREE_849A)
3859 if (smbus_writew(bktr->i2c_sc.smbus, addr, cmd,
3863 if (smbus_writeb(bktr->i2c_sc.smbus, addr, cmd,
3873 i2cRead( bktr_ptr_t bktr, int addr )
3878 if (bktr->id == BROOKTREE_848 ||
3879 bktr->id == BROOKTREE_848A ||
3880 bktr->id == BROOKTREE_849A)
3885 if (smbus_readb(bktr->i2c_sc.smbus, addr, cmd, &result))
3891 #define IICBUS(bktr) ((bktr)->i2c_sc.iicbb)
3899 msp_dpl_write(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr, unsigned int data)
3908 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3910 iicbus_write_byte(IICBUS(bktr), dev, 0);
3911 iicbus_write_byte(IICBUS(bktr), addr_h, 0);
3912 iicbus_write_byte(IICBUS(bktr), addr_l, 0);
3913 iicbus_write_byte(IICBUS(bktr), data_h, 0);
3914 iicbus_write_byte(IICBUS(bktr), data_l, 0);
3916 iicbus_stop(IICBUS(bktr));
3923 msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr)
3935 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3937 iicbus_write_byte(IICBUS(bktr), dev_r, 0);
3938 iicbus_write_byte(IICBUS(bktr), addr_h, 0);
3939 iicbus_write_byte(IICBUS(bktr), addr_l, 0);
3941 iicbus_repeated_start(IICBUS(bktr), i2c_addr +1, 0 /* no timeout? */);
3942 iicbus_read(IICBUS(bktr), data_read, 2, &read, IIC_LAST_READ, 0);
3943 iicbus_stop(IICBUS(bktr));
3955 msp_dpl_reset( bktr_ptr_t bktr, int i2c_addr )
3960 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3961 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3962 iicbus_write_byte(IICBUS(bktr), 0x80, 0);
3963 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3964 iicbus_stop(IICBUS(bktr));
3967 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3968 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3969 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3970 iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3971 iicbus_stop(IICBUS(bktr));
3976 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) {
3980 iicbus_start(IICBUS(bktr), bktr->remote_control_addr, 0 /* no timeout? */);
3981 iicbus_read(IICBUS(bktr), remote->data, 3, &read, IIC_LAST_READ, 0);
3982 iicbus_stop(IICBUS(bktr));
3993 i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 )
3999 OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE);
4002 if (bktr->id == BROOKTREE_848 ||
4003 bktr->id == BROOKTREE_848A ||
4004 bktr->id == BROOKTREE_849A) {
4015 OUTL(bktr, BKTR_I2C_DATA_CTL, data);
4019 if ( INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE )
4024 if ( !x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK) )
4036 i2cRead( bktr_ptr_t bktr, int addr )
4041 OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE);
4046 if (bktr->id == BROOKTREE_848 ||
4047 bktr->id == BROOKTREE_848A ||
4048 bktr->id == BROOKTREE_849A) {
4049 OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND);
4051 OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND_878);
4056 if ( INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE )
4061 if ( !x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK) )
4065 return( (INL(bktr, BKTR_I2C_DATA_CTL) >> 8) & 0xff );
4075 static void i2c_start( bktr_ptr_t bktr) {
4076 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release data */
4077 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release clock */
4078 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* lower data */
4079 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock */
4082 static void i2c_stop( bktr_ptr_t bktr) {
4083 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock & data */
4084 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* release clock */
4085 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release data */
4088 static int i2c_write_byte( bktr_ptr_t bktr, unsigned char data) {
4095 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4097 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4099 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4103 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4105 OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
4107 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4113 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* float data */
4114 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* strobe clock */
4115 status = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the ACK bit */
4116 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release clock */
4121 static int i2c_read_byte( bktr_ptr_t bktr, unsigned char *data, int last ) {
4127 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4130 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4132 bit = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the data bit */
4134 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4140 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4142 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4144 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4147 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4149 OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
4151 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4161 void msp_dpl_write( bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr,
4170 i2c_start(bktr);
4171 i2c_write_byte(bktr, msp_w_addr);
4172 i2c_write_byte(bktr, dev);
4173 i2c_write_byte(bktr, addr_h);
4174 i2c_write_byte(bktr, addr_l);
4175 i2c_write_byte(bktr, data_h);
4176 i2c_write_byte(bktr, data_l);
4177 i2c_stop(bktr);
4181 unsigned int msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr){
4188 i2c_start(bktr);
4189 i2c_write_byte(bktr,i2c_addr);
4190 i2c_write_byte(bktr,dev_r);
4191 i2c_write_byte(bktr,addr_h);
4192 i2c_write_byte(bktr,addr_l);
4194 i2c_start(bktr);
4195 i2c_write_byte(bktr,i2c_addr+1);
4196 i2c_read_byte(bktr,&data_1, 0);
4197 i2c_read_byte(bktr,&data_2, 1);
4198 i2c_stop(bktr);
4207 void msp_dpl_reset( bktr_ptr_t bktr, int i2c_addr ) {
4211 i2c_start(bktr);
4212 i2c_write_byte(bktr, i2c_addr);
4213 i2c_write_byte(bktr, 0x00);
4214 i2c_write_byte(bktr, 0x80);
4215 i2c_write_byte(bktr, 0x00);
4216 i2c_stop(bktr);
4219 i2c_start(bktr);
4220 i2c_write_byte(bktr, i2c_addr);
4221 i2c_write_byte(bktr, 0x00);
4222 i2c_write_byte(bktr, 0x00);
4223 i2c_write_byte(bktr, 0x00);
4224 i2c_stop(bktr);
4230 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) {
4233 i2c_start(bktr);
4234 i2c_write_byte(bktr,bktr->remote_control_addr);
4235 i2c_read_byte(bktr,&(remote->data[0]), 0);
4236 i2c_read_byte(bktr,&(remote->data[1]), 0);
4237 i2c_read_byte(bktr,&(remote->data[2]), 0);
4238 i2c_stop(bktr);
4256 static int i2cProbe( bktr_ptr_t bktr, int addr );
4264 i2cProbe( bktr_ptr_t bktr, int addr )
4270 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release data */
4271 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release clock */
4273 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* lower data */
4274 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock */
4279 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4281 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4283 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4287 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4289 OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
4291 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4297 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* float data */
4298 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* strobe clock */
4299 status = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the ACK bit */
4300 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release clock */
4303 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock & data */
4304 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* release clock */
4305 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release data */