static int _isp_probe(struct platform_device *pdev)
{
int ret = 0;
ISP_PRINT ("isp_k:probe start\n");
ret = misc_register(&isp_dev);
if (ret) {
ISP_PRINT ( "isp_k:probe cannot register miscdev on minor=%d (%d)\n",(int32_t)ISP_MINOR, (int32_t)ret);
return ret;
}
/*
isp_proc_file = create_proc_read_entry("driver/sprd_isp" ,
0444,
NULL,
_isp_kernel_proc_read,
NULL);
if (unlikely(NULL == isp_proc_file)) {
ISP_PRINT("isp_k:probe Can't create an entry for isp in /proc \n");
ret = ENOMEM;
return ret;
}
*/
isp_dev.this_device->of_node = pdev->dev.of_node;
ISP_PRINT (" isp_k:probe end\n");
return 0;
}
static void isp_kernel_exit(void)
{
ISP_PRINT ("isp_k: exit start \n");
platform_driver_unregister(&isp_driver);
ISP_PRINT ("isp_k: exit end \n");
}
/**********************************************************
*release the device
*
***********************************************************/
static int32_t _isp_kernel_release (struct inode *node, struct file *pf)
{
int ret = 0;
ISP_PRINT ("isp_k: release start \n");
ISP_PRINT ("isp_k: release end \n");
return ret;
}
void check_csi_error(void) {
unsigned int temp1, temp2;
while(1){
dump_csi_reg();
temp1 = csi_core_read(ERR1);
temp2 = csi_core_read(ERR2);
if(temp1 != 0)
ISP_PRINT(ISP_INFO,"error-------- 1:0x%08x\n", temp1);
if(temp2 != 0)
ISP_PRINT(ISP_INFO,"error-------- 2:0x%08x\n", temp2);
}
}
static int32_t __init isp_kernel_init(void)
{
int32_t ret = 0;
uint32_t addr = 0;
ISP_PRINT ("isp_k: init start \n");
if (platform_driver_register(&isp_driver) != 0) {
ISP_PRINT ("isp_kernel_init: platform device register error \n");
return -1;
}
ISP_PRINT ("isp_k: init end\n");
return ret;
}
static int _isp_remove(struct platform_device * dev)
{
ISP_PRINT ("isp_k: remove start \n");
misc_deregister(&isp_dev);
if (isp_proc_file) {
remove_proc_entry("driver/sprd_isp", NULL);
}
ISP_PRINT ("isp_k: remove end !\n");
return 0;
}
int isp_set_exposure_manual(struct isp_device *isp)
{
unsigned char value = 0;
value = isp_firmware_readb(isp, 0x1e022);
value |= 0x1;
ISP_PRINT(ISP_INFO,"the exposour en value is %#x\n",isp_firmware_readb(isp, 0x1e022));
isp_firmware_writeb(isp, value, 0x1e022);
ISP_PRINT(ISP_INFO,"the exposour en value is %#x\n",isp_firmware_readb(isp, 0x1e022));
if (value != isp_firmware_readb(isp, 0x1e022)){
ISP_PRINT(ISP_INFO,"set exposure manual failure!!!!\n");
return -1;
}
return 0;
}
/**********************************************************
*open the device
*
***********************************************************/
static int32_t _isp_kernel_open (struct inode *node, struct file *pf)
{
int32_t ret = 0;
ISP_PRINT ("isp_k: open start \n");
return ret;
}
int csi_phy_stop(unsigned int id)
{
ISP_PRINT(ISP_INFO,"csi_phy_stop being called \n");
/*reset phy*/
csi_core_write_part(PHY_SHUTDOWNZ, 0, 0, 1);
csi_core_write_part(DPHY_RSTZ, 0, 0, 1);
csi_core_write_part(CSI2_RESETN, 0, 0, 1);
return 0;
}
static int csi_phy_ready(unsigned int id)
{
int ready;
// TODO: phy0: lane0 is ready. need to be update for other lane
ready = csi_core_read(PHY_STATE);
#if 0
ISP_PRINT(ISP_INFO,"%s:phy state ready:0x%08x\n", __func__, ready);
#endif
if ((ready & (1 << 10 )) && (ready & (1<<4)))
return 1;
return 0;
}
/**********************************************************
*read info from file
*size_t size:
*loff_t p:
***********************************************************/
static int32_t _isp_kernel_proc_read (char *page, char **start, off_t off, int count, int *eof, void *data)
{
int len = 0;
#if 0
uint32_t reg_buf_len = 200;
uint32_t print_len = 0, print_cnt = 0;
uint32_t *reg_ptr = 0;
ISP_PRINT ("isp_k: _isp_kernel_proc_read 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x \n", (uint32_t)page, (uint32_t)start, (uint32_t)off, (uint32_t)count, (uint32_t)eof, (uint32_t)data);
(void)start;
(void)off;
(void)count;
(void)eof;
if(0x00==g_isp_device.reg_base_addr)
{
return 0x00;
}
reg_ptr = (uint32_t*)g_isp_device.reg_base_addr;
len += sprintf(page + len, "Context for ISP device \n");
len += sprintf(page + len, "********************************************* \n");
while (print_len < reg_buf_len) {
len += sprintf(page + len, "offset 0x%x : 0x%x, 0x%x, 0x%x, 0x%x \n",
print_len,
reg_ptr[print_cnt],
reg_ptr[print_cnt+1],
reg_ptr[print_cnt+2],
reg_ptr[print_cnt+3]);
print_cnt += 4;
print_len += 16;
}
len += sprintf(page + len, "********************************************* \n");
len += sprintf(page + len, "The end of ISP device \n");
#endif
return len;
}
static int isp_calc_zoom(struct isp_device *isp)
{
int crop_w = 0;
int crop_h = 0;
int crop_x = 0;
int crop_y = 0;
int downscale_w;
int downscale_h;
int dcw_w;
int dcw_h;
int Wi;
int Wo;
int Hi;
int Ho;
int ratio_h;
int ratio_w;
int ratio_gross;
int ratio;
int ratio_dcw = 0;
int dratio = 0;
int ratio_d = 0;
int ratio_up = 0;
int dcwFlag =0;
int downscaleFlag=0;
int w_dcw;
int h_dcw;
int i;
int j;
int zoom_0;
int zoom_ratio;
int crop_width;
int crop_height;
int in_width;
int in_height;
int out_height;
int out_width;
int final_crop_width;
int final_crop_height;
int crop_x0 = 0;
int crop_y0 = 0;
int ret = 1;
int t1;
int t2;
out_width = isp->parm.out_width;
out_height = isp->parm.out_height;
in_width = isp->parm.in_width;
in_height = isp->parm.in_height;
zoom_0 = isp_get_zoom_ratio(isp, ZOOM_LEVEL_0);
zoom_ratio = isp_get_zoom_ratio(isp, isp->parm.zoom);
crop_width = (zoom_0 * in_width)/zoom_ratio;
crop_height = (zoom_0 * in_height)/zoom_ratio;
if(((crop_width*1000)/crop_height) <= ((out_width*1000)/out_height)){
final_crop_width = crop_width;
final_crop_width = final_crop_width&0xfffe;
final_crop_height = (final_crop_width * out_height)/out_width;
final_crop_height = final_crop_height&0xfffe;
}else{
final_crop_height = crop_height;
final_crop_height = final_crop_height&0xfffe;
final_crop_width = (final_crop_height * out_width)/out_height;
final_crop_width = final_crop_width&0xfffe;
}
crop_x0 = (in_width - final_crop_width)/2;
crop_y0 = (in_height - final_crop_height)/2;
Wo = isp->parm.out_width;
Ho = isp->parm.out_height;
Wi = final_crop_width;
Hi = final_crop_height;
ISP_PRINT(ISP_INFO, "Wo %d;Ho %d;Wi %d;Hi %d\n",Wo,Ho,Wi,Hi);
if(final_crop_width> isp->parm.out_width) {
crop_w =crop_h =crop_x =crop_y =downscale_w =downscale_h =dcw_w =dcw_h = 0;
ratio_h = (Hi*1000/Ho);
ratio_w = (Wi*1000/Wo);
ratio_gross = (ratio_h>= ratio_w) ? ratio_w:ratio_h;
ratio = ratio_gross/1000;
for (i=0;i<4;i++)
if((1<<i)<=ratio && (1<<(i+1))>ratio)
break;
if(i==4) i--;
dcw_w = dcw_h = i;
ratio_dcw = i;
if(dcw_w == 0)
dcwFlag = 0;
else
dcwFlag = 1;
h_dcw = (1<<i)*Ho;
w_dcw = (1<<i)*Wo;
downscale_w = (256*w_dcw + Wi)/(2*Wi);
downscale_h = (256*h_dcw + Hi)/(2*Hi);
dratio = (downscale_w>=downscale_h)?downscale_w:downscale_h;
if(dratio == 128)
downscaleFlag = 0;
else {
downscaleFlag = 1;
dratio += 1;
}
crop_w = (256*w_dcw + dratio)/(2*dratio);
crop_h = (256*h_dcw + dratio)/(2*dratio);
crop_w = crop_w&0xfffe;
crop_h = crop_h&0xfffe;
//update by wayne
for(j=-3;j<=3;j++) {
crop_w = (256*w_dcw + (dratio+j))/(2*(dratio+j));
crop_h = (256*h_dcw + (dratio+j))/(2*(dratio+j));
crop_w = crop_w&0xfffe;
crop_h = crop_h&0xfffe;
for(i=0;i<=4;i+=2) {
t1 = (crop_w+i)*(dratio+j)/128;
t2 = (crop_h+i)*(dratio+j)/128;
if((t1&0xfffe) == t1 && t1 >= w_dcw && (t2&0xfffe) == t2 && t2 >= h_dcw && (dratio+j)>=64 &&(dratio+j)<=128 && (crop_w +i)<= Wi && (crop_h+i)<= Hi)
{
ret = 0;
break;
}
}
if(ret == 0)
break;
}
if(j==4) j--;
if(i==6) i = i-2;
ISP_PRINT(ISP_INFO, "i = %d,j = %d\n",i,j);
crop_w += i;
crop_h += i;
dratio += j;
//end
crop_x = (Wi-crop_w)/2;
crop_y = (Hi-crop_h)/2;
ratio_d = dratio;
}
else {
ratio_up= ((final_crop_height* 0x100)/isp->parm.out_height);
crop_w = final_crop_width;
crop_h = final_crop_height;
}
isp->parm.ratio_up = ratio_up;
isp->parm.ratio_d = ratio_d;
isp->parm.ratio_dcw = ratio_dcw;
isp->parm.crop_width = crop_w;
isp->parm.crop_height = crop_h;
isp->parm.crop_x = crop_x + crop_x0;
isp->parm.crop_y = crop_y + crop_y0;
isp->parm.dcwFlag = dcwFlag;
isp->parm.dowscaleFlag = downscaleFlag;
/*isp_dump_cal_zoom(isp);*/
return 0;
}
/**********************************************************
*the io controller of isp
*unsigned int cmd:
*unsigned long param:
***********************************************************/
static long _isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param)
{
long ret = 0;
if(ISP_IO_IRQ==cmd)
{
} else {
switch (cmd)
{
case ISP_IO_READ: {
}
break;
case ISP_IO_WRITE: {
}
break;
case ISP_IO_RST: {
ISP_PRINT(" isp_k:ioctl restet start \n");
}
break;
case ISP_IO_SETCLK:
ISP_PRINT(" isp_k:ioctl set clock start \n");
break;
case ISP_IO_STOP: {
}
break;
case ISP_IO_INT: {
}
break;
case ISP_IO_DCAM_INT: {
}
break;
case ISP_IO_LNC_PARAM: {
}
break;
case ISP_IO_LNC: {
}
break;
case ISP_IO_ALLOC: {
}
break;
default:
ISP_PRINT("isp_k:_ioctl cmd is unsupported, cmd = %x\n", (int32_t)cmd);
return -EFAULT;
}
}
//ISP_PRINT("isp_k:_ioctl finished\n");
ISP_IOCTL_EXIT:
return ret;
}
