devsupport.c

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

		driver = device_driver_get(desc->sdd_prefix);
		if (!driver)
			driver = device_driver_alloc(desc->sdd_prefix);
		pri = device_driver_sysgen_thread_pri_get(desc->sdd_prefix);
		device_driver_thread_pri_set(driver, pri);
		device_driver_devsw_put(driver, desc->sdd_bdevsw, desc->sdd_cdevsw);
	}
#endif
	FIXME("device_driver_init");
}

/*
** Hash a prefix string into a hash table chain.
*/
static int
driver_prefix_hash(char *prefix)
{
#ifdef notyet
	int accum = 0;
	char nextchar;

	while (nextchar = *prefix++)
		accum = accum ^ nextchar;

	return(accum % DEVICE_DRIVER_HASH_SIZE);
#else
	FIXME("driver_prefix_hash");
	return(0);
#endif
}


/*
** Allocate a driver handle.
** Returns the driver handle, or NULL if the driver prefix 
** already has a handle.
** 
** Upper layers prevent races among device_driver_alloc,
** device_driver_free, and device_driver_get*.
*/
device_driver_t
device_driver_alloc(char *prefix)
{
#ifdef notyet
	int which_hash;
	device_driver_t new_driver;
	int s;
		
	which_hash = driver_prefix_hash(prefix);

	new_driver = kern_calloc(1, sizeof(*new_driver));
	ASSERT(new_driver != NULL);
	new_driver->dd_prev = NULL;
	new_driver->dd_prefix = string_table_insert(&driver_prefix_string_table, prefix);
	new_driver->dd_bdevsw = NULL;
	new_driver->dd_cdevsw = NULL;

	dev_admin_registry_init(&new_driver->dd_dev_admin_registry);
	device_driver_admin_info_update(new_driver);

	s = mutex_spinlock(&device_driver_lock[which_hash]);

#if DEBUG
	{
		device_driver_t drvscan;

		/* Make sure we haven't already added a driver with this prefix */
		drvscan = device_driver_hash[which_hash];
		while (drvscan && 
		        strcmp(drvscan->dd_prefix, prefix)) {
			drvscan = drvscan->dd_next;
		}

		ASSERT(!drvscan);
	}
#endif /* DEBUG */


	/* Add new_driver to front of hash chain. */
	new_driver->dd_next = device_driver_hash[which_hash];
	if (new_driver->dd_next)
		new_driver->dd_next->dd_prev = new_driver;
	device_driver_hash[which_hash] = new_driver;

	mutex_spinunlock(&device_driver_lock[which_hash], s);

	return(new_driver);
#else
	FIXME("device_driver_alloc");
	return((device_driver_t)0);
#endif
}

/*
** Free a driver handle.
**
** Statically loaded drivers should never device_driver_free.
** Dynamically loaded drivers device_driver_free when either an
** unloaded driver is unregistered, or when an unregistered driver
** is unloaded.
*/
void
device_driver_free(device_driver_t driver)
{
#ifdef notyet
	int which_hash;
	int s;

	if (!driver)
		return;

	which_hash = driver_prefix_hash(driver->dd_prefix);

	s = mutex_spinlock(&device_driver_lock[which_hash]);

#if DEBUG
	{
		device_driver_t drvscan;

		/* Make sure we're dealing with the right list */
		drvscan = device_driver_hash[which_hash];
		while (drvscan && (drvscan != driver))
			drvscan = drvscan->dd_next;

		ASSERT(drvscan);
	}
#endif /* DEBUG */

	if (driver->dd_next)
		driver->dd_next->dd_prev = driver->dd_prev;

	if (driver->dd_prev)
		driver->dd_prev->dd_next = driver->dd_next;
	else
		device_driver_hash[which_hash] = driver->dd_next;

	mutex_spinunlock(&device_driver_lock[which_hash], s);

	driver->dd_next = NULL;		/* sanity */
	driver->dd_prev = NULL;		/* sanity */
	driver->dd_prefix = NULL;	/* sanity */

	if (driver->dd_bdevsw) {
		driver->dd_bdevsw->d_driver = NULL;
		driver->dd_bdevsw = NULL;
	}

	if (driver->dd_cdevsw) {
		if (driver->dd_cdevsw->d_str) {
			str_free_mux_node(driver);
		}
		driver->dd_cdevsw->d_driver = NULL;
		driver->dd_cdevsw = NULL;
	}

	kern_free(driver);
#endif
	FIXME("device_driver_free");
}


/*
** Given a device driver prefix, return a handle to the caller.
*/
device_driver_t
device_driver_get(char *prefix)
{
#ifdef notyet
	int which_hash;
	device_driver_t drvscan;
	int s;

	if (prefix == NULL)
		return(NULL);
		
	which_hash = driver_prefix_hash(prefix);

	s = mutex_spinlock(&device_driver_lock[which_hash]);

	drvscan = device_driver_hash[which_hash];
	while (drvscan && strcmp(drvscan->dd_prefix, prefix))
		drvscan = drvscan->dd_next;

	mutex_spinunlock(&device_driver_lock[which_hash], s);

	return(drvscan);
#else
	FIXME("device_driver_get");
	return((device_driver_t)0);
#endif
}


/*
** Given a block or char special file devfs_handle_t, find the 
** device driver that controls it.
*/
device_driver_t
device_driver_getbydev(devfs_handle_t device)
{
#ifdef notyet
	struct bdevsw *my_bdevsw;
	struct cdevsw *my_cdevsw;

	my_cdevsw = get_cdevsw(device);
	if (my_cdevsw != NULL)
		return(my_cdevsw->d_driver);

	my_bdevsw = get_bdevsw(device);
	if (my_bdevsw != NULL)
		return(my_bdevsw->d_driver);

#endif
	FIXME("device_driver_getbydev");
	return((device_driver_t)0);
}


/*
** Associate a driver with bdevsw/cdevsw pointers.
**
** Statically loaded drivers are permanently and automatically associated
** with the proper bdevsw/cdevsw.  Dynamically loaded drivers associate
** themselves when the driver is registered, and disassociate when the
** driver unregisters.
**
** Returns 0 on success, -1 on failure (devsw already associated with driver)
*/
int
device_driver_devsw_put(device_driver_t driver,
			struct bdevsw *my_bdevsw,
			struct cdevsw *my_cdevsw)
{
#ifdef notyet
	int i;

	if (!driver)
		return(-1);

	/* Trying to re-register data?  */
	if (((my_bdevsw != NULL) && (driver->dd_bdevsw != NULL)) ||
	    ((my_cdevsw != NULL) && (driver->dd_cdevsw != NULL)))
		return(-1);

	if (my_bdevsw != NULL) {
		driver->dd_bdevsw = my_bdevsw;
		my_bdevsw->d_driver = driver;
		for (i = 0; i < bdevmax; i++) {
			if (driver->dd_bdevsw->d_flags == bdevsw[i].d_flags) {
				bdevsw[i].d_driver = driver;
				break;
			}
		}
	}

	if (my_cdevsw != NULL) {
		driver->dd_cdevsw = my_cdevsw;
		my_cdevsw->d_driver = driver;
		for (i = 0; i < cdevmax; i++) {
			if (driver->dd_cdevsw->d_flags == cdevsw[i].d_flags) {
				cdevsw[i].d_driver = driver;
				break;
			}
		}
	}
#endif
	FIXME("device_driver_devsw_put");
	return(0);
}


/*
** Given a driver, return the corresponding bdevsw and cdevsw pointers.
*/
void
device_driver_devsw_get(	device_driver_t driver, 
				struct bdevsw **bdevswp,
				struct cdevsw **cdevswp)
{
	if (!driver) {
		*bdevswp = NULL;
		*cdevswp = NULL;
	} else {
		*bdevswp = driver->dd_bdevsw;
		*cdevswp = driver->dd_cdevsw;
	}
}

/*
 * device_driver_thread_pri_set
 *	Given a driver try to set its thread priority.
 *	Returns 0 on success , -1 on failure.
 */ 
int
device_driver_thread_pri_set(device_driver_t driver,ilvl_t pri)
{
	if (!driver)
		return(-1);
	driver->dd_thread_pri = pri;
	return(0);
}
/*
 * device_driver_thread_pri_get
 * 	Given a driver return the driver thread priority.
 * 	If the driver is NULL return invalid driver thread
 * 	priority.
 */
ilvl_t
device_driver_thread_pri_get(device_driver_t driver)
{
	if (driver)
		return(driver->dd_thread_pri);
	else
		return(DRIVER_THREAD_PRI_INVALID);
}
/*
** Given a device driver, return it's handle (prefix).
*/
void
device_driver_name_get(device_driver_t driver, char *buffer, int length)
{
	if (driver == NULL)
		return;

	strncpy(buffer, driver->dd_prefix, length);
}


/*
** Associate a pointer-sized piece of information with a device.
*/
void 
device_info_set(devfs_handle_t device, void *info)
{
#ifdef notyet
	hwgraph_fastinfo_set(device, (arbitrary_info_t)info);
#endif
	FIXME("device_info_set");
}


/*
** Retrieve a pointer-sized piece of information associated with a device.
*/
void *
device_info_get(devfs_handle_t device)
{
#ifdef notyet
	return((void *)hwgraph_fastinfo_get(device));
#else
	FIXME("device_info_get");
	return(NULL);
#endif
}

/*
 * Find the thread priority for a device, from the various
 * sysgen files.
 */
int
device_driver_sysgen_thread_pri_get(char *dev_prefix)
{
#ifdef notyet
	int pri;
	char *pri_s;
	char *class;

	extern default_intr_pri;
	extern disk_intr_pri;
	extern serial_intr_pri;
	extern parallel_intr_pri;
	extern tape_intr_pri;
	extern graphics_intr_pri;
	extern network_intr_pri;
	extern scsi_intr_pri;
	extern audio_intr_pri;
	extern video_intr_pri;
	extern external_intr_pri;
	extern tserialio_intr_pri;

	/* Check if there is a thread priority specified for
	 * this driver's thread thru admin hints. If so 
	 * use that value. Otherwise set it to its default
	 * class value, otherwise set it to the default
	 * value.
	 */

	if (pri_s = device_driver_admin_info_get(dev_prefix,
						ADMIN_LBL_THREAD_PRI)) {
		pri = atoi(pri_s);
	} else if (class = device_driver_admin_info_get(dev_prefix,
						ADMIN_LBL_THREAD_CLASS)) {
		if (strcmp(class, "disk") == 0)
			pri = disk_intr_pri;
		else if (strcmp(class, "serial") == 0)
			pri = serial_intr_pri;
		else if (strcmp(class, "parallel") == 0)
			pri = parallel_intr_pri;
		else if (strcmp(class, "tape") == 0)
			pri = tape_intr_pri;
		else if (strcmp(class, "graphics") == 0)
			pri = graphics_intr_pri;
		else if (strcmp(class, "network") == 0)
			pri = network_intr_pri;
		else if (strcmp(class, "scsi") == 0)
			pri = scsi_intr_pri;
		else if (strcmp(class, "audio") == 0)
			pri = audio_intr_pri;
		else if (strcmp(class, "video") == 0)
			pri = video_intr_pri;
		else if (strcmp(class, "external") == 0)
			pri = external_intr_pri;
		else if (strcmp(class, "tserialio") == 0)
			pri = tserialio_intr_pri;
		else
			pri = default_intr_pri;
	} else
		pri = default_intr_pri;

	if (pri > 255)
		pri = 255;
	else if (pri < 0)
		pri = 0;
	return pri;
#else
	FIXME("device_driver_sysgen_thread_pri_get");
	return(-1);
#endif
}