e100_proc.c

linux intel 网卡驱动,利用他可以让inel的pro 100 网卡进行网络配置和实用

	len = read_int_param(page, "CPU Saver Interrupt Delay",
			     "Sets the value for CPU saver's interrupt delay",
			     E100_DEFAULT_CPUSAVER_INTERRUPT_DELAY, 0x0,
			     0xFFFF);

	return generic_read(page, start, off, count, eof, len);
}

static int
read_bundle_max_def(char *page, char **start, off_t off,
		    int count, int *eof, void *data)
{
	int len;

	len = read_int_param(page, "CPU Saver Maximum Bundle",
			     "Sets CPU saver's maximum value",
			     E100_DEFAULT_CPUSAVER_BUNDLE_MAX, 0x1, 0xFFFF);

	return generic_read(page, start, off, count, eof, len);
}

static int
read_ifs_def(char *page, char **start, off_t off,
	     int count, int *eof, void *data)
{
	int len;

	len = read_bool_param(page, "IFS",
			      "Setting this value to \"On\" enables "
			      "the adaptive IFS algorithm", E100_DEFAULT_IFS);

	return generic_read(page, start, off, count, eof, len);
}

static int
read_xsum_rx_val(char *page, char **start, off_t off,
		 int count, int *eof, void *data)
{
	struct e100_private *bdp = data;
	unsigned long val;

	val = (bdp->params.b_params & PRM_XSUMRX) ? 1 : 0;
	return read_ulong(page, start, off, count, eof, val);
}

static int
read_ucode_val(char *page, char **start, off_t off,
	       int count, int *eof, void *data)
{
	struct e100_private *bdp = data;
	unsigned long val;

	val = (bdp->params.b_params & PRM_UCODE) ? 1 : 0;
	return read_ulong(page, start, off, count, eof, val);
}

static int
read_fc_val(char *page, char **start, off_t off,
	    int count, int *eof, void *data)
{
	struct e100_private *bdp = data;
	unsigned long val;

	val = (bdp->params.b_params & PRM_FC) ? 1 : 0;
	return read_ulong(page, start, off, count, eof, val);
}

static int
read_ifs_val(char *page, char **start, off_t off,
	     int count, int *eof, void *data)
{
	struct e100_private *bdp = data;
	unsigned long val;

	val = (bdp->params.b_params & PRM_IFS) ? 1 : 0;
	return read_ulong(page, start, off, count, eof, val);
}

static int
read_bundle_small_val(char *page, char **start, off_t off,
		      int count, int *eof, void *data)
{
	struct e100_private *bdp = data;
	unsigned long val;

	val = (bdp->params.b_params & PRM_BUNDLE_SMALL) ? 1 : 0;
	return read_ulong(page, start, off, count, eof, val);
}

#ifdef E100_RX_CONGESTION_CONTROL
static int
read_rcv_cong_val(char *page, char **start, off_t off,
		  int count, int *eof, void *data)
{
	struct e100_private *bdp = data;
	unsigned long val;

	val = (bdp->params.b_params & PRM_RX_CONG) ? 1 : 0;
	return read_ulong(page, start, off, count, eof, val);
}
#endif

static int
read_gen_prm(char *page, char **start, off_t off,
	     int count, int *eof, void *data)
{
	int val = 0;

	if (data)
		val = *((int *) data);

	return read_ulong(page, start, off, count, eof, (unsigned long) val);
}

static e100_proc_entry e100_proc_params[] = { 
	/* definitions */
	{"e100_speed_duplex.def", read_speed_duplex_def, 0, 0},
	{"RxDescriptors.def",     read_rx_desc_def,      0, 0},
	{"TxDescriptors.def",     read_tx_desc_def,      0, 0},
	{"XsumRX.def",            read_xsum_rx_def,      0, 0},
	{"ucode.def",             read_ucode_def,        0, 0},
	{"BundleSmallFr.def",     read_bundle_small_def, 0, 0},
	{"IntDelay.def",          read_int_delay_def,    0, 0},
	{"BundleMax.def",         read_bundle_max_def,   0, 0},
	{"ber.def",               read_ber_def,          0, 0},
	{"flow_control.def",      read_fc_def,           0, 0},
	{"IFS.def",               read_ifs_def,          0, 0},
#ifdef E100_RX_CONGESTION_CONTROL
	{"RxCongestionControl.def", read_rcv_cong_def,   0, 0},
	{"PollingMaxWork.def",      read_poll_max_def,   0, 0},
#endif
	/* values */
	{"e100_speed_duplex.val", read_gen_prm, 0, bdp_prm_off(e100_speed_duplex)},
	{"RxDescriptors.val",     read_gen_prm, 0, bdp_prm_off(RxDescriptors)},
	{"TxDescriptors.val",     read_gen_prm, 0, bdp_prm_off(TxDescriptors)},
	{"XsumRX.val",            read_xsum_rx_val,      0, 0},
	{"ucode.val",             read_ucode_val,        0, 0},
	{"BundleSmallFr.val",     read_bundle_small_val, 0, 0},
	{"IntDelay.val",          read_gen_prm, 0, bdp_prm_off(IntDelay)},
	{"BundleMax.val",         read_gen_prm, 0, bdp_prm_off(BundleMax)},
	{"ber.val",               read_gen_prm, 0, bdp_prm_off(ber)},
	{"flow_control.val",      read_fc_val,           0, 0},
	{"IFS.val",               read_ifs_val,          0, 0},
#ifdef E100_RX_CONGESTION_CONTROL
	{"RxCongestionControl.val", read_rcv_cong_val,   0, 0},
	{"PollingMaxWork.val",      read_gen_prm, 0, bdp_prm_off(PollingMaxWork)},
#endif
	{"", 0, 0, 0}
};
#endif  /* MODULE */

static struct proc_dir_entry * __devinit
create_proc_rw(char *name, void *data, struct proc_dir_entry *parent,
	       read_proc_t * read_proc, write_proc_t * write_proc)
{
	struct proc_dir_entry *pdep;
	mode_t mode = S_IFREG;

	if (write_proc) {
		mode |= S_IWUSR;
		if (read_proc) {
			mode |= S_IRUSR;
		}

	} else if (read_proc) {
		mode |= S_IRUGO;
	}

	if (!(pdep = create_proc_entry(name, mode, parent)))
		return NULL;

	pdep->read_proc = read_proc;
	pdep->write_proc = write_proc;
	pdep->data = data;
	return pdep;
}

#ifdef E100_EOU
#ifdef MODULE
static int __devinit
create_proc_param_subdir(struct e100_private *bdp,
			 struct proc_dir_entry *dev_dir)
{
	struct proc_dir_entry *param_dir;
	e100_proc_entry *pe;
	void *data;

	param_dir = create_proc_entry("LoadParameters", S_IFDIR, dev_dir);
	if (!param_dir)
		return -ENOMEM;

	for (pe = e100_proc_params; pe->name[0]; pe++) {

		data = ((char *) bdp) + pe->offset;

		if (!(create_proc_rw(pe->name, data, param_dir,
				     pe->read_proc, pe->write_proc))) {
			return -ENOMEM;
		}
	}

	return 0;
}

static void
remove_proc_param_subdir(struct proc_dir_entry *parent)
{
	struct proc_dir_entry *de;
	e100_proc_entry *pe;
	int len;

	len = strlen("LoadParameters");

	for (de = parent->subdir; de; de = de->next) {
		if ((de->namelen == len) &&
		    (!memcmp(de->name, "LoadParameters", len)))
			break;
	}

	if (!de)
		return;

	for (pe = e100_proc_params; pe->name[0]; pe++) {
		remove_proc_entry(pe->name, de);
	}

	remove_proc_entry("LoadParameters", parent);
}
#endif /* MODULE */
#endif

void
e100_remove_proc_subdir(struct e100_private *bdp)
{
	e100_proc_entry *pe;
	char info[256];
	int len;

	/* If our root /proc dir was not created, there is nothing to remove */
	if (adapters_proc_dir == NULL) {
		return;
	}

	len = strlen(bdp->device->name);
	strncpy(info, bdp->device->name, sizeof (info));
	strncat(info + len, ".info", sizeof (info) - len);

	if (bdp->proc_parent) {
		for (pe = e100_proc_list; pe->name[0]; pe++) {
			if (pe->name[0] == '\n')
				continue;

			remove_proc_entry(pe->name, bdp->proc_parent);
		}

#ifdef E100_EOU		
#ifdef MODULE
		remove_proc_param_subdir(bdp->proc_parent);
#endif
#endif		
		remove_proc_entry(bdp->device->name, adapters_proc_dir);
		bdp->proc_parent = NULL;
	}

	remove_proc_entry(info, adapters_proc_dir);

	/* try to remove the main /proc dir, if it's empty */
	e100_proc_cleanup();
}

int __devinit
e100_create_proc_subdir(struct e100_private *bdp)
{
	struct proc_dir_entry *dev_dir;
	e100_proc_entry *pe;
	char info[256];
	int len;
	void *data;

	/* create the main /proc dir if needed */
	if (!adapters_proc_dir) {
		if (!e100_init_proc_dir())
			return -ENOMEM;
	}

	strncpy(info, bdp->device->name, sizeof (info));
	len = strlen(info);
	strncat(info + len, ".info", sizeof (info) - len);

	/* info */
	if (!(create_proc_rw(info, bdp, adapters_proc_dir, read_info, 0))) {
		e100_proc_cleanup();
		return -ENOMEM;
	}

	dev_dir = create_proc_entry(bdp->device->name, S_IFDIR,
				    adapters_proc_dir);
	bdp->proc_parent = dev_dir;

	if (!dev_dir) {
		e100_remove_proc_subdir(bdp);
		return -ENOMEM;
	}

	for (pe = e100_proc_list; pe->name[0]; pe++) {
		if (pe->name[0] == '\n')
			continue;

		if (pe->offset != ~0)
			data = ((char *) bdp) + pe->offset;
		else
			data = NULL;

		if (!(create_proc_rw(pe->name, data, dev_dir,
				     pe->read_proc, pe->write_proc))) {
			e100_remove_proc_subdir(bdp);
			return -ENOMEM;
		}
	}

#ifdef E100_EOU	
#ifdef MODULE
	if (create_proc_param_subdir(bdp, dev_dir)) {
		e100_remove_proc_subdir(bdp);
		return -ENOMEM;
	}
#endif
#endif	

	return 0;
}

/****************************************************************************
 * Name:          e100_init_proc_dir
 *
 * Description:   This routine creates the top-level /proc directory for the
 *                driver in /proc/net
 *
 * Arguments:     none
 *
 * Returns:       true on success, false on fail
 *
 ***************************************************************************/
static unsigned char
e100_init_proc_dir(void)
{
	int len;

	/* first check if adapters_proc_dir already exists */
	len = strlen(ADAPTERS_PROC_DIR);
	for (adapters_proc_dir = proc_net->subdir;
	     adapters_proc_dir; adapters_proc_dir = adapters_proc_dir->next) {

		if ((adapters_proc_dir->namelen == len) &&
		    (!memcmp(adapters_proc_dir->name, ADAPTERS_PROC_DIR, len)))
			break;
	}

	if (!adapters_proc_dir)
		adapters_proc_dir =
			create_proc_entry(ADAPTERS_PROC_DIR, S_IFDIR, proc_net);

	if (!adapters_proc_dir)
		return false;

	return true;
}

/****************************************************************************
 * Name:          e100_proc_cleanup
 *
 * Description:   This routine clears the top-level /proc directory, if empty.
 *
 * Arguments:     none
 *
 * Returns:       none
 *
 ***************************************************************************/
static void
e100_proc_cleanup(void)
{
	struct proc_dir_entry *de;

	if (adapters_proc_dir == NULL) {
		return;
	}

	/* check if subdir list is empty before removing adapters_proc_dir */
	for (de = adapters_proc_dir->subdir; de; de = de->next) {
		/* ignore . and .. */
		if (*(de->name) != '.')
			break;
	}

	if (de)
		return;

	remove_proc_entry(ADAPTERS_PROC_DIR, proc_net);
	adapters_proc_dir = NULL;
}

#endif /* CONFIG_PROC_FS */