/*! * PrpENC enable channel setup function * * @param cam struct cam_data * mxc capture instance * * @return status */ static int prp_enc_setup(cam_data *cam) { ipu_channel_params_t enc; int err = 0; dma_addr_t dummy = cam->dummy_frame.buffer.m.offset; #ifdef CONFIG_MXC_MIPI_CSI2 void *mipi_csi2_info; int ipu_id; int csi_id; #endif CAMERA_TRACE("In prp_enc_setup\n"); if (!cam) { printk(KERN_ERR "cam private is NULL\n"); return -ENXIO; } memset(&enc, 0, sizeof(ipu_channel_params_t)); ipu_csi_get_window_size(cam->ipu, &enc.csi_prp_enc_mem.in_width, &enc.csi_prp_enc_mem.in_height, cam->csi); enc.csi_prp_enc_mem.in_pixel_fmt = IPU_PIX_FMT_UYVY; enc.csi_prp_enc_mem.out_width = cam->v2f.fmt.pix.width; enc.csi_prp_enc_mem.out_height = cam->v2f.fmt.pix.height; enc.csi_prp_enc_mem.csi = cam->csi; if (cam->rotation >= IPU_ROTATE_90_RIGHT) { enc.csi_prp_enc_mem.out_width = cam->v2f.fmt.pix.height; enc.csi_prp_enc_mem.out_height = cam->v2f.fmt.pix.width; } if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV420) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_YUV420P; pr_info("YUV420\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_YVU420) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_YVU420P; pr_info("YVU420\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_YUV422P; pr_info("YUV422P\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_YUYV; pr_info("YUYV\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_UYVY) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_UYVY; pr_info("UYVY\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_NV12) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_NV12; pr_info("NV12\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_BGR24) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_BGR24; pr_info("BGR24\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB24) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_RGB24; pr_info("RGB24\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB565) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_RGB565; pr_info("RGB565\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_BGR32) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_BGR32; pr_info("BGR32\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB32) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_RGB32; pr_info("RGB32\n"); } else { printk(KERN_ERR "format not supported\n"); return -EINVAL; } #ifdef CONFIG_MXC_MIPI_CSI2 mipi_csi2_info = mipi_csi2_get_info(); if (mipi_csi2_info) { if (mipi_csi2_get_status(mipi_csi2_info)) { ipu_id = mipi_csi2_get_bind_ipu(mipi_csi2_info); csi_id = mipi_csi2_get_bind_csi(mipi_csi2_info); if (cam->ipu == ipu_get_soc(ipu_id) && cam->csi == csi_id) { enc.csi_prp_enc_mem.mipi_en = true; enc.csi_prp_enc_mem.mipi_vc = mipi_csi2_get_virtual_channel(mipi_csi2_info); enc.csi_prp_enc_mem.mipi_id = mipi_csi2_get_datatype(mipi_csi2_info); mipi_csi2_pixelclk_enable(mipi_csi2_info); } else { enc.csi_prp_enc_mem.mipi_en = false; enc.csi_prp_enc_mem.mipi_vc = 0; enc.csi_prp_enc_mem.mipi_id = 0; } } else { enc.csi_prp_enc_mem.mipi_en = false; enc.csi_prp_enc_mem.mipi_vc = 0; enc.csi_prp_enc_mem.mipi_id = 0; } } #endif err = ipu_init_channel(cam->ipu, CSI_PRP_ENC_MEM, &enc); if (err != 0) { printk(KERN_ERR "ipu_init_channel %d\n", err); return err; } grotation = cam->rotation; if (cam->rotation >= IPU_ROTATE_90_RIGHT) { if (cam->rot_enc_bufs_vaddr[0]) { dma_free_coherent(0, cam->rot_enc_buf_size[0], cam->rot_enc_bufs_vaddr[0], cam->rot_enc_bufs[0]); } if (cam->rot_enc_bufs_vaddr[1]) { dma_free_coherent(0, cam->rot_enc_buf_size[1], cam->rot_enc_bufs_vaddr[1], cam->rot_enc_bufs[1]); } cam->rot_enc_buf_size[0] = PAGE_ALIGN(cam->v2f.fmt.pix.sizeimage); cam->rot_enc_bufs_vaddr[0] = (void *)dma_alloc_coherent(0, cam->rot_enc_buf_size[0], &cam->rot_enc_bufs[0], GFP_DMA | GFP_KERNEL); if (!cam->rot_enc_bufs_vaddr[0]) { printk(KERN_ERR "alloc enc_bufs0\n"); return -ENOMEM; } cam->rot_enc_buf_size[1] = PAGE_ALIGN(cam->v2f.fmt.pix.sizeimage); cam->rot_enc_bufs_vaddr[1] = (void *)dma_alloc_coherent(0, cam->rot_enc_buf_size[1], &cam->rot_enc_bufs[1], GFP_DMA | GFP_KERNEL); if (!cam->rot_enc_bufs_vaddr[1]) { dma_free_coherent(0, cam->rot_enc_buf_size[0], cam->rot_enc_bufs_vaddr[0], cam->rot_enc_bufs[0]); cam->rot_enc_bufs_vaddr[0] = NULL; cam->rot_enc_bufs[0] = 0; printk(KERN_ERR "alloc enc_bufs1\n"); return -ENOMEM; } err = ipu_init_channel_buffer(cam->ipu, CSI_PRP_ENC_MEM, IPU_OUTPUT_BUFFER, enc.csi_prp_enc_mem.out_pixel_fmt, enc.csi_prp_enc_mem.out_width, enc.csi_prp_enc_mem.out_height, enc.csi_prp_enc_mem.out_width, IPU_ROTATE_NONE, cam->rot_enc_bufs[0], cam->rot_enc_bufs[1], 0, 0, 0); if (err != 0) { printk(KERN_ERR "CSI_PRP_ENC_MEM err\n"); return err; } err = ipu_init_channel(cam->ipu, MEM_ROT_ENC_MEM, NULL); if (err != 0) { printk(KERN_ERR "MEM_ROT_ENC_MEM channel err\n"); return err; } err = ipu_init_channel_buffer(cam->ipu, MEM_ROT_ENC_MEM, IPU_INPUT_BUFFER, enc.csi_prp_enc_mem.out_pixel_fmt, enc.csi_prp_enc_mem.out_width, enc.csi_prp_enc_mem.out_height, enc.csi_prp_enc_mem.out_width, cam->rotation, cam->rot_enc_bufs[0], cam->rot_enc_bufs[1], 0, 0, 0); if (err != 0) { printk(KERN_ERR "MEM_ROT_ENC_MEM input buffer\n"); return err; } err = ipu_init_channel_buffer(cam->ipu, MEM_ROT_ENC_MEM, IPU_OUTPUT_BUFFER, enc.csi_prp_enc_mem.out_pixel_fmt, enc.csi_prp_enc_mem.out_height, enc.csi_prp_enc_mem.out_width, cam->v2f.fmt.pix.bytesperline / bytes_per_pixel(enc.csi_prp_enc_mem. out_pixel_fmt), IPU_ROTATE_NONE, dummy, dummy, 0, cam->offset.u_offset, cam->offset.v_offset); if (err != 0) { printk(KERN_ERR "MEM_ROT_ENC_MEM output buffer\n"); return err; } err = ipu_link_channels(cam->ipu, CSI_PRP_ENC_MEM, MEM_ROT_ENC_MEM); if (err < 0) { printk(KERN_ERR "link CSI_PRP_ENC_MEM-MEM_ROT_ENC_MEM\n"); return err; } err = ipu_enable_channel(cam->ipu, CSI_PRP_ENC_MEM); if (err < 0) { printk(KERN_ERR "ipu_enable_channel CSI_PRP_ENC_MEM\n"); return err; } err = ipu_enable_channel(cam->ipu, MEM_ROT_ENC_MEM); if (err < 0) { printk(KERN_ERR "ipu_enable_channel MEM_ROT_ENC_MEM\n"); return err; } ipu_select_buffer(cam->ipu, CSI_PRP_ENC_MEM, IPU_OUTPUT_BUFFER, 0); ipu_select_buffer(cam->ipu, CSI_PRP_ENC_MEM, IPU_OUTPUT_BUFFER, 1); } else { err = ipu_init_channel_buffer(cam->ipu, CSI_PRP_ENC_MEM, IPU_OUTPUT_BUFFER, enc.csi_prp_enc_mem.out_pixel_fmt, enc.csi_prp_enc_mem.out_width, enc.csi_prp_enc_mem.out_height, cam->v2f.fmt.pix.bytesperline / bytes_per_pixel(enc.csi_prp_enc_mem. out_pixel_fmt), cam->rotation, dummy, dummy, 0, cam->offset.u_offset, cam->offset.v_offset); if (err != 0) { printk(KERN_ERR "CSI_PRP_ENC_MEM output buffer\n"); return err; } err = ipu_enable_channel(cam->ipu, CSI_PRP_ENC_MEM); if (err < 0) { printk(KERN_ERR "ipu_enable_channel CSI_PRP_ENC_MEM\n"); return err; } } return err; }
static int mxc_ipu_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int ret = 0; switch (cmd) { case IPU_INIT_CHANNEL: { ipu_channel_parm parm; if (copy_from_user (&parm, (ipu_channel_parm *) arg, sizeof(ipu_channel_parm))) { return -EFAULT; } if (!parm.flag) { ret = ipu_init_channel(parm.channel, &parm.params); } else { ret = ipu_init_channel(parm.channel, NULL); } } break; case IPU_UNINIT_CHANNEL: { ipu_channel_t ch; int __user *argp = (void __user *)arg; if (get_user(ch, argp)) return -EFAULT; ipu_uninit_channel(ch); } break; case IPU_INIT_CHANNEL_BUFFER: { ipu_channel_buf_parm parm; if (copy_from_user (&parm, (ipu_channel_buf_parm *) arg, sizeof(ipu_channel_buf_parm))) { return -EFAULT; } ret = ipu_init_channel_buffer(parm.channel, parm.type, parm.pixel_fmt, parm.width, parm.height, parm.stride, parm.rot_mode, parm.phyaddr_0, parm.phyaddr_1, parm.u_offset, parm.v_offset); } break; case IPU_UPDATE_CHANNEL_BUFFER: { ipu_channel_buf_parm parm; if (copy_from_user (&parm, (ipu_channel_buf_parm *) arg, sizeof(ipu_channel_buf_parm))) { return -EFAULT; } if ((parm.phyaddr_0 != (dma_addr_t) NULL) && (parm.phyaddr_1 == (dma_addr_t) NULL)) { ret = ipu_update_channel_buffer(parm.channel, parm.type, parm.bufNum, parm.phyaddr_0); } else if ((parm.phyaddr_0 == (dma_addr_t) NULL) && (parm.phyaddr_1 != (dma_addr_t) NULL)) { ret = ipu_update_channel_buffer(parm.channel, parm.type, parm.bufNum, parm.phyaddr_1); } else { ret = -1; } } break; case IPU_SELECT_CHANNEL_BUFFER: { ipu_channel_buf_parm parm; if (copy_from_user (&parm, (ipu_channel_buf_parm *) arg, sizeof(ipu_channel_buf_parm))) { return -EFAULT; } ret = ipu_select_buffer(parm.channel, parm.type, parm.bufNum); } break; case IPU_LINK_CHANNELS: { ipu_channel_link link; if (copy_from_user (&link, (ipu_channel_link *) arg, sizeof(ipu_channel_link))) { return -EFAULT; } ret = ipu_link_channels(link.src_ch, link.dest_ch); } break; case IPU_UNLINK_CHANNELS: { ipu_channel_link link; if (copy_from_user (&link, (ipu_channel_link *) arg, sizeof(ipu_channel_link))) { return -EFAULT; } ret = ipu_unlink_channels(link.src_ch, link.dest_ch); } break; case IPU_ENABLE_CHANNEL: { ipu_channel_t ch; int __user *argp = (void __user *)arg; if (get_user(ch, argp)) return -EFAULT; ipu_enable_channel(ch); } break; case IPU_DISABLE_CHANNEL: { ipu_channel_info info; if (copy_from_user (&info, (ipu_channel_info *) arg, sizeof(ipu_channel_info))) { return -EFAULT; } ret = ipu_disable_channel(info.channel, info.stop); } break; case IPU_ENABLE_IRQ: { uint32_t irq; int __user *argp = (void __user *)arg; if (get_user(irq, argp)) return -EFAULT; ipu_enable_irq(irq); } break; case IPU_DISABLE_IRQ: { uint32_t irq; int __user *argp = (void __user *)arg; if (get_user(irq, argp)) return -EFAULT; ipu_disable_irq(irq); } break; case IPU_CLEAR_IRQ: { uint32_t irq; int __user *argp = (void __user *)arg; if (get_user(irq, argp)) return -EFAULT; ipu_clear_irq(irq); } break; case IPU_FREE_IRQ: { ipu_irq_info info; if (copy_from_user (&info, (ipu_irq_info *) arg, sizeof(ipu_irq_info))) { return -EFAULT; } ipu_free_irq(info.irq, info.dev_id); } break; case IPU_REQUEST_IRQ_STATUS: { uint32_t irq; int __user *argp = (void __user *)arg; if (get_user(irq, argp)) return -EFAULT; ret = ipu_get_irq_status(irq); } break; case IPU_SDC_INIT_PANEL: { ipu_sdc_panel_info sinfo; if (copy_from_user (&sinfo, (ipu_sdc_panel_info *) arg, sizeof(ipu_sdc_panel_info))) { return -EFAULT; } ret = ipu_sdc_init_panel(sinfo.panel, sinfo.pixel_clk, sinfo.width, sinfo.height, sinfo.pixel_fmt, sinfo.hStartWidth, sinfo.hSyncWidth, sinfo.hEndWidth, sinfo.vStartWidth, sinfo.vSyncWidth, sinfo.vEndWidth, sinfo.signal); } break; case IPU_SDC_SET_WIN_POS: { ipu_sdc_window_pos pos; if (copy_from_user (&pos, (ipu_sdc_window_pos *) arg, sizeof(ipu_sdc_window_pos))) { return -EFAULT; } ret = ipu_sdc_set_window_pos(pos.channel, pos.x_pos, pos.y_pos); } break; case IPU_SDC_SET_GLOBAL_ALPHA: { ipu_sdc_global_alpha g; if (copy_from_user (&g, (ipu_sdc_global_alpha *) arg, sizeof(ipu_sdc_global_alpha))) { return -EFAULT; } ret = ipu_sdc_set_global_alpha(g.enable, g.alpha); } break; case IPU_SDC_SET_COLOR_KEY: { ipu_sdc_color_key c; if (copy_from_user (&c, (ipu_sdc_color_key *) arg, sizeof(ipu_sdc_color_key))) { return -EFAULT; } ret = ipu_sdc_set_color_key(c.channel, c.enable, c.colorKey); } break; case IPU_SDC_SET_BRIGHTNESS: { uint8_t b; int __user *argp = (void __user *)arg; if (get_user(b, argp)) return -EFAULT; ret = ipu_sdc_set_brightness(b); } break; case IPU_REGISTER_GENERIC_ISR: { ipu_event_info info; if (copy_from_user (&info, (ipu_event_info *) arg, sizeof(ipu_event_info))) { return -EFAULT; } ret = ipu_request_irq(info.irq, mxc_ipu_generic_handler, 0, "video_sink", info.dev); } break; case IPU_GET_EVENT: /* User will have to allocate event_type structure and pass the pointer in arg */ { event_type ev; int r = -1; r = get_events(&ev); if (r == -1) { wait_event_interruptible(waitq, (pending_events != 0)); r = get_events(&ev); } ret = -1; if (r == 0) { if (!copy_to_user((event_type *) arg, &ev, sizeof(event_type))) { ret = 0; } } } break; case IPU_ADC_WRITE_TEMPLATE: { ipu_adc_template temp; if (copy_from_user (&temp, (ipu_adc_template *) arg, sizeof(temp))) { return -EFAULT; } ret = ipu_adc_write_template(temp.disp, temp.pCmd, temp.write); } break; case IPU_ADC_UPDATE: { ipu_adc_update update; if (copy_from_user (&update, (ipu_adc_update *) arg, sizeof(update))) { return -EFAULT; } ret = ipu_adc_set_update_mode(update.channel, update.mode, update.refresh_rate, update.addr, update.size); } break; case IPU_ADC_SNOOP: { ipu_adc_snoop snoop; if (copy_from_user (&snoop, (ipu_adc_snoop *) arg, sizeof(snoop))) { return -EFAULT; } ret = ipu_adc_get_snooping_status(snoop.statl, snoop.stath); } break; case IPU_ADC_CMD: { ipu_adc_cmd cmd; if (copy_from_user (&cmd, (ipu_adc_cmd *) arg, sizeof(cmd))) { return -EFAULT; } ret = ipu_adc_write_cmd(cmd.disp, cmd.type, cmd.cmd, cmd.params, cmd.numParams); } break; case IPU_ADC_INIT_PANEL: { ipu_adc_panel panel; if (copy_from_user (&panel, (ipu_adc_panel *) arg, sizeof(panel))) { return -EFAULT; } ret = ipu_adc_init_panel(panel.disp, panel.width, panel.height, panel.pixel_fmt, panel.stride, panel.signal, panel.addr, panel.vsync_width, panel.mode); } break; case IPU_ADC_IFC_TIMING: { ipu_adc_ifc_timing t; if (copy_from_user (&t, (ipu_adc_ifc_timing *) arg, sizeof(t))) { return -EFAULT; } ret = ipu_adc_init_ifc_timing(t.disp, t.read, t.cycle_time, t.up_time, t.down_time, t.read_latch_time, t.pixel_clk); } break; case IPU_CSI_INIT_INTERFACE: { ipu_csi_interface c; if (copy_from_user (&c, (ipu_csi_interface *) arg, sizeof(c))) return -EFAULT; ret = ipu_csi_init_interface(c.width, c.height, c.pixel_fmt, c.signal); } break; case IPU_CSI_ENABLE_MCLK: { ipu_csi_mclk m; if (copy_from_user(&m, (ipu_csi_mclk *) arg, sizeof(m))) return -EFAULT; ret = ipu_csi_enable_mclk(m.src, m.flag, m.wait); } break; case IPU_CSI_READ_MCLK_FLAG: { ret = ipu_csi_read_mclk_flag(); } break; case IPU_CSI_FLASH_STROBE: { bool strobe; int __user *argp = (void __user *)arg; if (get_user(strobe, argp)) return -EFAULT; ipu_csi_flash_strobe(strobe); } break; case IPU_CSI_GET_WIN_SIZE: { ipu_csi_window_size w; ipu_csi_get_window_size(&w.width, &w.height); if (copy_to_user ((ipu_csi_window_size *) arg, &w, sizeof(w))) return -EFAULT; } break; case IPU_CSI_SET_WIN_SIZE: { ipu_csi_window_size w; if (copy_from_user (&w, (ipu_csi_window_size *) arg, sizeof(w))) return -EFAULT; ipu_csi_set_window_size(w.width, w.height); } break; case IPU_CSI_SET_WINDOW: { ipu_csi_window p; if (copy_from_user (&p, (ipu_csi_window *) arg, sizeof(p))) return -EFAULT; ipu_csi_set_window_pos(p.left, p.top); } break; case IPU_PF_SET_PAUSE_ROW: { uint32_t p; int __user *argp = (void __user *)arg; if (get_user(p, argp)) return -EFAULT; ret = ipu_pf_set_pause_row(p); } break; default: break; } return ret; }
/*! * PrpENC enable channel setup function * * @param cam struct cam_data * mxc capture instance * * @return status */ static int prp_enc_setup(cam_data *cam) { ipu_channel_params_t enc; int err = 0; dma_addr_t dummy = 0xdeadbeaf; CAMERA_TRACE("In prp_enc_setup\n"); if (!cam) { printk(KERN_ERR "cam private is NULL\n"); return -ENXIO; } memset(&enc, 0, sizeof(ipu_channel_params_t)); ipu_csi_get_window_size(&enc.csi_prp_enc_mem.in_width, &enc.csi_prp_enc_mem.in_height, cam->csi); enc.csi_prp_enc_mem.in_pixel_fmt = IPU_PIX_FMT_UYVY; enc.csi_prp_enc_mem.out_width = cam->v2f.fmt.pix.width; enc.csi_prp_enc_mem.out_height = cam->v2f.fmt.pix.height; enc.csi_prp_enc_mem.csi = cam->csi; if (cam->rotation >= IPU_ROTATE_90_RIGHT) { enc.csi_prp_enc_mem.out_width = cam->v2f.fmt.pix.height; enc.csi_prp_enc_mem.out_height = cam->v2f.fmt.pix.width; } if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV420) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_YUV420P; pr_info("YUV420\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV422P) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_YUV422P; pr_info("YUV422P\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_YUYV; pr_info("YUYV\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_UYVY) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_UYVY; pr_info("UYVY\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_NV12) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_NV12; pr_info("NV12\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_BGR24) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_BGR24; pr_info("BGR24\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB24) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_RGB24; pr_info("RGB24\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB565) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_RGB565; pr_info("RGB565\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_BGR32) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_BGR32; pr_info("BGR32\n"); } else if (cam->v2f.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB32) { enc.csi_prp_enc_mem.out_pixel_fmt = IPU_PIX_FMT_RGB32; pr_info("RGB32\n"); } else { printk(KERN_ERR "format not supported\n"); return -EINVAL; } err = ipu_init_channel(CSI_PRP_ENC_MEM, &enc); if (err != 0) { printk(KERN_ERR "ipu_init_channel %d\n", err); return err; } ipu_csi_enable_mclk_if(CSI_MCLK_ENC, cam->csi, true, true); grotation = cam->rotation; if (cam->rotation >= IPU_ROTATE_90_RIGHT) { if (cam->rot_enc_bufs_vaddr[0]) { dma_free_coherent(0, cam->rot_enc_buf_size[0], cam->rot_enc_bufs_vaddr[0], cam->rot_enc_bufs[0]); } if (cam->rot_enc_bufs_vaddr[1]) { dma_free_coherent(0, cam->rot_enc_buf_size[1], cam->rot_enc_bufs_vaddr[1], cam->rot_enc_bufs[1]); } cam->rot_enc_buf_size[0] = PAGE_ALIGN(cam->v2f.fmt.pix.sizeimage); cam->rot_enc_bufs_vaddr[0] = (void *)dma_alloc_coherent(0, cam->rot_enc_buf_size[0], &cam->rot_enc_bufs[0], GFP_DMA | GFP_KERNEL); if (!cam->rot_enc_bufs_vaddr[0]) { printk(KERN_ERR "alloc enc_bufs0\n"); return -ENOMEM; } cam->rot_enc_buf_size[1] = PAGE_ALIGN(cam->v2f.fmt.pix.sizeimage); cam->rot_enc_bufs_vaddr[1] = (void *)dma_alloc_coherent(0, cam->rot_enc_buf_size[1], &cam->rot_enc_bufs[1], GFP_DMA | GFP_KERNEL); if (!cam->rot_enc_bufs_vaddr[1]) { dma_free_coherent(0, cam->rot_enc_buf_size[0], cam->rot_enc_bufs_vaddr[0], cam->rot_enc_bufs[0]); cam->rot_enc_bufs_vaddr[0] = NULL; cam->rot_enc_bufs[0] = 0; printk(KERN_ERR "alloc enc_bufs1\n"); return -ENOMEM; } err = ipu_init_channel_buffer(CSI_PRP_ENC_MEM, IPU_OUTPUT_BUFFER, enc.csi_prp_enc_mem.out_pixel_fmt, enc.csi_prp_enc_mem.out_width, enc.csi_prp_enc_mem.out_height, enc.csi_prp_enc_mem.out_width, IPU_ROTATE_NONE, cam->rot_enc_bufs[0], cam->rot_enc_bufs[1], 0, 0, 0); if (err != 0) { printk(KERN_ERR "CSI_PRP_ENC_MEM err\n"); return err; } err = ipu_init_channel(MEM_ROT_ENC_MEM, NULL); if (err != 0) { printk(KERN_ERR "MEM_ROT_ENC_MEM channel err\n"); return err; } err = ipu_init_channel_buffer(MEM_ROT_ENC_MEM, IPU_INPUT_BUFFER, enc.csi_prp_enc_mem.out_pixel_fmt, enc.csi_prp_enc_mem.out_width, enc.csi_prp_enc_mem.out_height, enc.csi_prp_enc_mem.out_width, cam->rotation, cam->rot_enc_bufs[0], cam->rot_enc_bufs[1], 0, 0, 0); if (err != 0) { printk(KERN_ERR "MEM_ROT_ENC_MEM input buffer\n"); return err; } err = ipu_init_channel_buffer(MEM_ROT_ENC_MEM, IPU_OUTPUT_BUFFER, enc.csi_prp_enc_mem.out_pixel_fmt, enc.csi_prp_enc_mem.out_height, enc.csi_prp_enc_mem.out_width, cam->v2f.fmt.pix.bytesperline / bytes_per_pixel(enc.csi_prp_enc_mem. out_pixel_fmt), IPU_ROTATE_NONE, dummy, dummy, 0, cam->offset.u_offset, cam->offset.v_offset); if (err != 0) { printk(KERN_ERR "MEM_ROT_ENC_MEM output buffer\n"); return err; } err = ipu_link_channels(CSI_PRP_ENC_MEM, MEM_ROT_ENC_MEM); if (err < 0) { printk(KERN_ERR "link CSI_PRP_ENC_MEM-MEM_ROT_ENC_MEM\n"); return err; } err = ipu_enable_channel(CSI_PRP_ENC_MEM); if (err < 0) { printk(KERN_ERR "ipu_enable_channel CSI_PRP_ENC_MEM\n"); return err; } err = ipu_enable_channel(MEM_ROT_ENC_MEM); if (err < 0) { printk(KERN_ERR "ipu_enable_channel MEM_ROT_ENC_MEM\n"); return err; } ipu_select_buffer(CSI_PRP_ENC_MEM, IPU_OUTPUT_BUFFER, 0); ipu_select_buffer(CSI_PRP_ENC_MEM, IPU_OUTPUT_BUFFER, 1); } else { err = ipu_init_channel_buffer(CSI_PRP_ENC_MEM, IPU_OUTPUT_BUFFER, enc.csi_prp_enc_mem.out_pixel_fmt, enc.csi_prp_enc_mem.out_width, enc.csi_prp_enc_mem.out_height, cam->v2f.fmt.pix.bytesperline / bytes_per_pixel(enc.csi_prp_enc_mem. out_pixel_fmt), cam->rotation, dummy, dummy, 0, cam->offset.u_offset, cam->offset.v_offset); if (err != 0) { printk(KERN_ERR "CSI_PRP_ENC_MEM output buffer\n"); return err; } err = ipu_enable_channel(CSI_PRP_ENC_MEM); if (err < 0) { printk(KERN_ERR "ipu_enable_channel CSI_PRP_ENC_MEM\n"); return err; } } return err; }