mmc_media.c

spi driver for sd /mmc card

		
		dev = mmc_media_locate_device(CURRENT);
		if ( !dev ) {
			end_request(0);
			continue;
		}

		DEBUG(2," (%p): cmd %i sec %li (nr. %li)\n", CURRENT,
		      CURRENT->cmd, CURRENT->sector, CURRENT->current_nr_sectors);

		if ( mmc_media_transfer(dev,CURRENT) ) {
			g_busy = 1;
			return;
		}
		end_request(0);  /* There was a problem with the request */
	}
}

void mmc_media_transfer_done( struct mmc_io_request *trans, int result )
{
	unsigned long flags;
	int nsect,nr_sectors;
	struct request *req = CURRENT;
	struct buffer_head *bh = req->bh, *next;
	unsigned char *data = (unsigned char *)bh_pages;
		
	DEBUG(3,": result=%d\n", result);
	spin_lock_irqsave(&io_request_lock, flags);

	nr_sectors = trans->nr_sectors;

	for (;;)
	{
	    if ((req->cmd == READ) && data)
	    {
		memcpy(bh->b_data,data,bh->b_size);
		data += bh->b_size;
            }

	    if (!(next = bh->b_reqnext)) break;
	    if (!(nr_sectors - (next->b_size >> 9))) break;

	    nsect = bh->b_size >> 9;
	    blk_finished_io(nsect);
	    bh->b_reqnext = NULL;
	    bh->b_end_io(bh,result);

	    req->bh = bh = next;
	    next = bh->b_reqnext;

	    req->hard_sector += nsect;
	    req->hard_nr_sectors -= nsect;
	    req->sector = req->hard_sector;
	    req->nr_sectors = req->hard_nr_sectors;

	    req->current_nr_sectors = bh->b_size >> 9;
	    req->hard_cur_sectors = req->current_nr_sectors;
	    if (req->nr_sectors < req->current_nr_sectors) {
		    req->nr_sectors = req->current_nr_sectors;
		    printk("end_request:buffer-list destroyed\n");
	    }

	    req->buffer = bh->b_data;

	    nr_sectors -= nsect;
	}

//#ifdef CONFIG_ARCH_EZX_E680
	/* add by w20598 */
	if (!mmc_slot_enable)
	    if (MMC_IO_READ == trans->cmd)
	        end_request(0);
	    else
	        end_request(1);
	else
	/* add end */ 
//#endif
	    end_request(result);
	g_busy = 0;
	if (!QUEUE_EMPTY)
		mmc_media_request(NULL);  // Start the next transfer
	spin_unlock_irqrestore(&io_request_lock, flags);
}


static struct block_device_operations mmc_bdops = {
	open:               mmc_media_open,
	release:            mmc_media_release,
	ioctl:              mmc_media_ioctl,
	check_media_change: mmc_media_check_change,
	revalidate:         mmc_media_revalidate
};

//#ifdef CONFIG_ARCH_EZX_E680
/*********************************************************************/
/* add by w20598 for hotplug support                                 */
/* if user unplugs the card, driver will prevent from flushing datas */
/* create a new inferface to set driver enable                       */
/*********************************************************************/

/*******************************************************************************
  * Function name:	mmcsysif_open
  * Arguments:		struct inode *
  *			struct file *
  * Return:		int : 0  for successful,
  *			      negative number signaling a error
  * Comments:	open operation
  *******************************************************************************/
static int mmcsysif_open(struct inode * inode, struct file * file)
{
         DEBUG(2,": mmcsysif_usage=%d\n", mmcsysif_usage);
	 
	 if (mmcsysif_usage > 2)
	     return -1;
	     
	 mmcsysif_usage++;
	 
         return 0;
}

/*******************************************************************************
  * Function name:	mmcsysif_release
  * Arguments:		struct inode *
  *			struct file *
  * Return:		int  : 0  for successful,
  *			       negative number signaling a error
  * Comments:	release operation
  *******************************************************************************/
static int mmcsysif_release(struct inode * inode, struct file * file)
{
        if (mmcsysif_usage > 2)
	    return -1;
	    
	mmcsysif_usage--;
	
	DEBUG(2,": mmcsysif_usage=%d\n", mmcsysif_usage);

        return 0;
}

/* ioctl for tcmd. ap_tcmd can run as ezx user */
static int mmcsysif_ioctl_ext(unsigned int cmd, unsigned long arg)
{
        int num = 0;
        struct mmc_media_dev *dev;
        struct mmc_slot *slot;
        unsigned long status;

	dev     = &g_media_dev[num];
	if (dev->slot == NULL)
		return -ENODEV;
	slot    = g_media_dev[num].slot;

	switch(cmd) {
	case IOCMMCGETSIZE:
	    if (!access_ok(VERIFY_WRITE, arg, sizeof(long)))
                return -EFAULT;
            return put_user(dev->nr_sects * dev->read_block_len, (long *)arg);
	    
	case IOCMMCGETCARDCID:
	    if (!access_ok(VERIFY_WRITE, arg, sizeof(struct mmc_cid)))
                return -EFAULT;
            if (copy_to_user ((void *) arg, &(slot->cid), sizeof(struct mmc_cid)))
                return -EFAULT;
            return 0;
		
	case IOCMMCGETCARDCSD:
	    if (!access_ok(VERIFY_WRITE, arg, sizeof(struct mmc_csd)))
                return -EFAULT;
            if (copy_to_user ((void *) arg, &(slot->csd), sizeof(struct mmc_csd)))
                return -EFAULT;
            return 0;
		
	case IOCMMCGETCARDSTATUS:
            if (!access_ok(VERIFY_WRITE, arg, sizeof(int)))
                return -EFAULT;
            status = 0;
            if (slot->dev->sdrive->is_wp && slot->dev->sdrive->is_wp(num))
                status |= 0x1;
            if (copy_to_user((void*) arg, & status, sizeof(unsigned long)))
                return -EFAULT;
            return 0;     
		
	case IOCMMCGETCARDTYPE:
	    if (!access_ok(VERIFY_WRITE, arg, sizeof(long)))
                        return -EFAULT;
            return put_user(g_media_dev[num].slot->sd,(long *)arg);
		
	default:
	      break;
	}

        return -ENOTTY; 

}

static int mmcsysif_ioctl(struct inode *inode, struct file *filp,
                 unsigned int cmd, unsigned long arg)
{
	DEBUG(2," ioctl 0x%x 0x%lx\n", cmd, arg);

	switch(cmd) {
	case IOCMMCSETENABLE:
		if (!access_ok(VERIFY_WRITE, arg, sizeof(long)))
			return -EFAULT;
                if (mmc_slot_enable)
		{
		    DEBUG(3, "slot%d is already enable.\n",arg);
		    return 0;
		}			
		DEBUG(3, "set slot%d enable\n",arg);
		mmc_slot_enable = 1;
		return 0;
	case IOCSETERROR:
		panicdev = (unsigned short)MKDEV(mmc_major,1);
		complete(&fatpanic_completion);
		return 0;
	case IOCMMCEXIST:
		if (!access_ok(VERIFY_WRITE, arg, sizeof(long)))
			return -EFAULT;
		
#ifdef CONFIG_ARCH_EZX_A780
		return put_user(( GPLR(GPIO_MMC_DATA3) & GPIO_bit(GPIO_MMC_DATA3)),(long *)arg);
#else
        return put_user(( GPLR(GPIO_MMC_DETECT) & GPIO_bit(GPIO_MMC_DETECT)),(long *)arg);
#endif


	case IOCMMCGETSIZE:
	case IOCMMCGETCARDCID:
	case IOCMMCGETCARDCSD:
	case IOCMMCGETCARDSTATUS:
	case IOCMMCGETCARDTYPE:
	     return mmcsysif_ioctl_ext(cmd,arg);
	default:
	      break;
	}

	return -ENOTTY; /* should never get here */

}

static ssize_t mmcsysif_read(struct file * filp, char * buf, size_t count, loff_t *ppos)
{
    panicdev = 0;
    init_completion(&fatpanic_completion);
    wait_for_completion(&fatpanic_completion);
    if (!copy_to_user(buf,kdevname((kdev_t) panicdev),5))
	return 0;

    return -1; /* error */	
}

static struct file_operations mmcsysif_bdops = {
       ioctl:      mmcsysif_ioctl,
       open:       mmcsysif_open,
       read:      mmcsysif_read,
       release:    mmcsysif_release
};
//#endif

/******************************************************************/
/* TODO:
   We have a race condition if two slots need to be revalidated at the same
   time.  Perhaps we should walk the list of devices and look for change
   flags?
*/

static void mmc_media_load_task_handler( void *nr )
{
	int slot_id = (int) nr;
	DEBUG(2," slot_id=%d\n", slot_id );
	mmc_media_revalidate(MKDEV(mmc_major,(slot_id<<MMC_SHIFT)));
}

static struct tq_struct mmc_media_load_task = {
	routine:  mmc_media_load_task_handler
};

static void mmc_media_load( struct mmc_slot *slot )
{
	unsigned long flags;
	struct mmc_media_dev *dev  = &g_media_dev[slot->id];
	int i;

	long nr_sects;
	int  write_block_len;
	int  read_block_len;

	spin_lock_irqsave(&dev->lock, flags);

	nr_sects        = (1 + slot->csd.c_size) * (1 << (slot->csd.c_size_mult + 2));
	write_block_len = 1 << slot->csd.write_bl_len;
	read_block_len  = 1 << slot->csd.read_bl_len;

	MOD_INC_USE_COUNT;
	DEBUG(1, " slot=%p nr_sect=%ld write_block_length=%d read_block_len=%d\n", 
	      slot, nr_sects, write_block_len, read_block_len );

	dev->slot            = slot;
	dev->nr_sects        = nr_sects;
	dev->read_block_len  = read_block_len;
	dev->write_block_len = write_block_len;
	dev->changed         = 1;
	mmc_gendisk.nr_real++;

	/* Fix up the block size to match read_block_len */
	/* TODO: can we really do this?  Right now we're affecting blksize_size and hardsect_size */
	for ( i = 0 ; i < (1 << MMC_SHIFT) ; i++ )
		mmc_blk[(slot->id << MMC_SHIFT) + i] = read_block_len;

	mmc_media_load_task.data = (void *) slot->id;
	schedule_task( &mmc_media_load_task );

	spin_unlock_irqrestore(&dev->lock, flags);
}

/* TODO: This is a problem area.  We've lost our card, so we'd like
   to flush all outstanding buffers and requests, remove the partitions from
   the file system, and generally shut everything down.
*/

static void mmc_media_unload( struct mmc_slot *slot )
{
	unsigned long flags;
	struct mmc_media_dev *dev = &g_media_dev[slot->id];

	spin_lock_irqsave(&dev->lock, flags);

//	for ( i = 0 ; i < MMC_SHIFT ; i++ )
//		fsync_dev(MKDEV(mmc_major,slot->id,i));

	MOD_DEC_USE_COUNT;
	DEBUG(1," slot=%p id=%d\n", slot, slot->id);

	dev->slot            = NULL;
	dev->nr_sects        = 0;
	dev->changed         = 1;
	mmc_gendisk.nr_real--;

	mmc_media_load_task.data = (void *) slot->id;
	schedule_task( &mmc_media_load_task );

	spin_unlock_irqrestore(&dev->lock, flags);
}

/* 
   Called once the device has a valid CSD structure
   In the future this should determine what type of card we have
   For the moment, everything is a memory card 
*/

static int mmc_media_probe( struct mmc_slot *slot )
{
	return 1;
}

static struct mmc_media_driver mmc_driver = {
	name:            "flash",
	load:            mmc_media_load,
	unload:          mmc_media_unload,
	probe:           mmc_media_probe,
	io_request_done: mmc_media_transfer_done,
};

/******************************************************************/

static int __init mmc_media_init( void )
{
	int i, result,order;
	DEBUG(0,"Init MMC media\n");
	
#ifdef CONFIG_DEVFS_FS
	mmc_devfs_handle = devfs_mk_dir(NULL, DEVICE_NAME, NULL);
	if (!mmc_devfs_handle) return -EBUSY;
	result = devfs_register_blkdev(mmc_major, DEVICE_NAME, &mmc_bdops);
#else
        result = register_blkdev(mmc_major, DEVICE_NAME, &mmc_bdops);	
#endif	

	if (result < 0) {
		printk(KERN_WARNING "Unable to get major %d for MMC media\n", mmc_major);
		return result;
	}

	if ( !mmc_major ) mmc_major = result;
	DEBUG(3, "register block device /dev/%s* layer with major %d\n",
	      DEVICE_NAME, mmc_major);

//#ifdef CONFIG_ARCH_EZX_E680
/* add by w20598 for mmcsysif */
#ifdef CONFIG_DEVFS_FS
	mmcsysif_de = devfs_register(NULL,"midicomm",DEVFS_FL_AUTO_DEVNUM,
								0, 0, S_IFCHR | S_IRUGO | S_IWUGO,
								&mmcsysif_bdops,NULL);

	if( NULL == mmcsysif_de)
		DEBUG(0,":devfs_register mmcsysif failed");
#else
	result = register_chrdev(mmcsysif_major, "mmcsysif", &mmcsysif_bdops);
	if (result < 0)
	{
		DEBUG(0," :mmcsysif can not get major %d",mmcsysif_major);
		return result;
	}
	if( 0 == mmcsysif_major)
	{
		mmcsysif_major = result;
		DEBUG(2," :mmcsysif:mmcsysif_major = %d",mmcsysif_major);
	}
	DEBUG(2,": register mmcsysif success. major = %d",mmcsysif_major);
#endif
/* add end */
//#endif
	/* Set up global block arrays */
	read_ahead[mmc_major]    = rahead;
	for(i=0 ; i < MMC_NDISK; i++)
		mmc_blk[i] = 512;
	hardsect_size[mmc_major] = mmc_blk;
	for(i=0; i < MMC_NDISK; i++)
		mmc_max[i] = maxsectors;
	max_sectors[mmc_major]   = mmc_max;

	/* Start with zero-sized partitions : we'll fix this later */
	memset(mmc_sizes, 0, sizeof(int) * MMC_NDISK);
	blk_size[mmc_major] = mmc_sizes;

	/* Fix up the gendisk structure */
	mmc_gendisk.part    = mmc_partitions;
	mmc_gendisk.sizes   = mmc_sizes;
	mmc_gendisk.nr_real = 0;
	
#ifdef CONFIG_DEVFS_FS
	mmc_gendisk.de_arr  = &mmc_devfs_handle;
#endif	

	mmc_gendisk.flags   = &mmc_gendisk_flags;
	mmc_gendisk.fops    = &mmc_bdops;

	/* Add ourselves to the global list */
	mmc_gendisk.major = mmc_major;
	add_gendisk(&mmc_gendisk);

	order = 0;
	while (maxsectors > (1<< (order + 2))) order++;

	bh_pages = __get_free_pages(GFP_KERNEL,order);
	
	blk_init_queue(BLK_DEFAULT_QUEUE(mmc_major), DEVICE_REQUEST);
	return mmc_register_media_driver(&mmc_driver);
}

static void mmc_media_cleanup( void )
{
	int i,order;
	DEBUG(0,"\n");

	flush_scheduled_tasks();
	unregister_blkdev(mmc_major, DEVICE_NAME);

	for ( i = 0 ; i < MMC_NDISK; i++ )
		fsync_dev(MKDEV(mmc_major,i));

	mmc_unregister_media_driver(&mmc_driver);

	blk_cleanup_queue(BLK_DEFAULT_QUEUE(mmc_major));

	blk_size[mmc_major]      = NULL;
	hardsect_size[mmc_major] = NULL;
	max_sectors[mmc_major]   = NULL;

	del_gendisk(&mmc_gendisk);

	order = 0;
	while (maxsectors > (1<< (order + 2))) order++;

	if (bh_pages) free_pages(bh_pages,order);

//#ifdef CONFIG_ARCH_EZX_E680	
/* add by w20598 */
#ifdef CONFIG_DEVFS_FS
	devfs_unregister(mmcsysif_de);
#else
	unregister_chrdev(mmcsysif_major,"mmcsysif");
#endif
        DEBUG(3,":mmcsysif quit");
/* add end */
//#endif

#ifdef CONFIG_DEVFS_FS
	devfs_unregister(mmc_devfs_handle);
#endif
	
}

struct mmc_media_module media_module = {
	init:    mmc_media_init,
	cleanup: mmc_media_cleanup
};