static int __init jpeg_init(void)
{
int ret;
JPEG_MSG("JPEG Codec initialize\n");
JPEG_MSG("Register the JPEG Codec device\n");
if(platform_device_register(&jpeg_device))
{
JPEG_ERR("failed to register jpeg codec device\n");
ret = -ENODEV;
return ret;
}
JPEG_MSG("Register the JPEG Codec driver\n");
if(platform_driver_register(&jpeg_driver))
{
JPEG_ERR("failed to register jpeg codec driver\n");
platform_device_unregister(&jpeg_device);
ret = -ENODEV;
return ret;
}
return 0;
}
static int __init jpeg_init(void)
{
int ret;
JPEG_MSG("JPEG Codec initialize\n");
#if 0
JPEG_MSG("Register the JPEG Codec device\n");
if(platform_device_register(&jpeg_device))
{
JPEG_ERR("failed to register jpeg codec device\n");
ret = -ENODEV;
return ret;
}
#endif
JPEG_MSG("Register the JPEG Codec driver\n");
if(platform_driver_register(&jpeg_driver))
{
JPEG_ERR("failed to register jpeg codec driver\n");
platform_device_unregister(&jpeg_device);
ret = -ENODEV;
return ret;
}
cmdqCoreRegisterCB(CMDQ_GROUP_JPEG,
cmdqJpegClockOn,
cmdqJpegDumpInfo,
cmdqJpegResetEng,
cmdqJpegClockOff);
return 0;
}
int jpeg_drv_dec_wait(JPEG_DEC_DRV_IN *config)
{
unsigned int timeout = 0x2FFFFF;
unsigned int irq_status;
/* wait done */
if (config->decodeMode == JPEG_DEC_MODE_MCU_ROW) {
while ((REG_JPGDEC_INTERRUPT_STATUS & BIT_INQST_MASK_ALLIRQ) == 0) {
timeout--;
if (timeout == 0)
break;
}
} else {
while ((REG_JPGDEC_INTERRUPT_STATUS & BIT_INQST_MASK_ALLIRQ) == 0) {
timeout--;
if (timeout == 0)
break;
}
}
irq_status = REG_JPGDEC_INTERRUPT_STATUS;
IMG_REG_WRITE((irq_status), REG_ADDR_JPGDEC_INTERRUPT_STATUS);
/* Debug: jpeg_drv_dec_dump_reg(); */
if (timeout == 0) {
JPEG_ERR("Error! Decode Timeout.\n");
jpeg_drv_dec_dump_reg();
return 0;
}
JPEG_ERR("JPEG Decode Success, st %x!!\n", irq_status);
return 1;
}
int jpeg_drv_dec_wait_one_row(JPEG_DEC_DRV_IN *config)
{
unsigned int timeout = 0x2FFFFF;
unsigned int irq_status;
unsigned int tri_cnt = ++config->pauseRowCnt; /* 1; */
unsigned int MCU_cnt = 0;
unsigned int base_Y = config->buffer_Y_PA; /* 0x89080000; */
unsigned int base_CB = config->buffer_Cb_PA; /* 0x89040000; */
unsigned int base_CR = config->buffer_Cr_PA; /* 0x89100000; */
unsigned int ring_row_index = tri_cnt % config->tileBufRowNum;
/* for( tri_cnt = 1 ; tri_cnt <= 60 ; tri_cnt++) */
{
/* wait done */
if (config->decodeMode == JPEG_DEC_MODE_MCU_ROW) {
while ((REG_JPGDEC_INTERRUPT_STATUS & BIT_INQST_MASK_ALLIRQ) == 0) {
timeout--;
if (timeout == 0)
break;
}
} else {
while ((REG_JPGDEC_INTERRUPT_STATUS & BIT_INQST_MASK_ALLIRQ) == 0) {
timeout--;
if (timeout == 0)
break;
}
}
irq_status = REG_JPGDEC_INTERRUPT_STATUS;
MCU_cnt = config->mcuPerRow * (tri_cnt + 1);
/* MCU_cnt = config->u4McuNumInRow * (tri_cnt+1) ; */
JPEG_MSG
("JPEG_DEC_WAIT_DONE: tri_cnt %d, irq %x, MCUinRow %d, p_idx %d, %x %x %x!!\n",
tri_cnt, irq_status, config->mcuPerRow, MCU_cnt,
base_Y + ring_row_index * (config->buffer_Y_row_size),
base_CB + ring_row_index * (config->buffer_C_row_size),
base_CR + ring_row_index * (config->buffer_C_row_size));
jpeg_drv_dec_set_dst_bank0(base_Y + ring_row_index * (config->buffer_Y_row_size),
base_CB + ring_row_index * (config->buffer_C_row_size),
base_CR + ring_row_index * (config->buffer_C_row_size));
jpeg_drv_dec_set_pause_mcu_idx(MCU_cnt - 1);
IMG_REG_WRITE((irq_status), REG_ADDR_JPGDEC_INTERRUPT_STATUS);
/* Debug: jpeg_drv_dec_dump_reg(); */
if (timeout == 0) {
JPEG_ERR("Error! Decode Timeout.\n");
jpeg_drv_dec_dump_reg();
return 0;
}
JPEG_ERR("JPEG Decode Success, st %x!!\n", irq_status);
}
return 1;
}
static int jpeg_probe(struct platform_device *pdev)
{
struct class_device;
int ret;
struct class_device *class_dev = NULL;
JPEG_MSG("-------------jpeg driver probe-------\n");
ret = alloc_chrdev_region(&jpeg_devno, 0, 1, JPEG_DEVNAME);
if(ret)
{
JPEG_ERR("Error: Can't Get Major number for JPEG Device\n");
}
else
{
JPEG_MSG("Get JPEG Device Major number (%d)\n", jpeg_devno);
}
jpeg_cdev = cdev_alloc();
jpeg_cdev->owner = THIS_MODULE;
jpeg_cdev->ops = &jpeg_fops;
ret = cdev_add(jpeg_cdev, jpeg_devno, 1);
jpeg_class = class_create(THIS_MODULE, JPEG_DEVNAME);
class_dev = (struct class_device *)device_create(jpeg_class, NULL, jpeg_devno, NULL, JPEG_DEVNAME);
spin_lock_init(&jpeg_dec_lock);
spin_lock_init(&jpeg_enc_lock);
// initial codec, register codec ISR
dec_status = 0;
enc_status = 0;
_jpeg_dec_int_status = 0;
_jpeg_enc_int_status = 0;
#ifndef FPGA_VERSION
init_waitqueue_head(&dec_wait_queue);
init_waitqueue_head(&enc_wait_queue);
enable_irq(MT_JPEG_CODEC_IRQ_ID);
if(request_irq(MT_JPEG_CODEC_IRQ_ID, jpeg_drv_isr, IRQF_TRIGGER_LOW, "jpeg_driver" , NULL))
{
JPEG_ERR("JPEG Codec Driver request irq failed\n");
}
#endif
JPEG_MSG("JPEG Probe Done\n");
NOT_REFERENCED(class_dev);
return 0;
}
kal_uint32 jpeg_drv_enc_set_encFormat(kal_uint32 encFormat)
{
kal_uint32 val ;
unsigned int u4Value ;
if(encFormat & (~3)){
JPEG_ERR("JPEG_DRV_ENC: set encFormat Err %d!!\n", encFormat );
return 0;
}
val = (encFormat & 3) << 3;
#if 0
// REG_JPEG_ENC_CTRL &= ~JPEG_ENC_CTRL_YUV_BIT;
//
// REG_JPEG_ENC_CTRL |= val;
#else
u4Value = REG_JPEG_ENC_CTRL ;
u4Value &= ~JPEG_ENC_CTRL_YUV_BIT;
u4Value |= val;
IMG_REG_WRITE( (u4Value), REG_ADDR_JPEG_ENC_CTRL);
#endif
return 1;
}
static int jpeg_dec_ioctl(unsigned int cmd, unsigned long arg, struct file *file)
{
unsigned int* pStatus;
unsigned int decResult;
long timeout_jiff;
JPEG_DEC_DRV_IN dec_params;
JPEG_DEC_CONFIG_ROW dec_row_params ;
unsigned int irq_st = 0;
//unsigned int timeout = 0x1FFFFF;
JPEG_DEC_DRV_OUT outParams;
pStatus = (unsigned int*)file->private_data;
if (NULL == pStatus)
{
JPEG_MSG("[JPEGDRV]JPEG Decoder: Private data is null in flush operation. SOME THING WRONG??\n");
return -EFAULT;
}
switch(cmd)
{
// initial and reset JPEG encoder
case JPEG_DEC_IOCTL_INIT: /* OT:OK */
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Init!!\n");
if(jpeg_drv_dec_init() == 0)
{
*pStatus = JPEG_DEC_PROCESS;
}
break;
case JPEG_DEC_IOCTL_RESET: /* OT:OK */
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Reset!!\n");
jpeg_drv_dec_reset();
break;
case JPEG_DEC_IOCTL_CONFIG:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Configration!!\n");
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_MSG("[JPEGDRV]Permission Denied! This process can not access decoder\n");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_MSG("[JPEGDRV]JPEG Decoder is unlocked!!");
*pStatus = 0;
return -EFAULT;
}
if(copy_from_user(&dec_params, (void *)arg, sizeof(JPEG_DEC_DRV_IN)))
{
JPEG_MSG("[JPEGDRV]JPEG Decoder : Copy from user error\n");
return -EFAULT;
}
//_jpeg_dec_dump_reg_en = dec_params.regDecDumpEn;
if(dec_params.decodeMode == JPEG_DEC_MODE_MCU_ROW)
_jpeg_dec_mode = 1;
else
_jpeg_dec_mode = 0;
if (jpeg_drv_dec_set_config_data(&dec_params) < 0)
return -EFAULT;
break;
case JPEG_DEC_IOCTL_RESUME:
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_MSG("[JPEGDRV]Permission Denied! This process can not access decoder\n");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_MSG("[JPEGDRV]JPEG Decoder is unlocked!!");
*pStatus = 0;
return -EFAULT;
}
if(copy_from_user(&dec_row_params, (void *)arg, sizeof(JPEG_DEC_CONFIG_ROW)))
{
JPEG_MSG("[JPEGDRV]JPEG Decoder : Copy from user error\n");
return -EFAULT;
}
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Resume, [%d] %x %x %x !!\n", dec_row_params.pauseMCU -1,dec_row_params.decRowBuf[0], dec_row_params.decRowBuf[1], dec_row_params.decRowBuf[2]);
jpeg_drv_dec_set_dst_bank0( dec_row_params.decRowBuf[0], dec_row_params.decRowBuf[1], dec_row_params.decRowBuf[2]);
jpeg_drv_dec_set_pause_mcu_idx(dec_row_params.pauseMCU -1) ;
jpeg_drv_dec_resume(BIT_INQST_MASK_PAUSE);
break;
case JPEG_DEC_IOCTL_START: /* OT:OK */
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Start!!\n");
//Debug: printk("0xF0: 0x%08x\n", *(volatile unsigned int*)(JPEG_DEC_BASE + 0xF0));
jpeg_drv_dec_start();
break;
case JPEG_DEC_IOCTL_WAIT:
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_WRN("Permission Denied! This process can not access decoder");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_WRN("Decoder status is available, HOW COULD THIS HAPPEN ??");
*pStatus = 0;
return -EFAULT;
}
if(copy_from_user(&outParams, (void *)arg, sizeof(JPEG_DEC_DRV_OUT)))
{
JPEG_WRN("JPEG Decoder : Copy from user error\n");
return -EFAULT;
}
//set timeout
timeout_jiff = outParams.timeout* HZ / 1000;
//JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Wait Resume Time Jiffies : %ld\n", timeout_jiff);
#ifdef FPGA_VERSION
//#if 1
JPEG_MSG("[JPEGDRV]Polling JPEG Status");
do
{
_jpeg_dec_int_status = REG_JPGDEC_INTERRUPT_STATUS;
} while(_jpeg_dec_int_status == 0);
#else
//if(outParams.timeout >= 5000){
//
// JPEG_MSG("Polling JPEG Status");
// do
// {
// _jpeg_dec_int_status = REG_JPGDEC_INTERRUPT_STATUS;
// timeout--;
// } while(_jpeg_dec_int_status == 0 && timeout != 0);
// if(timeout == 0) JPEG_MSG("Polling JPEG Status TIMEOUT!!\n");
//}else
if(jpeg_isr_dec_lisr()<0) {
//JPEG_MSG("wait JPEG irq\n");
wait_event_interruptible_timeout(dec_wait_queue, _jpeg_dec_int_status, timeout_jiff);
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Enter IRQ Wait Done!!\n");
//printk("[JPEGDRV]wait JPEG irq done\n");
} else {
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Enter IRQ Wait Already Done!!\n");
//printk("[JPEGDRV]JPEG decoder already done\n");
}
#endif
decResult = jpeg_drv_dec_get_result();
//jpeg_drv_dec_dump_key_reg();
if(decResult >= 2)
{
JPEG_MSG("[JPEGDRV]Decode Result : %d, status %x!\n", decResult, _jpeg_dec_int_status );
jpeg_drv_dec_dump_key_reg();
//jpeg_drv_dec_dump_reg();
jpeg_drv_dec_reset();
}
irq_st = _jpeg_dec_int_status ;
decResult = decResult | (irq_st<<8) ;
_jpeg_dec_int_status = 0;
if(copy_to_user(outParams.result, &decResult, sizeof(unsigned int)))
{
JPEG_WRN("JPEG Decoder : Copy to user error (result)\n");
return -EFAULT;
}
break;
case JPEG_DEC_IOCTL_BREAK:
if (jpeg_drv_dec_break() < 0)
return -EFAULT;
break;
case JPEG_DEC_IOCTL_DUMP_REG:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder DUMP REGISTER !!\n");
jpeg_drv_dec_dump_reg();
break;
case JPEG_DEC_IOCTL_DEINIT:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Decoder Deinit !!\n");
// copy input parameters
if(*pStatus != JPEG_DEC_PROCESS)
{
JPEG_ERR("Permission Denied! This process can not access encoder");
return -EFAULT;
}
if(dec_status == 0)
{
JPEG_ERR("Encoder status is available, HOW COULD THIS HAPPEN ??");
*pStatus = 0;
return -EFAULT;
}
jpeg_drv_dec_deinit();
*pStatus = 0;
break;
#ifdef FOR_COMPILE
case JPEG_DEC_IOCTL_RW_REG: /* OT:OK */
jpeg_drv_dec_rw_reg();
break;
#endif
default:
JPEG_ERR("JPEG DEC IOCTL NO THIS COMMAND\n");
break;
}
return 0;
}
static int jpeg_probe(struct platform_device *pdev)
{
struct class_device;
int ret;
struct class_device *class_dev = NULL;
JPEG_MSG("-------------jpeg driver probe-------\n");
ret = alloc_chrdev_region(&jpeg_devno, 0, 1, JPEG_DEVNAME);
if(ret)
{
JPEG_ERR("Error: Can't Get Major number for JPEG Device\n");
}
else
{
JPEG_MSG("Get JPEG Device Major number (%d)\n", jpeg_devno);
}
jpeg_cdev = cdev_alloc();
jpeg_cdev->owner = THIS_MODULE;
jpeg_cdev->ops = &jpeg_fops;
ret = cdev_add(jpeg_cdev, jpeg_devno, 1);
jpeg_class = class_create(THIS_MODULE, JPEG_DEVNAME);
class_dev = (struct class_device *)device_create(jpeg_class, NULL, jpeg_devno, NULL, JPEG_DEVNAME);
spin_lock_init(&jpeg_dec_lock);
spin_lock_init(&jpeg_enc_lock);
// initial codec, register codec ISR
dec_status = 0;
enc_status = 0;
_jpeg_dec_int_status = 0;
_jpeg_enc_int_status = 0;
_jpeg_dec_mode = 0;
#ifndef FPGA_VERSION
init_waitqueue_head(&dec_wait_queue);
init_waitqueue_head(&enc_wait_queue);
//mt6575_irq_set_sens(MT6575_JPEG_CODEC_IRQ_ID, MT65xx_LEVEL_SENSITIVE);
//mt6575_irq_set_polarity(MT6575_JPEG_CODEC_IRQ_ID, MT65xx_POLARITY_LOW);
//mt6575_irq_unmask(MT6575_JPEG_CODEC_IRQ_ID);
JPEG_MSG("request JPEG Encoder IRQ \n");
enable_irq(MT6589_JPEG_ENC_IRQ_ID);
if(request_irq(MT6589_JPEG_ENC_IRQ_ID, jpeg_drv_enc_isr, IRQF_TRIGGER_LOW, "jpeg_enc_driver" , NULL))
//if(request_irq(MT6589_JPEG_ENC_IRQ_ID, jpeg_drv_enc_isr, /*IRQF_TRIGGER_RISING*/ IRQF_TRIGGER_HIGH, "jpeg_enc_driver" , NULL))
//if(request_irq(MT6589_JPEG_ENC_IRQ_ID, jpeg_drv_enc_isr, IRQF_TRIGGER_RISING , "jpeg_enc_driver" , NULL))
{
JPEG_ERR("JPEG ENC Driver request irq failed\n");
}
enable_irq(MT6589_JPEG_DEC_IRQ_ID);
JPEG_MSG("request JPEG Decoder IRQ \n");
//if(request_irq(MT6589_JPEG_DEC_IRQ_ID, jpeg_drv_dec_isr, IRQF_TRIGGER_LOW, "jpeg_dec_driver" , NULL))
//if(request_irq(MT6589_JPEG_DEC_IRQ_ID, jpeg_drv_dec_isr, /*IRQF_TRIGGER_RISING*/ IRQF_TRIGGER_HIGH, "jpeg_dec_driver" , NULL))
//if(request_irq(MT6589_JPEG_DEC_IRQ_ID, jpeg_drv_dec_isr, IRQF_TRIGGER_RISING , "jpeg_dec_driver" , NULL))
if(request_irq(MT6589_JPEG_DEC_IRQ_ID, jpeg_drv_dec_isr, IRQF_TRIGGER_FALLING , "jpeg_dec_driver" , NULL))
{
JPEG_ERR("JPEG DEC Driver request irq failed\n");
}
#endif
JPEG_MSG("JPEG Probe Done\n");
NOT_REFERENCED(class_dev);
return 0;
}
static int jpeg_probe(struct platform_device *pdev)
{
#ifdef CONFIG_OF
int new_count;
struct JpegDeviceStruct* jpegDev;
struct device_node *node = NULL;
new_count = nrJpegDevs + 1;
gJpegqDevs = krealloc(gJpegqDevs,
sizeof(struct JpegDeviceStruct) * new_count, GFP_KERNEL);
if (!gJpegqDevs) {
dev_err(&pdev->dev, "Unable to allocate cam_isp_devs\n");
return -ENOMEM;
}
jpegDev = &(gJpegqDevs[nrJpegDevs]);
jpegDev->pDev = &pdev->dev;
memset(&gJpegqDev, 0x0, sizeof(JpegDeviceStruct));
node = of_find_compatible_node(NULL, NULL, "mediatek,JPGENC");
jpegDev->encRegBaseVA = (unsigned long)of_iomap(node, 0);
jpegDev->encIrqId = irq_of_parse_and_map(node, 0);
node = of_find_compatible_node(NULL, NULL, "mediatek,JPGDEC");
jpegDev->decRegBaseVA = (unsigned long)of_iomap(node, 0);
jpegDev->decIrqId = irq_of_parse_and_map(node, 0);
gJpegqDev = *jpegDev;
#else
gJpegqDev.encRegBaseVA = (0L | 0xF7003000);
gJpegqDev.decRegBaseVA = (0L | 0xF7004000);
gJpegqDev.encIrqId = JPGENC_IRQ_BIT_ID;
gJpegqDev.decIrqId = JPGDEC_IRQ_BIT_ID;
gJpegqDev.pDev = &pdev->dev;
#endif
#ifdef JPEG_DEV
int ret;
struct class_device *class_dev = NULL;
JPEG_MSG("-------------jpeg driver probe-------\n");
ret = alloc_chrdev_region(&jpeg_devno, 0, 1, JPEG_DEVNAME);
if(ret)
{
JPEG_ERR("Error: Can't Get Major number for JPEG Device\n");
}
else
{
JPEG_MSG("Get JPEG Device Major number (%d)\n", jpeg_devno);
}
jpeg_cdev = cdev_alloc();
jpeg_cdev->owner = THIS_MODULE;
jpeg_cdev->ops = &jpeg_fops;
ret = cdev_add(jpeg_cdev, jpeg_devno, 1);
jpeg_class = class_create(THIS_MODULE, JPEG_DEVNAME);
class_dev = (struct class_device *)device_create(jpeg_class, NULL, jpeg_devno, NULL, JPEG_DEVNAME);
#else
proc_create("mtk_jpeg", 0, NULL, &jpeg_fops);
#endif
spin_lock_init(&jpeg_dec_lock);
spin_lock_init(&jpeg_enc_lock);
// initial codec, register codec ISR
dec_status = 0;
enc_status = 0;
_jpeg_dec_int_status = 0;
_jpeg_enc_int_status = 0;
_jpeg_dec_mode = 0;
#ifndef FPGA_VERSION
#ifdef JPEG_DEC_DRIVER
init_waitqueue_head(&dec_wait_queue);
#endif
init_waitqueue_head(&enc_wait_queue);
//mt6575_irq_set_sens(MT6575_JPEG_CODEC_IRQ_ID, MT65xx_LEVEL_SENSITIVE);
//mt6575_irq_set_polarity(MT6575_JPEG_CODEC_IRQ_ID, MT65xx_POLARITY_LOW);
//mt6575_irq_unmask(MT6575_JPEG_CODEC_IRQ_ID);
JPEG_MSG("request JPEG Encoder IRQ \n");
enable_irq(gJpegqDev.encIrqId);
if(request_irq(gJpegqDev.encIrqId, jpeg_drv_enc_isr, IRQF_TRIGGER_LOW, "jpeg_enc_driver" , NULL))
//if(request_irq(JPGENC_IRQ_BIT_ID, jpeg_drv_enc_isr, /*IRQF_TRIGGER_RISING*/ IRQF_TRIGGER_HIGH, "jpeg_enc_driver" , NULL))
//if(request_irq(JPGENC_IRQ_BIT_ID, jpeg_drv_enc_isr, IRQF_TRIGGER_RISING , "jpeg_enc_driver" , NULL))
{
JPEG_ERR("JPEG ENC Driver request irq failed\n");
}
#ifdef JPEG_DEC_DRIVER
enable_irq(gJpegqDev.decIrqId);
JPEG_MSG("request JPEG Decoder IRQ \n");
//if(request_irq(JPGDEC_IRQ_BIT_ID, jpeg_drv_dec_isr, IRQF_TRIGGER_LOW, "jpeg_dec_driver" , NULL))
//if(request_irq(JPGDEC_IRQ_BIT_ID, jpeg_drv_dec_isr, /*IRQF_TRIGGER_RISING*/ IRQF_TRIGGER_HIGH, "jpeg_dec_driver" , NULL))
//if(request_irq(JPGDEC_IRQ_BIT_ID, jpeg_drv_dec_isr, IRQF_TRIGGER_RISING , "jpeg_dec_driver" , NULL))
if(request_irq(gJpegqDev.decIrqId, jpeg_drv_dec_isr, IRQF_TRIGGER_FALLING , "jpeg_dec_driver" , NULL))
{
JPEG_ERR("JPEG DEC Driver request irq failed\n");
}
#endif
#endif
JPEG_MSG("JPEG Probe Done\n");
#ifdef JPEG_DEV
NOT_REFERENCED(class_dev);
#endif
return 0;
}
