cim.patch

patches for linux-2.6.

+	  		cim_config->memory[0]=mem_buf;
+	  		cim_config->memory[1]=mem_buf+ cim_config->nTransferSize[0];
+	  		cim_config->memory[2]=mem_buf+ cim_config->nTransferSize[0]
+			      + cim_config->nTransferSize[1];
+	  }
+	  else
+	  {
+	       	DPRINTK( "CCIR656 (Planer) Mode Memory Size Calculation\n");
+			cim_config->nTransferSize[0]=((cim_config_ptr->frame_width) * ( cim_config_ptr->frame_height));
+			cim_config->nTransferSize[1]=((cim_config_ptr->frame_width) * ( cim_config_ptr->frame_height))/2;   
+			cim_config->nTransferSize[2]=((cim_config_ptr->frame_width) * ( cim_config_ptr->frame_height))/2;
+			DPRINTK(" Transfer Size of FIFO-A %d FIFO-B %d & FIFO-C in CCIR656 Mode %d\n", cim_config->nTransferSize[0],
+			cim_config->nTransferSize[1],cim_config->nTransferSize[2]);
+	  
+	  		cim_config->memory[0]=mem_buf;
+	  		cim_config->memory[1]=mem_buf+ cim_config->nTransferSize[0];
+	  		cim_config->memory[2]=mem_buf+ cim_config->nTransferSize[0]
+			      + cim_config->nTransferSize[1];
+	  
+	  }
+	
+ 	for ( i=0; i< cim_config->cmos_camera->dbdma_channel;i++ )
+	{
+		/* Allocate Channel */
+		cim_config->ChannelArray[i]=(chan_tab_t**)au1xxx_dbdma_chan_alloc(DBDMA_SourceID[i], DSCR_CMD0_ALWAYS,
+					Cim_DDMA_Done_Interrupt, (void *)NULL); 
+		
+		if ( cim_config->ChannelArray[i] !=NULL )
+		{ 
+			au1xxx_dbdma_set_devwidth((u32)(cim_config->ChannelArray[i]), 32);
+            if ( au1xxx_dbdma_ring_alloc((u32)(cim_config->ChannelArray[i]),  16) == 0 )
+			{
+				printk("Allocation failed for an CIM DDMA channel-A in Single Channel\n"); 
+				ErrorCheck++;
+				goto error_ch_alloc;
+		  	}
+	   	au1xxx_dbdma_start((u32)( cim_config->ChannelArray[i]));                              
+		int j=0;
+	   	for ( j=0; j <NUM_DBDMA_DESCRIPTORS; j++ )
+			{ 
+    
+				if ( ! au1xxx_dbdma_put_dest((u32)( cim_config->ChannelArray[i]),  
+								cim_config->memory[i],  cim_config->nTransferSize[i]) )
+				{
+					printk("DBDMA Error..Putting Descriptor on Buffer Ring Channel A in Single Channel \n");
+				}
+		  	} 
+			  
+		} 
+		else
+		{
+			ErrorCheck++;
+			goto error_ch_alloc;
+		}
+
+	}
+	DPRINTK("CMOS Camera configuration \n");
+	for ( i=0; i< cim_config_ptr->cmd_size; i++ )
+	{
+		while ( ( pb1550_wm_codec_write(cim_config_ptr->device_addr ,
+						cim_config_ptr->config_cmd[i][0],cim_config_ptr->config_cmd[i][1] ) != 1)
+				&& (nAckCount < 50) )
+		{
+			nAckCount++;
+		}
+		if(i==0){mdelay(1);}
+
+	}	
+	if(nAckCount==50)
+	{
+	 	printk("External CMOS Camera Not Present or not properly connected !!!! !\n");
+	 	goto error_ch_alloc;
+	}	else
+	{
+        DPRINTK("CMOS Camera configuration Sucessful \n");
+	}
+
+	au1200_cim->enable= CIM_ENABLE_EN;
+	au1200_cim->capture=CIM_CAPTURE_CLR;
+	
+	if ( cim_config_ptr->au1200_dpsmode==1 )
+	{
+		nCameraModeConfig= CIM_CONFIG_DPS_N(cim_config_ptr->au1200_dpsmode) | 
+		          							CIM_CONFIG_FS | 
+											CIM_CONFIG_BAY_N(cim_config_ptr->au1200_baymode)|
+											CIM_CONFIG_BYT |
+											CIM_CONFIG_LEN( CIM_CONFIG_LEN_10BIT );
+	}
+	else if ( cim_config_ptr->au1200_dpsmode==0 )
+	{
+		nCameraModeConfig=CIM_CONFIG_DPS_N(cim_config_ptr->au1200_dpsmode) |
+		 								   	CIM_CONFIG_FS | CIM_CONFIG_BYT |
+						 					CIM_CONFIG_LEN( CIM_CONFIG_LEN_10BIT)|
+											CIM_CONFIG_BAY_N(cim_config_ptr->au1200_baymode) |
+											CIM_CONFIG_PM; 
+	}
+	else
+	{
+		/* Need to re check........*/
+		nCameraModeConfig= CIM_CONFIG_DPS_N(cim_config_ptr->au1200_dpsmode) | 
+											CIM_CONFIG_FS |
+											CIM_CONFIG_BYT |
+											CIM_CONFIG_LEN( CIM_CONFIG_LEN_10BIT)|
+											CIM_CONFIG_FSEL_N(CIM_CONFIG_FIELD12);
+	}
+
+	au1200_cim->config=nCameraModeConfig;
+	nClearSetInterrupt= CIM_INSTAT_CD | CIM_INSTAT_FD |
+						CIM_INSTAT_UFA | CIM_INSTAT_OFA |
+						CIM_INSTAT_UFB | CIM_INSTAT_OFB |
+						CIM_INSTAT_UFB | CIM_INSTAT_OFC;
+
+	au1200_cim->instat=nClearSetInterrupt;
+	au1200_cim->inten=nClearSetInterrupt;
+	DPRINTK("Camera Config register value %x \n",au1200_cim->config);
+	for(i=0;i<6;i++){mdelay(1);}
+	
+	error_ch_alloc:
+	if ( ErrorCheck )
+	{
+		CIM_Cleanup(cim_config);
+		return -1;
+	}
+  return 0;
+}
+
+/* To get contigious Memroy location using GetFree pages*/
+
+static unsigned long
+Camera_mem_alloc(unsigned long size)
+{
+    /* __get_free_pages() fulfills a max request of 2MB */
+    /* do multiple requests to obtain large contigous mem */
+#define MAX_GFP 0x00200000
+
+	unsigned long mem, amem, alloced = 0, allocsize;
+
+    DPRINTK(" Allocating Contigous chunk of memory %d \n", size);
+    size += 0x1000;
+    allocsize = (size < MAX_GFP) ? size : MAX_GFP;
+
+    /* Get first chunk */
+    mem = (unsigned long )
+        __get_free_pages(GFP_ATOMIC | GFP_DMA, get_order(allocsize));
+    if (mem != 0) alloced = allocsize;
+
+    /* Get remaining, contiguous chunks */
+    while (alloced < size)
+    {
+        amem = (unsigned long )
+            __get_free_pages(GFP_ATOMIC | GFP_DMA, get_order(allocsize));
+        if (amem != 0)
+            alloced += allocsize;
+
+        /* check for contiguous mem alloced */
+        if ((amem == 0) || (amem + allocsize) != mem)
+            break;
+        else
+            mem = amem;
+    }
+    return mem;
+}
+
+void Cim_Interrupt_Handler(int irq, void *dev_id, struct pt_regs *regs)
+{
+
+	uint32 nStatus;
+
+	disable_irq(AU1200_CAMERA_INT);
+	nStatus=au1200_cim->instat;
+
+	if ( nStatus &  CIM_INSTAT_CD )
+	{
+	//DPRINTK("\n Camera Driver: Capture Done Interrupt Recieved \n");
+		au1200_cim->instat=CIM_INSTAT_CD;
+	}
+	else if ( nStatus &  CIM_INSTAT_FD )
+	{
+		 //DPRINTK("\n Camera Driver: Frame Done Interrupt Recieved \n");  
+		au1200_cim->instat=CIM_INSTAT_FD;
+	}
+	else if ( nStatus &  CIM_INSTAT_UFA )
+	{
+		DPRINTK("\n Camera Driver: FIFO-A Underflow Interrupt Recieved \n");
+		au1200_cim->instat=CIM_INSTAT_UFA; 
+	   ciminterruptcheck = 1;
+   	}
+	else if ( nStatus &  CIM_INSTAT_OFA )
+	{
+		DPRINTK("\n Camera Driver: FIFO-A Overflow Interrupt Recieved \n"); 
+		au1200_cim->instat=CIM_INSTAT_OFA;
+		ciminterruptcheck = 1; 
+	}
+	else if ( nStatus &  CIM_INSTAT_UFB )
+	{
+		DPRINTK("\n Camera Driver: FIFO-B Underflow Interrupt Recieved \n"); 
+		au1200_cim->instat=CIM_INSTAT_UFB;
+		ciminterruptcheck = 1; 
+	}
+	else if ( nStatus &  CIM_INSTAT_OFB )
+	{
+		DPRINTK("\n Camera Driver: FIFO-B Overflow Interrupt Recieved \n");
+		au1200_cim->instat=CIM_INSTAT_OFB;
+		ciminterruptcheck = 1; 
+	}
+	else if ( nStatus &  CIM_INSTAT_UFC )
+	{
+		DPRINTK("\n Camera Driver: FIFO-C Underflow Interrupt Recieved \n");  
+		au1200_cim->instat=CIM_INSTAT_UFC;
+		ciminterruptcheck = 1; 
+	}
+	else if ( nStatus &  CIM_INSTAT_OFC )
+	{
+		DPRINTK("\n Camera Driver: FIFO-C Overflow Interrupt Recieved \n");  
+		au1200_cim->instat=CIM_INSTAT_OFC;
+		ciminterruptcheck = 1; 
+	}
+	else if ( nStatus &  CIM_INSTAT_ERR )
+	{
+		DPRINTK("\n Camera Driver: ERR (for 656 Mode) Interrupt Recieved \n"); 
+		au1200_cim->instat=CIM_INSTAT_ERR;
+	}
+	
+	enable_irq(AU1200_CAMERA_INT);
+} 
+
+static int
+au1xxxcim_open(struct inode *inode, struct file *file)
+{
+	DPRINTK("FOPS Open Kernel Routine \n");
+	return 0;
+}
+
+static int
+au1xxxcim_ioctl(struct inode *inode, struct file *file,
+				unsigned int cmd, unsigned long arg)
+{
+	nInterruptDoneNumber=0; 
+	int mode_index;
+	uint32 i;   
+	CAMERA_RUNTIME *capture;
+	CAMERA *capture_ptr;
+
+	capture=pcam_base;
+      
+	switch (cmd)
+	{
+ 
+	case AU1XXXCIM_QUERY:{
+                     		/*returing previous mode*/
+					DPRINTK("QUERY Mode- Return Camera Index to Application is %d \n", prev_mode);
+                 		 return prev_mode;
+		      }
+	case AU1XXXCIM_CONFIGURE: {
+					DPRINTK(" CONFIGURE Mode\n");
+					mode_index=find_mode_index(arg);
+				    if (mode_index == -1){
+					   printk(" Unsupported Mode. This mode is not supported in current driver \n");
+						if(check_mode !=1)
+					   	{
+						  	capture->cmos_camera=OrigCimArryPtr+prev_mode; 
+				         	capture_ptr=capture->cmos_camera;
+						 	CIM_Cleanup(capture);
+					  	 }
+					  check_mode=1;
+					  return  0;
+					}
+					else
+					{
+						if(check_mode !=1){
+							capture->cmos_camera=OrigCimArryPtr+prev_mode; 
+							capture_ptr=capture->cmos_camera;
+			   				DPRINTK("CONFIGURE Mode: Calling CleanUP as Camera needs to be re-configured \n");
+							CIM_Cleanup(capture); 
+						 }
+					}
+					DPRINTK("CONFIGURE:Camera Array Index value is %d \n", mode_index);
+			      	capture->cmos_camera=OrigCimArryPtr+mode_index;
+					capture_ptr=capture->cmos_camera;
+					DPRINTK(" CONFIGURE: Camera configured in  ** %s ** Mode \n", capture_ptr->camera_mode);
+		    		au1200_cim->enable &= ~CIM_ENABLE_EN;
+					Camera_Config(capture);
+					Camera_pwr_down();
+					mdelay(2);
+					Camera_pwr_up();
+					mdelay(7);
+				   	prev_mode=mode_index;
+					check_mode=0;
+					printk(" Prev_mode %d mode_index %d \n", prev_mode, mode_index);
+					return mode_index;
+          	      }
+case AU1XXXCIM_CAPTURE: {
+                   
+                    if(check_mode == 1){
+                     printk(" Unsupported Mode. This mode is not supported in current driver \n");
+					 return 0;
+					 } 
+					 
+					capture->cmos_camera=OrigCimArryPtr+prev_mode; 
+					capture_ptr=capture->cmos_camera;
+					DPRINTK("CAPTURE: Camera Array Index # %d \n", prev_mode);
+					DPRINTK("CAPTURE:Picture taken in **%s** Mode \n", capture_ptr->camera_mode);
+					Capture_Image();
+					DPRINTK("CAPTURE:Status Reg %x Capture Reg %x \n", au1200_cim->stat, au1200_cim->capture);
+					DPRINTK("Waiting for %d DMA Interrupt \n",capture_ptr->dbdma_channel);
+                	while ( (nInterruptDoneNumber != (capture_ptr->dbdma_channel)) && (!ciminterruptcheck) );
+
+                 	if(ciminterruptcheck)
+				 	{
+				   		printk(" !! ERROR: DMA Transfer Error  \n");
+				   		ciminterruptcheck = 0;
+				   		return 0; 
+				    }
+								
+                	DPRINTK("CAPTURE:Putting back descriptor back to ring\n");
+					for (i=0; i< capture_ptr->dbdma_channel; i++)
+					{
+						if ( ! au1xxx_dbdma_put_dest((u32)( capture->ChannelArray[i]),  
+							capture->memory[i],  capture->nTransferSize[i]) )
+						{
+							printk("DBDMA Error..Putting Descriptor on Buffer Ring Channel A in Single Channel \n");
+					   	}
+					}
+					DPRINTK(" CAPTURE: Exiting Capture \n");  
+				
+					return 1;
+                    break;        
+		   	} 
+
+	}
+}
+
+static int 
+au1xxxcim_mmap(struct file* file, struct vm_area_struct *vma)
+{
+	unsigned int len;
+	unsigned long start=0, off;
+
+	if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) 
+        {
+		printk(" Error vma->vm_pgoff > !OUL PAGE_SHIFT \n");
+		 return -EINVAL;
+		}
+
+	start = virt_to_phys(mem_buf) & PAGE_MASK;
+	len = PAGE_ALIGN((start & ~PAGE_MASK) + 2*MAX_FRAME_SIZE);
+	off = vma->vm_pgoff << PAGE_SHIFT;
+	
+	if ((vma->vm_end - vma->vm_start + off) > len) 
+	 {
+		printk(" Error vma->vm_end-vma->vm_start\n");
+		return -EINVAL;
+	 }
+	 
+	off += start;
+	vma->vm_pgoff = off >> PAGE_SHIFT;
+	pgprot_val(vma->vm_page_prot) &= ~_CACHE_MASK;
+	pgprot_val(vma->vm_page_prot) |= PAGE_CACHABLE_DEFAULT;
+	
+	/* This is an IO map - tell maydump to skip this VMA */
+	vma->vm_flags |= VM_IO;
+	
+	if (io_remap_page_range(vma,vma->vm_start, off,
+				vma->vm_end - vma->vm_start,
+				vma->vm_page_prot)) 
+	{
+		return -EAGAIN;
+	}