mmc_main.c.bak

MMC 0.4.0驱动 龙珠 MOTO板子

		
		j = 0xFF;
		while(j--);

		if(g_mmcsd_status&0x000B)
		{
			FAILED("Read Error (status = 0x%lx",(unsigned long)g_mmcsd_status);
			ret = MMCSD_ERROR;
			goto signle_read_end;
		}
/*		if(g_mmcsd_status&0x0008)
		{
			goto single_read_try_again;
		}
*/
		if((g_mmcsd_status&0x0080)!=0)		// Buffer is FULL 
		{
			//TRACE("FIFO is full");
			if(device->bit_width == 0)		
			{
				for(i = 0;i < 8; i++)
				{
#ifdef CONFIG_ARCH_MX2ADS
					if(device->port == 1)
						temp32 = mmcsdr_buffer_access_2;
					else
						temp32 = mmcsdr_buffer_access;
#endif
#ifdef CONFIG_ARCH_MX1ADS
					g_mmcsd_status = (mmcsdr_status);
#endif
						
					temp16 = (u16)temp32;
#ifdef MMCSD_DMA_ENDIAN_ERR
					*pbuff = (temp16&0xFF00)>>8;
					pbuff++;
					*pbuff = (temp16&0x00FF);
					pbuff++;
#else
					*pbuff = (temp16&0x00FF);
					pbuff++;
					*pbuff = (temp16&0xFF00)>>8;
					pbuff++;				
#endif
				}
				total += 16;
			}
			else
			{
				for(i = 0;i < 32; i++)
				{
#ifdef CONFIG_ARCH_MX2ADS
					if(device->port == 1)
						temp32 = mmcsdr_buffer_access_2;
					else
						temp32 = mmcsdr_buffer_access;
#endif
#ifdef CONFIG_ARCH_MX1ADS
					temp32 = mmcsdr_buffer_access;
#endif

					temp16 = (u16)temp32;
#ifdef MMCSD_DMA_ENDIAN_ERR
					*pbuff = (temp16&0xFF00)>>8;
					pbuff++;
					*pbuff = (temp16&0x00FF);
					pbuff++;
#else
					*pbuff = (temp16&0x00FF);
					pbuff++;
					*pbuff = (temp16&0xFF00)>>8;
					pbuff++;
#endif
				}
				total += 64;
			}
		}

		if((g_mmcsd_status&0x0800) != 0)	// TRANS Done
		{
			//TRACE("Transfer done! g_mmcsd_status = 0x%x",g_mmcsd_status);
			ret = MMCSD_OK;
			goto signle_read_end;
			
		}

//		TRACE("Sleep on.. status=%x",g_mmcsd_status);
//		interruptible_sleep_on(&(device->select_wait));
//		TRACE("Waked up ! status = 0x%x",g_mmcsd_status);
//
	}


signle_read_end:

	_MMCSD_StopClk(device->port);
	_MMCSD_Restore_Mask(int_mask,device->port);

	g_mmcsd_cmd[device->port] = 0;
	return ret;

}

/******************************************************************************
 * Function Name: mmcsd_DmaStartTransfer
 *
 * Input:   
 *
 * Value Returned:     
 *
 * Description: 
 * 	
 *
 * Modification History:
 *****************************************************************************/

int mmcsd_DmaStartTransfer(MMCSD_Dev *device,u8 * buff,u32 counter, u8 mode,u8 is_4_bit)
{
	int channel;

	channel = device->dma_channel;
	if(mode == MMCSD_READ)
	{
#ifdef CONFIG_ARCH_MX1ADS
		_reg_DMA_DAR(channel) = (u32)__virt_to_phys(buff);
		_reg_DMA_SAR(channel) = (MMCSDR_BUFFER_ACCESS&0x0FFFFFFF);
		_reg_DMA_CNTR(channel) = counter; 

		_reg_DMA_CCR(channel) = 0x00000828;	// Source Size = 16,Des Len = 32 
		_reg_DMA_RSSR(channel) = 0xD;
		if(is_4_bit)
		{
			_reg_DMA_BLR(channel) = 0x0;			// Burst Len 64;
			//_reg_DMA_BLR(channel) = 0x20;			// Burst Len 32;
		}
		else
		{
			_reg_DMA_BLR(channel) = 0x10;			// Burst Len 16;
		}
#endif
#ifdef CONFIG_ARCH_MX2ADS
		(device->dma).sourceType = DMA_TYPE_FIFO;
		(device->dma).sourcePort = DMA_MEM_SIZE_16;
		(device->dma).destType = DMA_TYPE_LINEAR;
		(device->dma).destAddr = (u32*)__virt_to_phys(buff);
		(device->dma).destPort = DMA_MEM_SIZE_32;
		(device->dma).count = counter;
		if(device->port == 0)
		{
			(device->dma).sourceAddr = (u32*)0x10013038;//sdhc1, 
			(device->dma).request = 0x7;//sdhc1 		
		}
		else
		{
			(device->dma).sourceAddr = (u32*)0x10014038;// for sdhc2 is 0x10014038
			(device->dma).request = 0x6;// sdhc2 is 0x6;		
		}
		
		if(is_4_bit)
		{
			(device->dma).burstLength = 0x0; //burst length 64
		}
		else
		{
			(device->dma).burstLength = 0x10; //burst len 16
		}
		mx_dma_set_config(device->dma_channel,&(device->dma));
//		mx_dump_dma_register(device->dma_channel);

#endif
	}
	else 
	{
#ifdef CONFIG_ARCH_MX1ADS
	//	_reg_DMA_SAR(channel) = (u32)_MMCSD_get_phy_addr(buff);
		_reg_DMA_SAR(channel) = (u32)__virt_to_phys(buff);
		_reg_DMA_DAR(channel) = (MMCSDR_BUFFER_ACCESS&0x0FFFFFFF);
		_reg_DMA_CNTR(channel) = counter; 

		//_reg_DMA_CCR(channel) = 0x00002088;	// Source Size = 32,Des Len = 16 
		_reg_DMA_CCR(channel) = 0x2088;	// Source Size = 32,Des Len = 16 
		_reg_DMA_RSSR(channel) = 0xD;

		if(is_4_bit)
		{
			_reg_DMA_BLR(channel) = 0x0;		// Burst Len 64;
			//_reg_DMA_BLR(channel) = 0x20;		// Burst Len 32;
		}
		else
		{
			_reg_DMA_BLR(channel) = 0x10;		// Burst Len 16;
		//	_reg_DMA_BLR(channel) = 0x8;		// Burst Len 8;
		}
#endif
#ifdef CONFIG_ARCH_MX2ADS
		(device->dma).sourceType = DMA_TYPE_LINEAR;
		//(device->dma).sourceAddr = (u32)__virt_to_phys(buff);
		(device->dma).sourcePort = DMA_MEM_SIZE_32;

		(device->dma).destType = DMA_TYPE_FIFO;
		(device->dma).destPort = DMA_MEM_SIZE_16;
		
		(device->dma).count = counter;
		if(device->port == 0)
		{
			(device->dma).destAddr = (u32*)0x10013038;//sdhc1
			(device->dma).request = 7;//sdhc1 		
		}
		else
		{
			(device->dma).destAddr = (u32*)0x10014038;//for sdhc2 is 0x10014038
			(device->dma).request = 0x6;//sdhc2 is 0x6;		
		}

		if(is_4_bit)
		{
			(device->dma).burstLength = 0x0; //burst length 64
		}
		else
		{
			(device->dma).burstLength = 0x10; //burst len 16
		}

		mx_dma_set_config(device->dma_channel,&(device->dma));

#endif
	}
				
	return MMCSD_OK;
}

/******************************************************************************
 * Function Name: mmcsd_dma_handler
 *
 * Input:   
 *
 * Value Returned:     
 *
 * Description: 
 * 	
 *
 * Modification History:
 *****************************************************************************/

void mmcsd_dma_isr(void *arg)
{
	MMCSD_Dev *device;

	device = g_selected_lock[0].device;

	if(device == NULL)
	{
		TRACE("\nmmcsd_interrupt_handler: no device");
		return;
	}

	g_mmcsd_status = (mmcsdr_status);


	//TRACE("(status = 0x%x)",g_mmcsd_status);

//	if(g_mmcsd_status&0x803)   // It should be here, but sometimes no 0x800 return.
	{
		device->result = g_mmcsd_status;
		wake_up_interruptible(&(device->select_wait));
	//	TRACE("Wake Up ...");
	}

}

#ifdef CONFIG_ARCH_MX2ADS
void mmcsd_dma_isr_1(void * arg)
{
	MMCSD_Dev *device;

	device = g_selected_lock[1].device;

	if(device == NULL)
	{
		TRACE("\nmmcsd_interrupt_handler: no device");
		return;
	}

	g_mmcsd_status = (mmcsdr_status_2);


	//TRACE("(status = 0x%x)",g_mmcsd_status);

//	if(g_mmcsd_status&0x803)   // It should be here, but sometimes no 0x800 return.
	{
		device->result = g_mmcsd_status;
		wake_up_interruptible(&(device->select_wait));
	//	TRACE("Wake Up ...");
	}

}
#endif

void mmcsd_dma_err_isr(int error_type)
{
	MMCSD_Dev *device;

	device = g_selected_lock[0].device;

	if(device == NULL)
	{
		TRACE("mmcsd_interrupt_handler: no device");
		return;
	}

	g_mmcsd_status = (mmcsdr_status);

	device->result = g_mmcsd_status;
	TRACE("error_type = 0x%x",error_type);

	wake_up_interruptible(&(device->select_wait));

}

#ifdef CONFIG_ARCH_MX2ADS
void mmcsd_irq_handler_2(int irq,void * data, struct pt_regs * pt)
{
	MMCSD_Dev *device;

	mmcsdr_int_mask_2 |= 0x40;
	device = g_selected_lock[1].device;
	if(device == NULL)
	{
		return; 
	}
	g_mmcsd_status = (mmcsdr_status_2);

	device->result = g_mmcsd_status;

	if(g_mmcsd_cmd[device->port] != 0xFF)
	{
		wake_up_interruptible(&(device->select_wait));
	}
}
#endif

void mmcsd_irq_handler(int irq,void * data, struct pt_regs * pt)
{
	MMCSD_Dev *device;

	mmcsdr_int_mask |= 0x40;

	device = g_selected_lock[0].device;
	if(device == NULL)
	{
		return; 
	}
//	TRACE("The Device not empty...");
	g_mmcsd_status = (mmcsdr_status);
	//TRACE("irq is called (%d), g_mmcsd_status = 0x%0X",g_mmcsd_cmd,g_mmcsd_status);

	device->result = g_mmcsd_status;

//	TRACE("Wake up the deice.. (status 0x%x)",device->result);

	if(g_mmcsd_cmd[device->port] != 0xFF)
	{
		wake_up_interruptible(&(device->select_wait));
	}

}

/**
 *@brief mmc ioctl routine
 *
 * Function Name: mmcsd_ioctl
 *
 *
 * Description:This routine will implement driver-specific functions
 *
 *@param 		inode	:	the pointer to driver-related inode.
 *@param 		filp	:	the pointer to driver-related file structure.
 *@param		command	:	the command number.
 *@param		argument:	argument which depends on command.
 *
 *@return	int   return status
 *			@li 0  sucess
 *			@li 1  failure
 *
 * Modification History:
 *   
 **/

static int mmcsd_ioctl(struct inode *inode,
			struct file *filp,
			unsigned command,
			unsigned long  argument)
{
   	int num,ret;
   	MMCSD_Dev *device;
	MMCSD_PWD *pwd;
	MMCSD_Blks blks;
	u32 	addr;
//	apmc_set_level(g_Mmc_apmc,APMC_LEVEL_LOWEST);

   struct 	hd_geometry hdGeometry;

	int sectors, total_sectors;
	//int diskinfo[4];
	//kdev_t dev = inode->i_rdev;

	TRACE("mmcsd_ioctl is called!");
	num = MINOR(inode->i_rdev);

	if(!filp)
	{
		TRACE("called without filp");
		return -EIO;
	}

	if(num > g_mmcsd_num)
	{
		return -ENODEV;
	}
	device = &g_mmcsd_devices[num];
		_reg_CRM_PCCR0 |= 0x0200;//disable sdhc1 clk
		_reg_CRM_PCCR0 |= 0x0400;//disable sdhc2 clk
		_MMCSD_StartClk(0);
		_MMCSD_StartClk(1);
			_MMCSD_SetClk(MMCSD_HIGH_SPEED,0);
#ifdef CONFIG_ARCH_MX2ADS
			_MMCSD_SetClk(MMCSD_HIGH_SPEED,1);
#endif

    switch(command) {

	case BLKFLSBUF:
	case BLKRAGET:
	        return blk_ioctl(inode->i_rdev, command, argument);

	case BLKGETSIZE:

		if (!argument) return -EINVAL; /* NULL pointer: not valid */

		if (copy_to_user((long *) argument, &(device->dev_size), sizeof (long)))
		{
			return -EFAULT;
		}
		return 0;
	
	case MMCSDSECTORSIZE:
		
		if (!argument) return -EINVAL; /* NULL pointer: not valid */
		
		if(copy_to_user((u16 *)argument, 
				&(device->phy_sectorsize),
				sizeof(u16)))
		{
			return -EFAULT;
		}
		return 0;

	case MMCSDERASESECTOR:

		if (!argument) return -EINVAL; /* NULL pointer: not valid */
		
		if (copy_from_user(&blks, (MMCSD_Blks *)argument, sizeof (blks)))
		{
			return -EFAULT;
		}

		return(mmcsd_sector_erase(device, &blks));

	case MMCSDPROTECT:

		if (!argument) return -EINVAL; /* NULL pointer: not valid */
		if (copy_from_user(&addr,(u32*)argument, sizeof(u32)))
		{
			return -EFAULT;
		}
		return(mmcsd_write_protect(device,addr,1));

	case MMCSDCLEPROTECT:
		if (!argument) return -EINVAL; /* NULL pointer: not valid */
		if (copy_from_user(&addr,(u32*)argument, sizeof(u32)))
		{
			return -EFAULT;
		}

		return(mmcsd_write_protect(device,addr,0));

	case MMCSDSETPW:
	case MMCSDRESETPW:
	case MMCSDLOCK:
	case MMCSDUNLOCK:
	case MMCSDFORCERASE: 

		pwd = (MMCSD_PWD *)kmalloc((2+((MMCSD_PWD *)argument)->len),GFP_KERNEL|GFP_DMA);
		if(pwd == NULL)
		{
			TRACE("\nmmcsd_ioctl: kmalloc error");
			return 1;
		}

		if (copy_from_user(pwd,(MMCSD_PWD *)argument, sizeof((2+((MMCSD_PWD *) argument)->len))))
		{
			return -EFAULT;
		}
		ret = mmcsd_passwd_cmd(device,pwd);

		kfree(pwd);

		return(ret);
    case HDIO_GETGEO:   /* Return BIOS disk parameters */
	{
		printk("read disk geometry \n");
			sectors = gMmcSectorInfor.sectors[1]<<8|gMmcSectorInfor.sectors[0];
    		total_sectors = sectors ? sectors : CF_LE_L(gMmcSectorInfor.total_sect);
		
        	hdGeometry.cylinders = (total_sectors & ~0x3f) >> 6;
			hdGeometry.heads = 4;
			hdGeometry.sectors = 16;
			hdGeometry.start = 4;
			copy_to_user((void *)argument, &hdGeometry, sizeof(hdGeometry));
		return 0;
	}

	default:

	        return blk_ioctl(inode->i_rdev, command, argument);

	}

    return 0; /* unknown command */
}

/******************************************************************************
 * Function Name: mmcsd_write_protect
 *
 * Input:
 * 		device:	 	pointer to the specified device.
 * 		addr:		the address of the indicated group.
 * 		is_set:		TRUE, if set the write protection; False, clear
 * 				the write protection.
 *
 * Value Returned:
 *		0	:	succeed
 *		1	:	fail
 *
 * Description:
 * 	This routine will set/clear the write protection bit for addressed 
 * 	group.
 *
 * Modification History:
 *****************************************************************************/

static i