mmc_core.c

包含MMC协议,驱动源码. 在LINUX操作系统下通过.

	if ( !(state & STATE_INSERT) ) 
		return 0;

	for ( i = 0 ; i < dev->num_slots ; i++ ) {
		struct mmc_slot *slot = dev->slot + i;

		if ( slot->flags & MMC_SLOT_FLAG_INSERT ) {
			if  (!dev->sdrive->is_empty(i)) {
				slot->dev = dev;
				slot->state = CARD_STATE_IDLE;
				card_count++;
			}
			slot->flags &= ~MMC_SLOT_FLAG_INSERT;
		}
	}
	return card_count;
}

/******************************************************************
 *
 * Hotplug callback card insertion/removal
 *
 ******************************************************************/
 
#if !defined(CONFIG_OMAP_INNOVATOR) && !defined(CONFIG_MACH_OMAP_PERSEUS2)
#ifdef CONFIG_HOTPLUG
extern char hotplug_path[];
extern int call_usermodehelper(char *path, char **argv, char **envp);

static void run_sbin_hotplug(struct mmc_dev *dev, int id, int insert)
{
	int i;
	char *argv[3], *envp[8];
	char media[64], slotnum[16];

	if (!hotplug_path[0])
		return;

	DEBUG(0,": hotplug_path=%s id=%d insert=%d\n", hotplug_path, id, insert);

	i = 0;
	argv[i++] = hotplug_path;
	argv[i++] = "mmc";
	argv[i] = 0;

	/* minimal command environment */
	i = 0;
	envp[i++] = "HOME=/";
	envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
	
	/* other stuff we want to pass to /sbin/hotplug */
	sprintf(slotnum, "SLOT=%d", id );
	if ( dev->slot[id].media_driver && dev->slot[id].media_driver->name )
		sprintf(media, "MEDIA=%s", dev->slot[id].media_driver->name );
	else
		sprintf(media, "MEDIA=unknown");

	envp[i++] = slotnum;
	envp[i++] = media;

	if (insert)
		envp[i++] = "ACTION=add";
	else
		envp[i++] = "ACTION=remove";
	envp[i] = 0;

	call_usermodehelper (argv [0], argv, envp);
}

static void mmc_hotplug_task_handler( void *nr )
{
	int insert = ((int) nr) & 0x01;
	int id     = ((int) nr) >> 1;
	DEBUG(2," id=%d insert=%d\n", id, insert );
	run_sbin_hotplug(&g_mmc_dev, id, insert );
}

static struct tq_struct mmc_hotplug_task = {
	routine:  mmc_hotplug_task_handler
};

void run_sbin_mmc_hotplug(struct mmc_dev *dev, int id, int insert )
{
//#ifdef CONFIG_ARCH_EZX_E680
	if (first_have_card)
	{
	    first_have_card = 0;
	    return;
	}
//#endif
	mmc_hotplug_task.data = (void *) ((id << 1) | insert);
	schedule_task( &mmc_hotplug_task );
}
#else
void run_sbin_mmc_hotplug(struct mmc_dev *sdev, int id, int insert) { }
#endif /* CONFIG_HOTPLUG */
#else
void run_sbin_mmc_hotplug(struct mmc_dev *sdev,  int id, int insert) { }
#endif

/******************************************************************
 * Common processing tasklet
 * Everything gets serialized through this
 ******************************************************************/

static void mmc_tasklet_action(unsigned long data)
{
	struct mmc_dev *dev = (struct mmc_dev *)data;
	unsigned long   flags;
	int             state;

	DEBUG(2,": dev=%p flags=%02x\n", dev, dev->state);

	/* Grab the current working state */
	local_irq_save(flags);
	state = dev->state;
	if ( state & STATE_CMD_DONE )
		dev->state = state & ~(STATE_CMD_DONE | STATE_CMD_ACTIVE);
	local_irq_restore(flags);

	/* If there is an active command, don't do anything */
	if ( (state & STATE_CMD_ACTIVE) && !(state & STATE_CMD_DONE) )
		return;

	if ( dev->protocol )
		dev->protocol(dev,state);
}

/******************************************************************
 * Callbacks from low-level driver
 * These run at interrupt time
 ******************************************************************/

void mmc_cmd_complete(struct mmc_request *request)
{
	DEBUG(2,": request=%p retval=%d\n", request, request->result);
	g_mmc_dev.state |= STATE_CMD_DONE;
	if ( !g_mmc_dev.suspended )
		tasklet_schedule(&g_mmc_dev.task);
}

void mmc_insert(int slot)
{
	DEBUG(2,": %d\n", slot);
	g_mmc_dev.state |= STATE_INSERT;
	g_mmc_dev.slot[slot].flags |= MMC_SLOT_FLAG_INSERT;
	if ( !g_mmc_dev.suspended )
		tasklet_schedule(&g_mmc_dev.task);
	mmc_slot_enable = 1;
}

void mmc_eject(int slot)
{
	DEBUG(2,": %d\n", slot);
	g_mmc_dev.state |= STATE_EJECT;
	g_mmc_dev.slot[slot].flags |= MMC_SLOT_FLAG_EJECT;
	if ( !g_mmc_dev.suspended )
		tasklet_schedule(&g_mmc_dev.task);
	mmc_slot_enable = 0;
}

EXPORT_SYMBOL(mmc_cmd_complete);
EXPORT_SYMBOL(mmc_insert);
EXPORT_SYMBOL(mmc_eject);

/******************************************************************
 * Called from the media handler
 ******************************************************************/

int mmc_handle_io_request( struct mmc_io_request *t )
{
	DEBUG(2," id=%d cmd=%d sector=%ld nr_sectors=%ld block_len=%ld buf=%p\n",
	      t->id, t->cmd, t->sector, t->nr_sectors, t->block_len, t->buffer);
	
	if ( g_mmc_dev.io_request ) {
		/* FIXME : Urgly solution here */
		if (g_mmc_dev.next_io_request || (g_mmc_dev.io_request->cmd == t->cmd)) {
			DEBUG(0,": error! io_request in progress\n");
			return 0;
		} 
		else {
			g_mmc_dev.next_io_request = t;
			return 1;
		}
	}
	
	g_mmc_dev.io_request = t;
	tasklet_schedule(&g_mmc_dev.task);
	return 1;
}

EXPORT_SYMBOL(mmc_handle_io_request);

/******************************************************************
 *  Media handlers
 *  Allow different drivers to register a media handler
 ******************************************************************/

static LIST_HEAD(mmc_media_drivers);

int mmc_match_media_driver( struct mmc_slot *slot )
{
	struct list_head *item;

	DEBUG(2,": slot=%p\n", slot);

	for ( item = mmc_media_drivers.next ; item != &mmc_media_drivers ; item = item->next ) {
		struct mmc_media_driver *drv = list_entry(item, struct mmc_media_driver, node );
		if ( drv->probe(slot) ) {
			slot->media_driver = drv;
			drv->load(slot);
			return 1;
		}
	}
	return 0;
}

int mmc_register_media_driver( struct mmc_media_driver *drv )
{
	list_add_tail( &drv->node, &mmc_media_drivers );
	return 0;
}

void mmc_unregister_media_driver( struct mmc_media_driver *drv )
{
	list_del(&drv->node);
}

EXPORT_SYMBOL(mmc_register_media_driver);
EXPORT_SYMBOL(mmc_unregister_media_driver);

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

int mmc_register_slot_driver( struct mmc_slot_driver *sdrive, int num_slots )
{
	int i;
	int retval;

	DEBUG(2," max=%d ocr=0x%08x\n", num_slots, sdrive->ocr);

	if ( num_slots > MMC_MAX_SLOTS ) {
		printk(KERN_CRIT "%s: illegal num of slots %d\n", __FUNCTION__, num_slots);
		return -ENOMEM;
	}

	if ( g_mmc_dev.sdrive ) {
		printk(KERN_ALERT "%s:: slot in use\n", __FUNCTION__);
		return -EBUSY;
	}

	g_mmc_dev.sdrive    = sdrive;
	g_mmc_dev.num_slots = num_slots;

	for ( i = 0 ; i < num_slots ; i++ ) {
		struct mmc_slot *slot = &g_mmc_dev.slot[i];
		memset(slot,0,sizeof(struct mmc_slot));
		slot->id = i;
		slot->state = CARD_STATE_EMPTY;
	}
	retval = sdrive->init();
	if ( retval )
		return retval;
#ifndef CONFIG_ARCH_EZX_HAINAN
	/* Generate insert events for cards */
	for ( i = 0 ; i < num_slots ; i++ )
		if ( !sdrive->is_empty(i) )
			mmc_insert(i);
#endif
	return 0;
}

void mmc_unregister_slot_driver( struct mmc_slot_driver *sdrive )
{
	int i;
	DEBUG(2,"\n");

	for ( i = 0 ; i < g_mmc_dev.num_slots ; i++ )
		mmc_eject(i);

	if ( sdrive == g_mmc_dev.sdrive ) {
		g_mmc_dev.sdrive->cleanup();
		g_mmc_dev.sdrive = NULL;
	}
}

EXPORT_SYMBOL(mmc_register_slot_driver);
EXPORT_SYMBOL(mmc_unregister_slot_driver);

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

static struct pm_dev *mmc_pm_dev;

static int mmc_pm_callback(struct pm_dev *pm_dev, pm_request_t req, void *data)
{
#ifndef CONFIG_ARCH_EZX
	int i;
	DEBUG(0,": pm callback %d\n", req );

	switch (req) {
	case PM_SUSPEND: /* Enter D1-D3 */
		g_mmc_dev.suspended = 1;
                break;
	case PM_RESUME:  /* Enter D0 */
		if ( g_mmc_dev.suspended ) {
			g_mmc_dev.suspended = 0;
			g_mmc_dev.state = 0;     // Clear the old state
			for ( i = 0 ; i < g_mmc_dev.num_slots ; i++ ) {
				mmc_eject(i);
				if ( !g_mmc_dev.sdrive->is_empty(i) )
					mmc_insert(i);
			}
		}
		break;
        }
#endif
        return 0;
}

#ifdef CONFIG_CEE
#include <linux/device.h>

static int mmc_suspend(struct device *dev, u32 state, u32 level);
static int mmc_resume(struct device *dev, u32 level);

static struct device_driver mmc_driver_ldm = {
	name:          "mmc",
	devclass:      NULL,
	probe:         NULL,
	suspend:       mmc_suspend,
	resume:        mmc_resume,
	scale:         NULL,
	remove:        NULL,
};

static struct device mmc_device_ldm = {
	name:         "MMC",
	bus_id:       "mmc",
	driver:       NULL,
	power_state:  DPM_POWER_ON,
};

static void
mmc_ldm_register(void)
{
#ifdef CONFIG_ARCH_MAINSTONE
	extern void pxaopb_driver_register(struct device_driver *driver);
	extern void pxaopb_device_register(struct device *device);
	
	pxaopb_driver_register(&mmc_driver_ldm);
	pxaopb_device_register(&mmc_device_ldm);
#endif
#ifdef CONFIG_ARCH_OMAP
   extern void mpu_public_driver_register(struct device_driver *driver);
   extern void mpu_public_device_register(struct device *device);

   mpu_public_driver_register(&mmc_driver_ldm);
   mpu_public_device_register(&mmc_device_ldm);
#endif
#ifdef CONFIG_ARCH_MX2ADS
	extern void mx21_ldm_device_register(struct device *device);
	extern void mx21_ldm_driver_register(struct device_driver *driver);

	mx21_ldm_driver_register(&mmc_driver_ldm);
	mx21_ldm_device_register(&mmc_device_ldm);
#endif
}

static void
mmc_ldm_unregister(void)
{
#ifdef CONFIG_ARCH_MAINSTONE
	extern void pxaopb_driver_unregister(struct device_driver *driver);
	extern void pxaopb_device_unregister(struct device *device);
	
	pxaopb_device_unregister(&mmc_device_ldm);
	pxaopb_driver_unregister(&mmc_driver_ldm);
#endif
#ifdef CONFIG_ARCH_OMAP
   extern void mpu_public_driver_unregister(struct device_driver *driver);
   extern void mpu_public_device_unregister(struct device *device);

   mpu_public_driver_unregister(&mmc_driver_ldm);
   mpu_public_device_unregister(&mmc_device_ldm);
#endif
#ifdef CONFIG_ARCH_MX2ADS
	extern void mx21_ldm_device_unregister(struct device *device);
	extern void mx21_ldm_driver_unregister(struct device_driver *driver);

	mx21_ldm_device_unregister(&mmc_device_ldm);
	mx21_ldm_driver_unregister(&mmc_driver_ldm);
#endif
}

static int
mmc_resume(struct device *dev, u32 level)
{
	int i;

	switch (level) {
	case RESUME_RESTORE_STATE:
	case RESUME_ENABLE:
	case RESUME_POWER_ON:
		/* Enter D0 */
		if ( g_mmc_dev.suspended ) {
			g_mmc_dev.suspended = 0;
			g_mmc_dev.state = 0;     // Clear the old state
			for ( i = 0 ; i < g_mmc_dev.num_slots ; i++ ) {
				mmc_eject(i);
				if ( !g_mmc_dev.sdrive->is_empty(i) )
					mmc_insert(i);
			}
		}
		break;
	}
	return 0;
}

static int
mmc_suspend(struct device *dev, u32 state, u32 level)
{
	switch (level) {
	case SUSPEND_NOTIFY:
	case SUSPEND_SAVE_STATE:
	case SUSPEND_DISABLE:
	case SUSPEND_POWER_DOWN:
		/* Enter D1-D3 */
		g_mmc_dev.suspended = 1;
		break;
	}
	return 0;
}

#endif /* CONFIG_CEE */

/******************************************************************
 * TODO: These would be better handled by driverfs
 * For the moment, we'll just eject and insert everything
 ******************************************************************/

int mmc_do_eject(ctl_table *ctl, int write, struct file * filp, void *buffer, size_t *lenp)
{
	mmc_eject(0);
	return 0;
}

int mmc_do_insert(ctl_table *ctl, int write, struct file * filp, void *buffer, size_t *lenp)
{
	mmc_insert(0);
	return 0;
}


static struct ctl_table mmc_sysctl_table[] =
{
	{ 1, "debug", &g_mmc_debug, sizeof(int), 0666, NULL, &proc_dointvec },
	{ 2, "eject", NULL, 0, 0600, NULL, &mmc_do_eject },
	{ 3, "insert", NULL, 0, 0600, NULL, &mmc_do_insert },
	{0}
};

static struct ctl_table mmc_dir_table[] =
{
	{BUS_MMC, "mmc", NULL, 0, 0555, mmc_sysctl_table},
	{0}
};

static struct ctl_table bus_dir_table[] = 
{
	{CTL_BUS, "bus", NULL, 0, 0555, mmc_dir_table},
        {0}
};

static struct ctl_table_header *mmc_sysctl_header;

#ifdef CONFIG_USBD_ISP_BUS

static unsigned int read_request_head = 0;
static unsigned int read_request_tail = 0;
static struct read_request_pool_s read_request_pool[MAX_READ_AHEAD_REQUEST];
static struct dma_buf_pool_s *write_request_pool[MAX_WRITE_PENDING_REQUEST];
static struct mmc_io_request gg_io_read_request, gg_io_write_request[MAX_WRITE_PENDING_REQUEST];
static unsigned int write_request_head = 0;
static unsigned int write_request_tail = 0;
void (*old_io_request_done)(struct mmc_io_request * req, int result);

LIST_HEAD(dma_write_buf_pool_head);
LIST_HEAD(dma_read_buf_pool_head);

struct dma_buf_pool_s dma_write_buf_pool[MAX_BUF_POOL_SIZE];