e100_proc.c

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

static int
read_state(char *page, char **start, off_t off, int count, int *eof, void *data)
{
	struct e100_private *bdp = data;
	int len;

	if (bdp->device->flags & IFF_UP)
		len = sprintf(page, "up\n");
	else
		len = sprintf(page, "down\n");

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

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

	e100_get_stats(bdp->device);
	val = (unsigned long) bdp->drv_stats.net_stats.rx_errors;
	return read_ulong(page, start, off, count, eof, val);
}

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

	e100_get_stats(bdp->device);
	val = (unsigned long) bdp->drv_stats.net_stats.tx_errors;
	return read_ulong(page, start, off, count, eof, val);
}

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

	len = sprintf(page, "N/A\n");
	return generic_read(page, start, off, count, eof, len);
}

static void
set_led(struct e100_private *bdp, u16 led_mdi_op)
{
	e100_mdi_write(bdp, PHY_82555_LED_SWITCH_CONTROL,
		       bdp->phy_addr, led_mdi_op);

	set_current_state(TASK_UNINTERRUPTIBLE);
	schedule_timeout(MDI_SLEEP_TIME);

	/* turn led ownership to the chip */
	e100_mdi_write(bdp, PHY_82555_LED_SWITCH_CONTROL,
		       bdp->phy_addr, PHY_82555_LED_NORMAL_CONTROL);
}

static int
write_blink_led_timer(struct file *file, const char *buffer,
		      unsigned long count, void *data)
{
	struct e100_private *bdp = data;
	char s_blink_op[WRITE_BUF_MAX_LEN + 1];
	char *res;
	unsigned long i_blink_op;

	if (!buffer)
		return -EINVAL;

	if (count > WRITE_BUF_MAX_LEN) {
		count = WRITE_BUF_MAX_LEN;
	}
	if (copy_from_user(s_blink_op, buffer, count))
		return -EFAULT;
	s_blink_op[count] = '\0';
	i_blink_op = simple_strtoul(s_blink_op, &res, 0);
	if (res == s_blink_op) {
		return -EINVAL;
	}

	switch (i_blink_op) {

	case LED_OFF:
		set_led(bdp, PHY_82555_LED_OFF);
		break;
	case LED_ON:
		if (bdp->rev_id >= D101MA_REV_ID)
			set_led(bdp, PHY_82555_LED_ON_559);
		else
			set_led(bdp, PHY_82555_LED_ON_PRE_559);

		break;
	default:
		return -EINVAL;
	}

	return count;
}

static e100_proc_entry e100_proc_list[] = {
	{"Description",           read_descr,            0, 0},
	{"Driver_Name",           read_drvr_name,        0, 0},
	{"Driver_Version",        read_drvr_ver,         0, 0},
	{"PCI_Vendor",            read_pci_vendor,       0, 0},
	{"PCI_Device_ID",         read_pci_device,       0, 0},
	{"PCI_Subsystem_Vendor",  read_pci_sub_vendor,   0, 0},
	{"PCI_Subsystem_ID",      read_pci_sub_device,   0, 0},
	{"PCI_Revision_ID",       read_pci_revision,     0, 0},
	{"PCI_Bus",               read_pci_bus,          0, 0},
	{"PCI_Slot",              read_pci_slot,         0, 0},
	{"IRQ",                   read_irq,              0, 0},
	{"System_Device_Name",    read_dev_name,         0, 0},
	{"Current_HWaddr",        read_current_hwaddr,   0, 0},
	{"Permanent_HWaddr",      read_permanent_hwaddr, 0, 0},
	{"Part_Number",           read_part_number,      0, 0},
	{"\n",},
	{"Link",                  read_link_status,      0, 0},
	{"Speed",                 read_speed,            0, 0},
	{"Duplex",                read_dplx_mode,        0, 0},
	{"State",                 read_state,            0, 0},
	{"\n",},
	{"Rx_Packets",            read_gen_ulong, 0, bdp_net_off(rx_packets)},
	{"Tx_Packets",            read_gen_ulong, 0, bdp_net_off(tx_packets)},
	{"Rx_Bytes",              read_gen_ulong, 0, bdp_net_off(rx_bytes)},
	{"Tx_Bytes",              read_gen_ulong, 0, bdp_net_off(tx_bytes)},
	{"Rx_Errors",             read_rx_errors, 0, 0},
	{"Tx_Errors",             read_tx_errors, 0, 0},
	{"Rx_Dropped",            read_gen_ulong, 0, bdp_net_off(rx_dropped)},
	{"Tx_Dropped",            read_gen_ulong, 0, bdp_net_off(tx_dropped)},
	{"Multicast",             read_rx_multicast_packets, 0, 0},
	{"Collisions",            read_gen_ulong, 0, bdp_net_off(collisions)},
	{"Rx_Length_Errors",      read_gen_ulong, 0, bdp_net_off(rx_length_errors)},
	{"Rx_Over_Errors",        read_gen_ulong, 0, bdp_net_off(rx_over_errors)},
	{"Rx_CRC_Errors",         read_gen_ulong, 0, bdp_net_off(rx_crc_errors)},
	{"Rx_Frame_Errors",       read_gen_ulong, 0, bdp_net_off(rx_frame_errors)},
	{"Rx_FIFO_Errors",        read_gen_ulong, 0, bdp_net_off(rx_fifo_errors)},
	{"Rx_Missed_Errors",      read_gen_ulong, 0, bdp_net_off(rx_missed_errors)},
	{"Tx_Aborted_Errors",     read_gen_ulong, 0, bdp_net_off(tx_aborted_errors)},
	{"Tx_Carrier_Errors",     read_gen_ulong, 0, bdp_net_off(tx_carrier_errors)},
	{"Tx_FIFO_Errors",        read_gen_ulong, 0, bdp_net_off(tx_fifo_errors)},
	{"Tx_Heartbeat_Errors",   read_gen_ulong, 0, ~0},
	{"Tx_Window_Errors",      read_gen_ulong, 0, ~0},
	{"\n",},
	{"Rx_TCP_Checksum_Good",  read_gen_ulong, 0, ~0},
	{"Rx_TCP_Checksum_Bad",   read_gen_ulong, 0, ~0},
	{"Tx_TCP_Checksum_Good",  read_gen_ulong, 0, ~0},
	{"Tx_TCP_Checksum_Bad",   read_gen_ulong, 0, ~0},
	{"\n",},
	{"Tx_Abort_Late_Coll",    read_gen_ulong, 0, bdp_drv_off(tx_late_col)},
	{"Tx_Deferred_Ok",        read_gen_ulong, 0, bdp_drv_off(tx_ok_defrd)},
	{"Tx_Single_Coll_Ok",     read_gen_ulong, 0, bdp_drv_off(tx_one_retry)},
	{"Tx_Multi_Coll_Ok",      read_gen_ulong, 0, bdp_drv_off(tx_mt_one_retry)},
	{"Rx_Long_Length_Errors", read_gen_ulong, 0, ~0},
	{"Rx_Align_Errors",       read_gen_ulong, 0, bdp_net_off(rx_frame_errors)},
	{"\n",},
	{"Tx_Flow_Control_Pause", read_gen_ulong, 0, bdp_drv_off(xmt_fc_pkts)},
	{"Rx_Flow_Control_Pause", read_gen_ulong, 0, bdp_drv_off(rcv_fc_pkts)},
	{"Rx_Flow_Control_Unsup", read_gen_ulong, 0, bdp_drv_off(rcv_fc_unsupported)},
	{"\n",},
	{"Tx_TCO_Packets",        read_gen_ulong, 0, bdp_drv_off(xmt_tco_pkts)},
	{"Rx_TCO_Packets",        read_gen_ulong, 0, bdp_drv_off(rcv_tco_pkts)},
	{"\n",},
	{"Rx_Interrupt_Packets",  read_gen_ulong, 0, bdp_drv_off(rx_intr_pkts)},
#ifdef E100_RX_CONGESTION_CONTROL
	{"Rx_Polling_Packets",    read_gen_ulong, 0, bdp_drv_off(rx_tasklet_pkts)},
	{"Polling_Interrupt_Switch", read_gen_ulong, 0, bdp_drv_off(poll_intr_switch)},
#endif
	{"Identify_Adapter", 0, write_blink_led_timer, 0},
        {"\n",},	
        {"MDIX_Status",           read_mdix_status,      0, 0},
        {"Cable_Status",          read_cable_status,     0, 0},
	{"", 0, 0, 0}
};

static int
read_info(char *page, char **start, off_t off, int count, int *eof, void *data)
{
	struct e100_private *bdp = data;
	e100_proc_entry *pe;
	int tmp;
	void *val;
	int len = 0;

	for (pe = e100_proc_list; pe->name[0]; pe++) {
		if (pe->name[0] == '\n') {
			len += sprintf(page + len, "\n");
			continue;
		}

		if (pe->read_proc) {
			if ((len + READ_BUF_MAX_LEN + E100_PE_LEN + 1) >=
			    PAGE_SIZE)
				break;

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

			len += sprintf(page + len, "%-"
				       __MODULE_STRING(E100_PE_LEN)
				       "s ", pe->name);
			len += pe->read_proc(page + len, start, 0,
					     READ_BUF_MAX_LEN + 1, &tmp, val);
		}
	}

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

#ifdef E100_EOU
#ifdef MODULE
/**********************
 *  parameter entries
 **********************/
static int
read_int_param(char *page, char *name, char *desc, int def, int min, int max)
{
	int len;

	len = sprintf(page, "Name: %s\n", name);
	len += sprintf(page + len, "Description: %s\n", desc);
	len += sprintf(page + len, "Default_Value: %d\n", def);
	len += sprintf(page + len, "Type: Range\n");
	len += sprintf(page + len, "Min: %d\n", min);
	len += sprintf(page + len, "Max: %d\n", max);
	len += sprintf(page + len, "Step:1\n");
	len += sprintf(page + len, "Radix: dec\n");

	return len;
}

static int
read_bool_param(char *page, char *name, char *desc, int def)
{
	int len;

	len = sprintf(page, "Name: %s\n", name);
	len += sprintf(page + len, "Description: %s\n", desc);
	len += sprintf(page + len, "Default_Value: %d\n", def);
	len += sprintf(page + len, "Type: Enum\n");
	len += sprintf(page + len, "0: Off\n");
	len += sprintf(page + len, "1: On\n");

	return len;
}

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

	len = sprintf(page, "Name: Speed and Duplex\n");
	len += sprintf(page + len, "Description: Sets the adapter's "
		       "speed and duplex mode\n");
	len += sprintf(page + len, "Default_Value: 0\n");
	len += sprintf(page + len, "Type: Enum\n");
	len += sprintf(page + len, "0: Auto-Negotiate\n");
	len += sprintf(page + len, "1: 10 Mbps / Half Duplex\n");
	len += sprintf(page + len, "2: 10 Mbps / Full Duplex\n");
	len += sprintf(page + len, "3: 100 Mbps / Half Duplex\n");
	len += sprintf(page + len, "4: 100 Mbps / Full Duplex\n");

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

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

	len = read_int_param(page, "Transmit Descriptors",
			     "Sets the number of Tx descriptors "
			     "available for the adapter",
			     E100_DEFAULT_TCB, E100_MIN_TCB, E100_MAX_TCB);
	return generic_read(page, start, off, count, eof, len);
}

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

	len = read_int_param(page, "Receive Descriptors",
			     "Sets the number of Rx descriptors "
			     "available for the adapter",
			     E100_DEFAULT_RFD, E100_MIN_RFD, E100_MAX_RFD);
	return generic_read(page, start, off, count, eof, len);
}

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

	len = read_int_param(page, "Bit Error Rate",
			     "Sets the value for the BER correction algorithm",
			     E100_DEFAULT_BER, 0, ZLOCK_MAX_ERRORS);

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

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

	len = read_bool_param(page, "RX Checksum",
			      "Setting this value to \"On\" enables "
			      "receive checksum", E100_DEFAULT_XSUM);

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

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

	len = read_bool_param(page, "Microcode",
			      "Setting this value to \"On\" enables "
			      "the adapter's microcode", E100_DEFAULT_UCODE);

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

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

	len = read_bool_param(page, "Bundle Small Frames",
			      "Setting this value to \"On\" enables "
			      "interrupt bundling of small frames",
			      E100_DEFAULT_BUNDLE_SMALL_FR);

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

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

	len = read_bool_param(page, "Flow Control",
			      "Setting this value to \"On\" enables processing "
			      "flow-control packets", E100_DEFAULT_FC);

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

#ifdef E100_RX_CONGESTION_CONTROL
static int
read_rcv_cong_def(char *page, char **start, off_t off,
		  int count, int *eof, void *data)
{
	int len;

	len = read_bool_param(page, "Receive Congestion Control",
			      "Setting this value to \"On\" enables switching "
			      "to polling mode on receive",
			      E100_DEFAULT_RX_CONGESTION_CONTROL);

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

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

	int len;

	len = read_int_param(page, "Maximum Polling Work",
			     "Sets the max number of RX packets processed"
			     " by single polling function call",
			     bdp->params.RxDescriptors, 1, E100_MAX_RFD);

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

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