void SwitchConsole_int(CONSOLE *which){ //this one doesn't sti __asm("cli"); CurrentConsole=which; ProcessConsole=which; //just for now.. write_regs(which->vga_registers); write_font(which->font,which->text_height); RefreshConsole(); }
void SetConsoleMode(unsigned char video_mode){ ProcessConsole->video_mode=video_mode; ProcessConsole->vga_registers=video_modes[video_mode]; //must resolve the font for each video mode switch(video_mode){ //set appropriate fonts, and sizes case 0: ProcessConsole->font=g_8x8_font; ProcessConsole->text_height=8; ProcessConsole->width=90; ProcessConsole->height=60; ProcessConsole->size=90*60*2; break; case 1: ProcessConsole->font=g_8x16_font; ProcessConsole->text_height=16; ProcessConsole->width=80; ProcessConsole->height=25; ProcessConsole->size=80*25*2; break; case 2: ProcessConsole->font=g_8x16_font; ProcessConsole->text_height=16; ProcessConsole->width=90; ProcessConsole->height=30; ProcessConsole->size=90*30*2; break; case 3: ProcessConsole->font=g_8x8_font; ProcessConsole->text_height=8; ProcessConsole->width=80; ProcessConsole->height=50; ProcessConsole->size=80*50*2; break; case 4: ProcessConsole->font=g_8x8_font; ProcessConsole->text_height=8; ProcessConsole->width=40; ProcessConsole->height=50; ProcessConsole->size=40*50*2; break; case 5: ProcessConsole->font=g_8x16_font; ProcessConsole->text_height=16; ProcessConsole->width=40; ProcessConsole->height=25; ProcessConsole->size=40*25*2; break; } free(ProcessConsole->buffer); ProcessConsole->size=(ProcessConsole->width*2*ProcessConsole->height); ProcessConsole->buffer=malloc(ProcessConsole->size); cls(); __asm("cli"); write_regs(ProcessConsole->vga_registers); write_font(ProcessConsole->font,ProcessConsole->text_height); RefreshConsole(); __asm("sti"); }
void except::behavior(hw_thread_ptr & hardware_thread) { #else void except::behavior() { hw_thread_ptr hardware_thread = in.read(); #endif /* _NO_SYSTEMC_ */ /* Check if the hardware thread is enabled */ if (_is_not_valid_hwthread(hardware_thread)) { return; } /* Everytime an instruction goes through this stage, increase its cycle count to 6 */ hardware_thread->cnt_cycles += 6; /* If fetch stage is stalled then just increment the cycle count and return. */ if (hardware_thread->is_fetch_stalled()) { return; } debug(hardware_thread); /* If the current instruction is a double word then set a flag to note it */ set_dword_state(hardware_thread); /* If deadline is causing a stall then let skip out of this stage */ if (dead_stalled(hardware_thread)) { return; } /* If the instruction fetch caused a stall then skip out of this stage */ if (fetch_stalled(hardware_thread)) { return; } /* If memory is causing a stall then skip out of this stage */ if (mem_stalled(hardware_thread)) { return; } if (!hardware_thread->is_db_word_stalled()) { /* Increment the PC based */ inc_pc(hardware_thread); } write_regs(hardware_thread); write_special_regs(hardware_thread); /* Increment the number of instructions executed */ hardware_thread->cnt_instr++; }
static int wis_saa7115_detect(struct i2c_adapter *adapter, int addr, int kind) { struct i2c_client *client; struct wis_saa7115 *dec; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return 0; client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); if (client == NULL) return -ENOMEM; memcpy(client, &wis_saa7115_client_templ, sizeof(wis_saa7115_client_templ)); client->adapter = adapter; client->addr = addr; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) client->id = wis_saa7115_i2c_id++; #endif dec = kmalloc(sizeof(struct wis_saa7115), GFP_KERNEL); if (dec == NULL) { kfree(client); return -ENOMEM; } dec->norm = VIDEO_MODE_NTSC; dec->brightness = 128; dec->contrast = 64; dec->saturation = 64; dec->hue = 0; i2c_set_clientdata(client, dec); printk(KERN_DEBUG "wis-saa7115: initializing SAA7115 at address %d on %s\n", addr, adapter->name); if (write_regs(client, initial_registers) < 0) { printk(KERN_ERR "wis-saa7115: error initializing SAA7115\n"); kfree(client); kfree(dec); return 0; } i2c_attach_client(client); return 0; }
int ModbusSlave232::preset_multiple_registers(unsigned int start_addr, unsigned char count, unsigned char *query, int *regs) { unsigned char function = FC_WRITE_REGS; /* Preset Multiple Registers */ int status = 0; unsigned char packet[RESPONSE_SIZE + CHECKSUM_SIZE]; build_write_packet(function, start_addr, count, packet); if (write_regs(start_addr, query, regs)) { status = send_reply(packet, RESPONSE_SIZE); } return (status); }
static int wis_ov7640_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = client->adapter; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -ENODEV; client->flags = I2C_CLIENT_SCCB; printk(KERN_DEBUG "wis-ov7640: initializing OV7640 at address %d on %s\n", client->addr, adapter->name); if (write_regs(client, initial_registers) < 0) { printk(KERN_ERR "wis-ov7640: error initializing OV7640\n"); return -ENODEV; } return 0; }
static void vga_generic_unset_mode(vgageneric_handle_t *dev) { set_plane(0); memcpy(0xC00A0000, dev->mem0, 128*1024); set_plane(1); memcpy(0xC00A0000, dev->mem1, 128*1024); set_plane(2); memcpy(0xC00A0000, dev->mem2, 128*1024); set_plane(3); memcpy(0xC00A0000, dev->mem3, 128*1024); set_plane(0); free(dev->mem0); free(dev->mem1); free(dev->mem2); free(dev->mem3); write_regs(dev->regs); free(dev->regs); dev->regs = 0; }
static inline int smb_mode_output(struct bladerf *dev) { int status; uint8_t val; status = dev->backend->si5338_read(dev, 39, &val); if (status != 0) { return status; } val |= 1; status = dev->backend->si5338_write(dev, 39, val); if (status != 0) { return status; } status = write_regs(dev, output_config, ARRAY_SIZE(output_config)); if (status != 0) { return status; } return status; }
static inline int smb_mode_output(struct bladerf *dev) { int status; uint8_t val; status = SI5338_READ(dev, 39, &val); if (status != 0) { return status; } val |= 1; status = SI5338_WRITE(dev, 39, val); if (status != 0) { return status; } status = write_regs(dev, output_config, ARRAY_SIZE(output_config)); if (status != 0) { return status; } return status; }
//////////////////////////////////////////////////////////////////////////////// // Functions //////////////////////////////////////////////////////////////////////////////// static int vga_generic_set_mode(vgageneric_handle_t *dev, int width, int height, int bpp) { dev->regs = malloc(128); read_regs(dev->regs); write_regs(g_640x480x16); dev->mem0 = malloc(128*1024); dev->mem1 = malloc(128*1024); dev->mem2 = malloc(128*1024); dev->mem3 = malloc(128*1024); set_plane(0); memcpy(dev->mem0, 0xC00A0000, 128*1024); set_plane(1); memcpy(dev->mem1, 0xC00A0000, 128*1024); set_plane(2); memcpy(dev->mem2, 0xC00A0000, 128*1024); set_plane(3); memcpy(dev->mem3, 0xC00A0000, 128*1024); return 1; }
static int tw2804_s_std(struct v4l2_subdev *sd, v4l2_std_id norm) { struct tw2804 *dec = to_state(sd); struct i2c_client *client = v4l2_get_subdevdata(sd); bool is_60hz = norm & V4L2_STD_525_60; u8 regs[] = { 0x01, is_60hz ? 0xc4 : 0x84, 0x09, is_60hz ? 0x07 : 0x04, 0x0a, is_60hz ? 0xf0 : 0x20, 0x0b, is_60hz ? 0x07 : 0x04, 0x0c, is_60hz ? 0xf0 : 0x20, 0x0d, is_60hz ? 0x40 : 0x4a, 0x16, is_60hz ? 0x00 : 0x40, 0x17, is_60hz ? 0x00 : 0x40, 0x20, is_60hz ? 0x07 : 0x0f, 0x21, is_60hz ? 0x07 : 0x0f, 0xff, 0xff, }; write_regs(client, regs, dec->channel); dec->norm = norm; return 0; }
static inline int smb_mode_input(struct bladerf *dev) { int status; uint8_t val; status = write_regs(dev, input_config, ARRAY_SIZE(input_config)); if (status != 0) { return status; } /* Turn off any SMB connector output */ status = dev->backend->si5338_read(dev, 39, &val); if (status != 0) { return status; } val &= ~(1); status = dev->backend->si5338_write(dev, 39, val); if (status != 0) { return status; } return status; }
int SCOPE post_ioctl(const struct syscall_regs * regs) { INJ_TRACE("ioctl: fd=%d, cmd=0x%x, arg=0x%x\n", regs->ebx, regs->ecx, regs->edx); write_regs(regs); int fd = regs->ebx; int cmd = regs->ecx; int arg = regs->edx; write_eax(regs); switch (_IOC_TYPE(cmd)) { case 'T': return post_tty_ioctl(fd, cmd, arg, regs); case 0x12: return post_blk_ioctl(fd, cmd, arg, regs); default: INJ_ERROR("no such ioctl command: 0x%x\n", cmd); __exit(-1); } return 0; }
static inline int smb_mode_disabled(struct bladerf *dev) { return write_regs(dev, default_config, ARRAY_SIZE(default_config)); }
static int wis_tw2804_command(struct i2c_client *client, unsigned int cmd, void *arg) { struct wis_tw2804 *dec = i2c_get_clientdata(client); if (cmd == DECODER_SET_CHANNEL) { int *input = arg; if (*input < 0 || *input > 3) { printk(KERN_ERR "wis-tw2804: channel %d is not " "between 0 and 3!\n", *input); return 0; } dec->channel = *input; printk(KERN_DEBUG "wis-tw2804: initializing TW2804 " "channel %d\n", dec->channel); if (dec->channel == 0 && write_regs(client, global_registers, 0) < 0) { printk(KERN_ERR "wis-tw2804: error initializing " "TW2804 global registers\n"); return 0; } if (write_regs(client, channel_registers, dec->channel) < 0) { printk(KERN_ERR "wis-tw2804: error initializing " "TW2804 channel %d\n", dec->channel); return 0; } return 0; } if (dec->channel < 0) { printk(KERN_DEBUG "wis-tw2804: ignoring command %08x until " "channel number is set\n", cmd); return 0; } switch (cmd) { case VIDIOC_S_STD: { v4l2_std_id *input = arg; u8 regs[] = { 0x01, *input & V4L2_STD_NTSC ? 0xc4 : 0x84, 0x09, *input & V4L2_STD_NTSC ? 0x07 : 0x04, 0x0a, *input & V4L2_STD_NTSC ? 0xf0 : 0x20, 0x0b, *input & V4L2_STD_NTSC ? 0x07 : 0x04, 0x0c, *input & V4L2_STD_NTSC ? 0xf0 : 0x20, 0x0d, *input & V4L2_STD_NTSC ? 0x40 : 0x4a, 0x16, *input & V4L2_STD_NTSC ? 0x00 : 0x40, 0x17, *input & V4L2_STD_NTSC ? 0x00 : 0x40, 0x20, *input & V4L2_STD_NTSC ? 0x07 : 0x0f, 0x21, *input & V4L2_STD_NTSC ? 0x07 : 0x0f, 0xff, 0xff, }; write_regs(client, regs, dec->channel); dec->norm = *input; break; } case VIDIOC_QUERYCTRL: { struct v4l2_queryctrl *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Brightness", sizeof(ctrl->name)); ctrl->minimum = 0; ctrl->maximum = 255; ctrl->step = 1; ctrl->default_value = 128; ctrl->flags = 0; break; case V4L2_CID_CONTRAST: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Contrast", sizeof(ctrl->name)); ctrl->minimum = 0; ctrl->maximum = 255; ctrl->step = 1; ctrl->default_value = 128; ctrl->flags = 0; break; case V4L2_CID_SATURATION: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Saturation", sizeof(ctrl->name)); ctrl->minimum = 0; ctrl->maximum = 255; ctrl->step = 1; ctrl->default_value = 128; ctrl->flags = 0; break; case V4L2_CID_HUE: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Hue", sizeof(ctrl->name)); ctrl->minimum = 0; ctrl->maximum = 255; ctrl->step = 1; ctrl->default_value = 128; ctrl->flags = 0; break; } break; } case VIDIOC_S_CTRL: { struct v4l2_control *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: if (ctrl->value > 255) dec->brightness = 255; else if (ctrl->value < 0) dec->brightness = 0; else dec->brightness = ctrl->value; write_reg(client, 0x12, dec->brightness, dec->channel); break; case V4L2_CID_CONTRAST: if (ctrl->value > 255) dec->contrast = 255; else if (ctrl->value < 0) dec->contrast = 0; else dec->contrast = ctrl->value; write_reg(client, 0x11, dec->contrast, dec->channel); break; case V4L2_CID_SATURATION: if (ctrl->value > 255) dec->saturation = 255; else if (ctrl->value < 0) dec->saturation = 0; else dec->saturation = ctrl->value; write_reg(client, 0x10, dec->saturation, dec->channel); break; case V4L2_CID_HUE: if (ctrl->value > 255) dec->hue = 255; else if (ctrl->value < 0) dec->hue = 0; else dec->hue = ctrl->value; write_reg(client, 0x0f, dec->hue, dec->channel); break; } break; } case VIDIOC_G_CTRL: { struct v4l2_control *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: ctrl->value = dec->brightness; break; case V4L2_CID_CONTRAST: ctrl->value = dec->contrast; break; case V4L2_CID_SATURATION: ctrl->value = dec->saturation; break; case V4L2_CID_HUE: ctrl->value = dec->hue; break; } break; } default: break; } return 0; }
static int s2250_detect(struct i2c_adapter *adapter, int addr, int kind) { struct i2c_client *client; struct s2250 *dec; u8 *data; struct go7007 *go = i2c_get_adapdata(adapter); struct go7007_usb *usb = go->hpi_context; client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); if (client == NULL) return -ENOMEM; memcpy(client, &s2250_client_templ, sizeof(s2250_client_templ)); client->adapter = adapter; dec = kmalloc(sizeof(struct s2250), GFP_KERNEL); if (dec == NULL) { kfree(client); return -ENOMEM; } dec->std = V4L2_STD_NTSC; dec->brightness = 50; dec->contrast = 50; dec->saturation = 50; dec->hue = 0; client->addr = TLV320_ADDRESS; i2c_set_clientdata(client, dec); printk(KERN_DEBUG "s2250: initializing video decoder on %s\n", adapter->name); /* initialize the audio */ client->addr = TLV320_ADDRESS; if (write_regs(client, aud_regs) < 0) { printk(KERN_ERR "s2250: error initializing audio\n"); kfree(client); kfree(dec); return 0; } client->addr = S2250_VIDDEC; i2c_set_clientdata(client, dec); if (write_regs(client, vid_regs) < 0) { printk(KERN_ERR "s2250: error initializing decoder\n"); kfree(client); kfree(dec); return 0; } if (write_regs_fp(client, vid_regs_fp) < 0) { printk(KERN_ERR "s2250: error initializing decoder\n"); kfree(client); kfree(dec); return 0; } /* set default channel */ /* composite */ write_reg_fp(client, 0x20, 0x020 | 1); write_reg_fp(client, 0x21, 0x662); write_reg_fp(client, 0x140, 0x060); /* set default audio input */ dec->audio_input = 0; write_reg(client, 0x08, 0x02); /* Line In */ if (down_interruptible(&usb->i2c_lock) == 0) { data = kzalloc(16, GFP_KERNEL); if (data != NULL) { int rc; rc = go7007_usb_vendor_request(go, 0x41, 0, 0, data, 16, 1); if (rc > 0) { u8 mask; data[0] = 0; mask = 1<<5; data[0] &= ~mask; data[1] |= mask; go7007_usb_vendor_request(go, 0x40, 0, (data[1]<<8) + data[1], data, 16, 0); } kfree(data); } up(&usb->i2c_lock); } i2c_attach_client(client); printk("s2250: initialized successfully\n"); return 0; }
static int s2250_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_client *audio; struct i2c_adapter *adapter = client->adapter; struct s2250 *dec; u8 *data; struct go7007 *go = i2c_get_adapdata(adapter); struct go7007_usb *usb = go->hpi_context; audio = i2c_new_dummy(adapter, TLV320_ADDRESS >> 1); if (audio == NULL) return -ENOMEM; dec = kmalloc(sizeof(struct s2250), GFP_KERNEL); if (dec == NULL) { i2c_unregister_device(audio); return -ENOMEM; } dec->std = V4L2_STD_NTSC; dec->brightness = 50; dec->contrast = 50; dec->saturation = 50; dec->hue = 0; dec->audio = audio; i2c_set_clientdata(client, dec); printk(KERN_DEBUG "s2250: initializing video decoder on %s\n", adapter->name); /* initialize the audio */ if (write_regs(audio, aud_regs) < 0) { printk(KERN_ERR "s2250: error initializing audio\n"); i2c_unregister_device(audio); kfree(dec); return 0; } if (write_regs(client, vid_regs) < 0) { printk(KERN_ERR "s2250: error initializing decoder\n"); i2c_unregister_device(audio); kfree(dec); return 0; } if (write_regs_fp(client, vid_regs_fp) < 0) { printk(KERN_ERR "s2250: error initializing decoder\n"); i2c_unregister_device(audio); kfree(dec); return 0; } /* set default channel */ /* composite */ write_reg_fp(client, 0x20, 0x020 | 1); write_reg_fp(client, 0x21, 0x662); write_reg_fp(client, 0x140, 0x060); /* set default audio input */ dec->audio_input = 0; write_reg(client, 0x08, 0x02); /* Line In */ if (mutex_lock_interruptible(&usb->i2c_lock) == 0) { data = kzalloc(16, GFP_KERNEL); if (data != NULL) { int rc; rc = go7007_usb_vendor_request(go, 0x41, 0, 0, data, 16, 1); if (rc > 0) { u8 mask; data[0] = 0; mask = 1<<5; data[0] &= ~mask; data[1] |= mask; go7007_usb_vendor_request(go, 0x40, 0, (data[1]<<8) + data[1], data, 16, 0); } kfree(data); } mutex_unlock(&usb->i2c_lock); } printk("s2250: initialized successfully\n"); return 0; }
static int wis_saa7115_command(struct i2c_client *client, unsigned int cmd, void *arg) { struct wis_saa7115 *dec = i2c_get_clientdata(client); switch (cmd) { case VIDIOC_S_INPUT: { int *input = arg; i2c_smbus_write_byte_data(client, 0x02, 0xC0 | *input); i2c_smbus_write_byte_data(client, 0x09, *input < 6 ? 0x40 : 0xC0); break; } case DECODER_SET_RESOLUTION: { struct video_decoder_resolution *res = arg; /* Course-grained scaler */ int h_integer_scaler = res->width < 704 ? 704 / res->width : 1; /* Fine-grained scaler to take care of remainder */ int h_scaling_increment = (704 / h_integer_scaler) * 1024 / res->width; /* Fine-grained scaler only */ int v_scaling_increment = (dec->norm & V4L2_STD_NTSC ? 240 : 288) * 1024 / res->height; u8 regs[] = { 0x88, 0xc0, 0x9c, res->width & 0xff, 0x9d, res->width >> 8, 0x9e, res->height & 0xff, 0x9f, res->height >> 8, 0xa0, h_integer_scaler, 0xa1, 1, 0xa2, 1, 0xa8, h_scaling_increment & 0xff, 0xa9, h_scaling_increment >> 8, 0xac, (h_scaling_increment / 2) & 0xff, 0xad, (h_scaling_increment / 2) >> 8, 0xb0, v_scaling_increment & 0xff, 0xb1, v_scaling_increment >> 8, 0xb2, v_scaling_increment & 0xff, 0xb3, v_scaling_increment >> 8, 0xcc, res->width & 0xff, 0xcd, res->width >> 8, 0xce, res->height & 0xff, 0xcf, res->height >> 8, 0xd0, h_integer_scaler, 0xd1, 1, 0xd2, 1, 0xd8, h_scaling_increment & 0xff, 0xd9, h_scaling_increment >> 8, 0xdc, (h_scaling_increment / 2) & 0xff, 0xdd, (h_scaling_increment / 2) >> 8, 0xe0, v_scaling_increment & 0xff, 0xe1, v_scaling_increment >> 8, 0xe2, v_scaling_increment & 0xff, 0xe3, v_scaling_increment >> 8, 0x88, 0xf0, 0, 0, }; write_regs(client, regs); break; } case VIDIOC_S_STD: { v4l2_std_id *input = arg; u8 regs[] = { 0x88, 0xc0, 0x98, *input & V4L2_STD_NTSC ? 0x12 : 0x16, 0x9a, *input & V4L2_STD_NTSC ? 0xf2 : 0x20, 0x9b, *input & V4L2_STD_NTSC ? 0x00 : 0x01, 0xc8, *input & V4L2_STD_NTSC ? 0x12 : 0x16, 0xca, *input & V4L2_STD_NTSC ? 0xf2 : 0x20, 0xcb, *input & V4L2_STD_NTSC ? 0x00 : 0x01, 0x88, 0xf0, 0x30, *input & V4L2_STD_NTSC ? 0x66 : 0x00, 0x31, *input & V4L2_STD_NTSC ? 0x90 : 0xe0, 0, 0, }; write_regs(client, regs); dec->norm = *input; break; } case VIDIOC_QUERYCTRL: { struct v4l2_queryctrl *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Brightness", sizeof(ctrl->name)); ctrl->minimum = 0; ctrl->maximum = 255; ctrl->step = 1; ctrl->default_value = 128; ctrl->flags = 0; break; case V4L2_CID_CONTRAST: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Contrast", sizeof(ctrl->name)); ctrl->minimum = 0; ctrl->maximum = 127; ctrl->step = 1; ctrl->default_value = 64; ctrl->flags = 0; break; case V4L2_CID_SATURATION: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Saturation", sizeof(ctrl->name)); ctrl->minimum = 0; ctrl->maximum = 127; ctrl->step = 1; ctrl->default_value = 64; ctrl->flags = 0; break; case V4L2_CID_HUE: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Hue", sizeof(ctrl->name)); ctrl->minimum = -128; ctrl->maximum = 127; ctrl->step = 1; ctrl->default_value = 0; ctrl->flags = 0; break; } break; } case VIDIOC_S_CTRL: { struct v4l2_control *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: if (ctrl->value > 255) dec->brightness = 255; else if (ctrl->value < 0) dec->brightness = 0; else dec->brightness = ctrl->value; write_reg(client, 0x0a, dec->brightness); break; case V4L2_CID_CONTRAST: if (ctrl->value > 127) dec->contrast = 127; else if (ctrl->value < 0) dec->contrast = 0; else dec->contrast = ctrl->value; write_reg(client, 0x0b, dec->contrast); break; case V4L2_CID_SATURATION: if (ctrl->value > 127) dec->saturation = 127; else if (ctrl->value < 0) dec->saturation = 0; else dec->saturation = ctrl->value; write_reg(client, 0x0c, dec->saturation); break; case V4L2_CID_HUE: if (ctrl->value > 127) dec->hue = 127; else if (ctrl->value < -128) dec->hue = -128; else dec->hue = ctrl->value; write_reg(client, 0x0d, dec->hue); break; } break; } case VIDIOC_G_CTRL: { struct v4l2_control *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: ctrl->value = dec->brightness; break; case V4L2_CID_CONTRAST: ctrl->value = dec->contrast; break; case V4L2_CID_SATURATION: ctrl->value = dec->saturation; break; case V4L2_CID_HUE: ctrl->value = dec->hue; break; } break; } default: break; } return 0; }
int init_vda(int vdaccir, int vdanorm, int vdamaster) { if ((vdaccir == VIDEO_MODE_CCIR656) && (vdanorm == VIDEO_NORM_PAL)) { if (write_regs((unsigned char*)&init_656_PAL, sizeof(init_656_PAL)) != 0) { goto err_out; } } else if ((vdaccir == VIDEO_MODE_CCIR656) && (vdanorm == VIDEO_NORM_NTSC)) { if (write_regs((unsigned char*)&init_656_NTSC, sizeof(init_656_NTSC)) != 0) { goto err_out; } } else if ((vdaccir == VIDEO_MODE_CCIR601) && (vdanorm == VIDEO_NORM_PAL)) { if (vdamaster == VIDEO_MODE_MASTER) { init_601_PAL[15] |= VIDEO_MODE_MASTER; } else if (vdamaster == VIDEO_MODE_SLAVER) { init_601_PAL[15] &= ~VIDEO_MODE_MASTER; } if (write_regs((unsigned char*)&init_601_PAL, sizeof(init_601_PAL)) != 0) { goto err_out; } } else if ((vdaccir == VIDEO_MODE_CCIR601) && (vdanorm == VIDEO_NORM_NTSC)) { if (vdamaster == VIDEO_MODE_MASTER) { init_601_NTSC[15] |= VIDEO_MODE_MASTER; } if (vdamaster == VIDEO_MODE_SLAVER) { init_601_NTSC[15] &= ~VIDEO_MODE_MASTER; } if (write_regs((unsigned char*)&init_601_NTSC, sizeof(init_601_NTSC)) != 0) { goto err_out; } } if (vdaccir == VIDEO_MODE_CCIR656) { I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_656 | TR0RST)); I2CWriteByte(I2C_ADV7179, 0x07, TR0MODE_656); } else if (vdaccir == VIDEO_MODE_CCIR601) { if (vdamaster == VIDEO_MODE_MASTER) { I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | TR0RST | VIDEO_MODE_MASTER)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | VIDEO_MODE_MASTER)); } else { I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | TR0RST)); I2CWriteByte(I2C_ADV7179, 0x07, TR0MODE_601); } } return (0); err_out: printk("err_out\n"); return -1; }
static int wis_tw9903_command(struct i2c_client *client, unsigned int cmd, void *arg) { struct wis_tw9903 *dec = i2c_get_clientdata(client); switch (cmd) { case VIDIOC_S_INPUT: { int *input = arg; i2c_smbus_write_byte_data(client, 0x02, 0x40 | (*input << 1)); break; } case VIDIOC_S_STD: { v4l2_std_id *input = arg; u8 regs[] = { 0x05, *input & V4L2_STD_NTSC ? 0x80 : 0x00, 0x07, *input & V4L2_STD_NTSC ? 0x02 : 0x12, 0x08, *input & V4L2_STD_NTSC ? 0x14 : 0x18, 0x09, *input & V4L2_STD_NTSC ? 0xf0 : 0x20, 0, 0, }; write_regs(client, regs); dec->norm = *input; break; } case VIDIOC_QUERYCTRL: { struct v4l2_queryctrl *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Brightness", sizeof(ctrl->name)); ctrl->minimum = -128; ctrl->maximum = 127; ctrl->step = 1; ctrl->default_value = 0x00; ctrl->flags = 0; break; case V4L2_CID_CONTRAST: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Contrast", sizeof(ctrl->name)); ctrl->minimum = 0; ctrl->maximum = 255; ctrl->step = 1; ctrl->default_value = 0x60; ctrl->flags = 0; break; case V4L2_CID_HUE: ctrl->type = V4L2_CTRL_TYPE_INTEGER; strncpy(ctrl->name, "Hue", sizeof(ctrl->name)); ctrl->minimum = -128; ctrl->maximum = 127; ctrl->step = 1; ctrl->default_value = 0; ctrl->flags = 0; break; } break; } case VIDIOC_S_CTRL: { struct v4l2_control *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: if (ctrl->value > 127) dec->brightness = 127; else if (ctrl->value < -128) dec->brightness = -128; else dec->brightness = ctrl->value; write_reg(client, 0x10, dec->brightness); break; case V4L2_CID_CONTRAST: if (ctrl->value > 255) dec->contrast = 255; else if (ctrl->value < 0) dec->contrast = 0; else dec->contrast = ctrl->value; write_reg(client, 0x11, dec->contrast); break; case V4L2_CID_HUE: if (ctrl->value > 127) dec->hue = 127; else if (ctrl->value < -128) dec->hue = -128; else dec->hue = ctrl->value; write_reg(client, 0x15, dec->hue); break; } break; } case VIDIOC_G_CTRL: { struct v4l2_control *ctrl = arg; switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: ctrl->value = dec->brightness; break; case V4L2_CID_CONTRAST: ctrl->value = dec->contrast; break; case V4L2_CID_HUE: ctrl->value = dec->hue; break; } break; } default: break; } return 0; }
/* * adv7179 ioctl routine. * @param inode: pointer of the node; * @param file: pointer of the file; * * @param cmd: command from the app: * ENCODER_SET_NORM(2):set adv7179's work mode. * * @param arg:arg from app layer. * * @return value:0-- set success; -1-- set error. * */ static long adv7179_ioctl(struct file* file, unsigned int cmd, unsigned long arg) { switch (cmd) { case ENCODER_SET_NORM: { int iarg = (int) arg; switch (iarg) { case VIDEO_MODE_656_PAL: write_regs((unsigned char*)&init_656_PAL, sizeof(init_656_PAL)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_656 | TR0RST)); I2CWriteByte(I2C_ADV7179, 0x07, TR0MODE_656); break; case VIDEO_MODE_656_NTSC: write_regs((unsigned char*)&init_656_NTSC, sizeof(init_656_NTSC)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_656 | TR0RST)); I2CWriteByte(I2C_ADV7179, 0x07, TR0MODE_656); break; case VIDEO_MODE_601_PAL_MASTER: init_601_PAL[15] |= VIDEO_MODE_MASTER; write_regs((unsigned char*)&init_601_PAL, sizeof(init_601_PAL)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | TR0RST | VIDEO_MODE_MASTER)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | VIDEO_MODE_MASTER)); break; case VIDEO_MODE_601_NTSC_MASTER: init_601_NTSC[15] |= VIDEO_MODE_MASTER; write_regs((unsigned char*)&init_601_NTSC, sizeof(init_601_NTSC)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | TR0RST | VIDEO_MODE_MASTER)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | VIDEO_MODE_MASTER)); break; case VIDEO_MODE_601_PAL_SLAVER: init_601_PAL[15] &= ~VIDEO_MODE_MASTER; write_regs((unsigned char*)&init_601_PAL, sizeof(init_601_PAL)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | TR0RST)); I2CWriteByte(I2C_ADV7179, 0x07, TR0MODE_601); break; case VIDEO_MODE_601_NTSC_SLAVER: init_601_NTSC[15] &= ~VIDEO_MODE_MASTER; write_regs((unsigned char*)&init_601_NTSC, sizeof(init_601_NTSC)); I2CWriteByte(I2C_ADV7179, 0x07, (TR0MODE_601 | TR0RST)); I2CWriteByte(I2C_ADV7179, 0x07, TR0MODE_601); break; default: return -1; } } break; default: return -1; } return 0; }