On
> +#undef NetXen_LOOPBACK
> +#undef SINGLE_DMA_BUF
> +#define NetXen_NIC_HW_CSUM
> +#define NetXen_NIC_NAPI
> +// #undef NetXen_NIC_NAPI
> +
> +#define NetXen_NETIF_F_TSO
Ugh. MixedCase define's and ifdef configuration message.
Remember, either keep the code or remove it.
> +// for cmd line parameteres----------
> +#define NetXen_PARAM(X,S) \
> +static int X=0; \
> +MODULE_PARM(X,"i"); \
> +MODULE_PARM_DESC(X,S);
>
More macro crap.
> +
> +
> +MODULE_AUTHOR("NetXen");
Author is a human, not a company.
> +MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
> +MODULE_LICENSE("GPL");
> +
> +/*static int netxen_nic_debug = NETIF_MSG_DRV | NETIF_MSG_PROBE; TODO */
> +int netxen_nic_debug;
"static int debug" is good better.
> +
> +MODULE_PARM(netxen_nic_debug, "i");
> +MODULE_PARM_DESC(netxen_nic_debug, "Debug level (0=none,...,16=all)");
> +
> +
> +char netxen_nic_driver_name[] = "netxen";
can be "static const char"
> +char netxen_nic_driver_string[] = "NetXen Network Driver version "
> + NetXen_NIC_LINUX_VERSIONID
> + "-"
> + NetXen_NIC_BUILD_NO
> + " generated "
> + NetXen_NIC_TIMESTAMP;
> +
> +#ifndef ARCH_KMALLOC_MINALIGN
> +#define ARCH_KMALLOC_MINALIGN 0
> +#endif
> +#ifndef ARCH_KMALLOC_FLAGS
> +#define ARCH_KMALLOC_FLAGS SLAB_HWCACHE_ALIGN
> +#endif
More macro obfuscation.
> +
> +#define NetXen_NETDEV_WEIGHT 120
> +#define ADAPTER_UP_MAGIC 777
> +
> +kmem_cache_t *cmd_desc_cache = NULL;
> +kmem_cache_t *cmd_buff_cache = NULL;
> +cmdDescType0_t *cmd_desc_array[NR_CPUS];
> +struct netxen_cmd_buffer *cmd_buff_array[NR_CPUS];
> +
> +static int netxen_nic_probe_err = 0;
> +
> +#define RCV_DESC_RINGSIZE (sizeof(rcvDesc_t) *
> adapter->MaxRxDescCount)
> +#define STATUS_DESC_RINGSIZE (sizeof(statusDesc_t)*
> adapter->MaxRxDescCount)
Don't use structure obscuring typedef's (rcvDesc_t) ...
> +#define JUMBO_DESC_RINGSIZE (sizeof(rcvDesc_t) *
> adapter->MaxJumboRxDescCount)
> +#define TX_RINGSIZE (sizeof(struct netxen_cmd_buffer) *
> adapter->MaxTxDescCount)
> +#define RCV_BUFFSIZE (sizeof(struct netxen_rx_buffer) *
> rcv_desc->MaxRxDescCount)
> +
> +#define NetXen_NIC_INT_RESET 0x2004
> +
> +/* Local functions to NetXen NIC driver */
> +static int __devinit netxen_nic_probe(struct pci_dev *pdev,
> + const struct pci_device_id *ent);
> +static void __devexit netxen_nic_remove(struct pci_dev *pdev);
> +static void netxen_nic_hw_reset (struct netxen_adapter_s *adapter);
> +static int netxen_nic_open(struct net_device *netdev);
> +static int netxen_nic_close(struct net_device *netdev);
> +static int netxen_nic_xmit_frame(struct sk_buff *, struct net_device *);
> +static int netxen_nic_set_mac(struct net_device *netdev, void *p);
> +static int netxen_nic_change_mtu(struct net_device *netdev, int new_mtu);
> +static int netxen_nic_hw_resources(struct netxen_adapter_s *adapter);
> +static void netxen_nic_set_multi(struct net_device *netdev);
> +static void initialize_adapter_sw(struct netxen_adapter_s *adapter);
> +static void netxen_post_rx_buffers(struct netxen_adapter_s *adapter,
> uint32_t ctx,
> + uint32_t num, uint32_t type);
> +static void netxen_process_rcv(struct netxen_adapter_s *adapter,int ctx,
> + statusDesc_t *desc);
> +static void netxen_tx_timeout(struct net_device *netdev);
> +static void netxen_tx_timeout_task(struct net_device *netdev);
> +static void netxen_process_cmd_ring(unsigned long data);
> +static void netxen_nic_down(struct netxen_port *port);
> +static int netxen_nic_do_ioctl(struct netxen_adapter_s *adapter,
> void*u_data,
> + struct netxen_port *port);
> +static int initialize_adapter_hw(struct netxen_adapter_s *adapter);
> +static void netxen_watchdog(unsigned long);
> +static void netxen_watchdog_task(unsigned long adapter);
> +static void netxen_nic_tune_phantom(struct pci_dev *pdev,
> + struct netxen_adapter_s*);
> +static void netxen_nic_enable_int(netxen_adapter *adapter);
> +static void netxen_nic_disable_int(netxen_adapter *adapter);
> +static uint32_t netxen_process_rcv_ring(struct netxen_adapter_s *, int, int);
> +static void netxen_nic_clear_stats(struct netxen_adapter_s *);
> +static struct net_device_stats *netxen_nic_get_stats(struct net_device
> *netdev);
> +static void netxen_nic_irq_enable(struct netxen_adapter_s *adapter);
> +static int netxen_handle_int(netxen_adapter *, struct net_device *);
> +static int netxen_nic_ioctl(struct net_device *netdev,
> + struct ifreq *ifr, int cmd);
> +static int netxen_nic_read_proc(char *buf, char **start, off_t offset,
> + int count, int *eof, void *data);
> +static int netxen_nic_port_read_proc(char *buf, char **start, off_t
> offset,
> + int count, int *eof, void *data);
> +#ifdef NetXen_NIC_NAPI
> +static int netxen_nic_rx_has_work(struct netxen_adapter_s *adapter);
> +static int netxen_nic_tx_has_work(struct netxen_adapter_s *adapter);
> +static int netxen_nic_poll(struct net_device *dev, int *budget);
> +#endif
> +#ifdef CONFIG_NET_POLL_CONTROLLER
> +static void netxen_nic_poll_controller(struct net_device *netdev);
> +#endif
> +#ifdef NetXen_NIC_HW_CSUM
> +static int netxen_tx_csum(struct netxen_adapter_s *adapter,
> cmdDescType0_t *desc,
> + struct sk_buff *skb);
> +#endif
> +static irqreturn_t netxen_intr(int irq, void *data, struct pt_regs *regs);
> +
> +extern void set_ethtool_ops(struct net_device *netdev);
> +struct netxen_adapter_s *g_adapter;
> +spinlock_t hal_lock;
> +
> +unsigned int loopback_start = 0;
> +
> +static struct proc_dir_entry *netxen_proc_dir_entry;
> +
> +static unsigned char *tx_user_packet_data = NULL, *rx_user_packet_data;
> +static unsigned int tx_user_packet_length = 0, rx_datalen, rx_user_pos = 0;
> +static int capture_input = 0, captured = 0;
> +
> +#define DIDX_DIF(p, c) \
> + ((p >= c) ? (p - c) : (MAX_CMD_DESCRIPTORS - p + c))
Why not a simple inline?
> +
> +#define CIS_WATERMARK 0x60
> +
> +#define PEG_LOOP 1000 /* loop to pegstuck? */
> +
> +#define QMAJ(hdr) ((hdr >> 19) & 0xF)
> +#define QMIN(hdr) (hdr & 0x3ffff)
> +#define QSUB(hdr) ((hdr >> 18) & 0x1)
> +
> +extern void xge_loopback(int on);
> +extern long xge_link_status (void);
> +
> +void __devinit
> +netxen_check_options(netxen_adapter *adapter)
> +{
> + adapter->MaxTxDescCount = MAX_CMD_DESCRIPTORS;
> + adapter->MaxRxDescCount = MAX_RCV_DESCRIPTORS;
> + adapter->MaxJumboRxDescCount = MAX_JUMBO_RCV_DESCRIPTORS;
> + return;
> +}
Why have a simple function like this ... ex C++ programmer?
> +
> +/* PCI Device ID Table */
> +static struct pci_device_id netxen_pci_tbl[] __devinitdata = {
> + {PCI_VENDOR_ID_NetXen,PCI_DEVICE_ID_NetXen_4PORT,PCI_ANY_ID,
> + PCI_ANY_ID,0,0,0UL},
Use PCI_DEVICE() for this.
> + {0,}
> +};
> +
> +MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
> +
> +struct netxen_adapter_s *adapterlist[MAX_NUM_CARDS];
This is artifically limiting . Use dynamic allocation and pci_privdata
to find adapter structure.
> +
> +/*
> +netxen_nic_probe()
> +
> +Linux system will invoke this after identifying the vendor ID and device Id
> +in the pci_tbl where this module will search for NetXen vedonr and device ID
> for
> +quad port adapter.
> +
> +Even though there are 4 seperate devices (functions) on the quad port NIC,
> but
> +the probe will be invoked for the first device (function) only. This will
> +initialize the adapter, and setup the global parameters along with the port's
> +specific structure.
> +*/
> +static int __devinit
> +netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> +{
> + struct net_device *netdev = NULL;
> + struct netxen_adapter_s *adapter = NULL;
> + struct netxen_port *port = NULL;
> + uint8_t *mem_ptr = NULL;
> + unsigned long mem_base, mem_len;
> + int pci_using_dac, i, err;
> + int boardno = 0;
> + int ring;
> + netdev_list_t *netlist = NULL;
> + netxen_recv_context_t *recv_ctx = NULL;
> + netxen_rcv_desc_ctx_t *rcv_desc = NULL;
> + struct netxen_cmd_buffer *cmd_buf_arr = NULL;
> + struct proc_dir_entry *procfile;
> + static int netxen_cards_found = 0;
> +
> + printk("NetXen: adapter %d\n", netxen_cards_found);
> +
> + if((err = pci_enable_device(pdev))) {
> + DPRINTK(1, ERR, "Cannot enable PCI device, aborting. %d\n",
> + err);
> + netxen_nic_probe_err = err;
> + return err;
> + }
> +
> + if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
> + DPRINTK(1, ERR, "Cannot find proper PCI device "
> + "base address, aborting. %p\n", pdev);
> + err = -ENODEV;
> + goto err_out_disable_pdev;
> + }
> +
> + if((err = pci_request_regions(pdev, netxen_nic_driver_name))) {
> + DPRINTK(1, ERR, "Cannot find proper PCI resources"
> + " aborting:%d\n", err);
> + goto err_out_disable_pdev;
> + }
> +
> + pci_set_master(pdev);
> +
> + if(!(err = pci_set_dma_mask(pdev, PCI_DMA_64BIT)) &&
> + !(err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))) {
> + pci_using_dac = 1;
> + } else {
> + if((err = pci_set_dma_mask(pdev, PCI_DMA_32BIT)) ||
> + (err = pci_set_consistent_dma_mask(pdev,
> DMA_32BIT_MASK))) {
> + DPRINTK(1, ERR, "No usable DMA configuration,"
> + " aborting:%d\n", err);
> + goto err_out_free_res;
> + }
> + pci_using_dac = 0;
> + }
> + DPRINTK(1, INFO, "pci_using_dac: %d\n", pci_using_dac);
> +
> + /* remap phys address */
> + mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
> + mem_len = pci_resource_len(pdev, 0);
> +
> + /* 128 Meg of memory */
> + DPRINTK(1, INFO, "ioremap from %lx a size of %lx\n", mem_base,
> + mem_len);
> + mem_ptr = ioremap(mem_base, NetXen_PCI_MAPSIZE_BYTES);
> + if (mem_ptr == 0UL) {
> + DPRINTK(1, ERR, "Cannot remap adapter memory aborting.:%p\n",
> + mem_ptr);
> + err = -EIO;
> + goto err_out_free_res;
> + }
> + DPRINTK(1, ERR, "ioremaped at %p\n", mem_ptr);
> +
> +/*
> + * Allocate a adapter structure which will manage all the initialization
> + * as well as the common resources for all ports...
> + * all the ports will have pointer to this adapter as well as Adapter
> + * will have pointers of all the ports structures.
> + */
> +
> + /* One adapter structure for all 4 ports.... */
> + adapter = (struct netxen_adapter_s *)kmalloc(sizeof(struct
> netxen_adapter_s),
> + GFP_KERNEL);
Cast is unnecessary here.
> + if (adapter == NULL) {
> + DPRINTK(1, ERR, "Could not allocate adapter memory:%d\n",
> + (int)sizeof(struct netxen_adapter_s));
> + err = -ENOMEM;
> + goto err_out_iounmap;
> + }
> +
> + if (netxen_cards_found == 0) {
> + g_adapter = adapter;
> + spin_lock_init(&hal_lock);
> + }
> +
> + /* Initialize to 0 */
> + memset(adapter, 0 , sizeof(struct netxen_adapter_s));
Use kzalloc.
> + DPRINTK(1, INFO, "malloced memory at %p\n", adapter);
> +
> + netxen_check_options(adapter);
> +
> + cmd_buf_arr = (struct netxen_cmd_buffer*) vmalloc(TX_RINGSIZE);
Your ring must be huge to need to vmalloc?
> + if (cmd_buf_arr == NULL) {
> + DPRINTK(1, ERR, "Could not allocate command buffer array,"
> + " order :%d\n", get_order(TX_RINGSIZE));
> + err = -ENOMEM;
> + goto err_out_free_adapter;
> + }
> + memset (cmd_buf_arr, 0, TX_RINGSIZE);
> +
> + for (i = 0; i < MAX_RCV_CTX; ++i) {
> + recv_ctx = &adapter->recv_ctx[i];
> + for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
> + rcv_desc = &recv_ctx->rcv_desc[ring];
> + switch (RCV_DESC_TYPE(ring)) {
> + case RCV_RING_STD:
> + rcv_desc->MaxRxDescCount =
> + adapter->MaxRxDescCount;
> + rcv_desc->flags = RCV_DESC_NORMAL;
> + rcv_desc->dma_size = RX_DMA_MAP_LEN;
> + rcv_desc->skb_size = MAX_RX_BUFFER_LENGTH;
> + break;
> +
> + case RCV_RING_JUMBO:
> + rcv_desc->MaxRxDescCount =
> + adapter->MaxJumboRxDescCount;
> + rcv_desc->flags = RCV_DESC_JUMBO;
> + rcv_desc->dma_size = RX_JUMBO_DMA_MAP_LEN;
> + rcv_desc->skb_size =
> + MAX_RX_JUMBO_BUFFER_LENGTH;
> + break;
> +
> + default:
> + printk("%s: netxen_nic_probe: bad receive "
> + "descriptor type %d\n",
> + netxen_nic_driver_name,
> + RCV_DESC_TYPE(ring));
> + break;
> + }
> + rcv_desc->rx_buf_arr = (struct netxen_rx_buffer*)
> +
> pci_alloc_consistent(pdev,
> + RCV_BUFFSIZE,
> + &rcv_desc->rx_buf_phys);
> +
> + if(rcv_desc->rx_buf_arr == NULL) {
> + DPRINTK(1, ERR, "Could not allocate rx"
> + " buffer array ring %d,"
> + " size:%u\n", ring,
> + (unsigned int)RCV_BUFFSIZE);
> + err = -ENOMEM;
> + goto err_out_free_rx_buffer;
> + }
> + memset (rcv_desc->rx_buf_arr, 0, RCV_BUFFSIZE);
> + }
> +
> + }
> +
> + adapter->cmd_buf_arr = cmd_buf_arr;
> + adapter->ahw.pci_base = (unsigned long)mem_ptr;
> + adapter->ahw.pci_len = mem_len;
> + adapter->ahw.crb_base = adapter->ahw.pci_base + NetXen_PCI_CRBSPACE;
> + rwlock_init(&adapter->adapter_lock);
Reader writer locks are the slowest of all the locking options. Why are you
using
it rather than something better.
> + spin_lock_init(&adapter->tx_lock);
> + spin_lock_init(&adapter->lock);
> + initialize_adapter_sw(adapter); /* initialize the buffers in adapter
> */
> + /*
> + * Set the CRB window to invalid. If any register in window 0 is
> + * accessed it should set the window to 0 and then reset it to 1.
> + */
> + adapter->curr_window = 255;
> + /*
> + * Adapter in our case is quad port so initialize it beofore
> + * initializing the ports
> + */
> + initialize_adapter_hw(adapter); /* initialize the adapter */
> + adapter->port =
> + (struct netxen_port**) kmalloc(sizeof(struct
> netxen_adapter_s)*
> + (adapter->ahw.max_ports),
> + GFP_KERNEL);
Use kcalloc, cast not needed
> + if (adapter->port == NULL) {
> + DPRINTK(1, ERR, "Could not allocate port-array memory:%d\n",
> + (int)sizeof(struct netxen_adapter_s) *
> + (adapter->ahw.max_ports));
> + err = -ENOMEM;
> + goto err_out_free_rx_buffer;
> + }
> + init_timer(&adapter->watchdog_timer);
> + adapter->ahw.xg_linkup = 0;
> + adapter->watchdog_timer.function = &netxen_watchdog;
> + adapter->watchdog_timer.data = (unsigned long) adapter;
> + INIT_WORK(&adapter->watchdog_task,
> + (void (*)(void *))netxen_watchdog_task, adapter);
> + adapter->ahw.vendor_id = pdev->vendor;
> + adapter->ahw.device_id = pdev->device;
> + adapter->ahw.pdev = pdev;
> + adapter->procCmdBufCounter = 0;
> + pci_read_config_byte(pdev, PCI_REVISION_ID,
> &adapter->ahw.revision_id);
> + pci_read_config_word(pdev, PCI_COMMAND, &adapter->ahw.pci_cmd_word);
> +
> +#if defined(CONFIG_PCI_MSI)
> + adapter->flags |= NetXen_NIC_MSI_ENABLED;
> + if (pci_enable_msi(pdev)) {
> + adapter->flags &= ~NetXen_NIC_MSI_ENABLED;
> + printk(KERN_WARNING "%s: unable to allocate MSI interrupt"
> + " error\n",netxen_nic_driver_name);
> + }
> +#endif
> + netxen_nic_tune_phantom(pdev, adapter);
> +
> + /* initialize the all the ports */
> + DPRINTK(1, INFO, "about to allocate all the %d net devs.\n",
> + adapter->ahw.max_ports);
> + for (i = 0; i < adapter->ahw.max_ports; i ++) {
> + netlist = kmalloc(sizeof(netdev_list_t), GFP_KERNEL);
> + if (netlist == NULL) {
> + goto err_out_free_dev;
> + }
> + netlist->netdev = alloc_etherdev(sizeof(struct netxen_port));
> + if(!netlist->netdev) {
> + DPRINTK(1, ERR, " could not allocate netdev for port"
> + " %d\n",i+1);
> + kfree(netlist);
> + goto err_out_free_dev;
> + }
> + netdev = netlist->netdev;
> +
> + SET_MODULE_OWNER(netdev);
> +
> + port = netdev->priv;
> + port->netdev = netdev;
> + port->pdev = pdev;
> + port->hw.port = port;
> + port->adapter = adapter;
> + port->portnum = i; /* Gigabit port number starting from 0-3
> */
> + port->flags &= ~NETDEV_STATUS;
> +
> + netdev->open = netxen_nic_open;
> + netdev->stop = netxen_nic_close;
> + netdev->hard_start_xmit = netxen_nic_xmit_frame;
> + netdev->get_stats = netxen_nic_get_stats;
> + netdev->set_multicast_list = netxen_nic_set_multi;
> + netdev->set_mac_address = netxen_nic_set_mac;
> + netdev->change_mtu = netxen_nic_change_mtu;
> + netdev->do_ioctl = netxen_nic_ioctl;
> + netdev->tx_timeout = netxen_tx_timeout;
> + set_ethtool_ops(netdev);
> + /* FIXME: maybe
> SET_ETHTOOL_OPS(netdev,&netxen_nic_ethtool_ops);*/
Yes, do it right.
> + netdev->irq = pdev->irq;
> +#ifdef NetXen_NIC_NAPI
> + netdev->poll = netxen_nic_poll;
> + netdev->weight = NetXen_NETDEV_WEIGHT;
> +#endif
> +#ifdef CONFIG_NET_POLL_CONTROLLER
> + netdev->poll_controller = netxen_nic_poll_controller;
> +#endif
> +#ifdef NetXen_NIC_HW_CSUM
> + /* ScatterGather support */
> + netdev->features = NETIF_F_SG ;
> + netdev->features |= NETIF_F_IP_CSUM;
> +#endif
> +#ifdef NetXen_NIC_HW_VLAN
> + netdev->features |= NETIF_F_HW_VLAN_TX;
> + netdev->features |= NETIF_F_HW_VLAN_RX;
> +#endif
> +#ifdef NetXen_NETIF_F_TSO
> + netdev->features |= NETIF_F_TSO;
> +#endif
> +
> + if(pci_using_dac)
> + netdev->features |= NETIF_F_HIGHDMA;
> + DPRINTK(1, INFO, "setting mac address: %p\n", port);
> +
> + /*
> + * Allocate h/w address and set in h/w.
> + * Eventually, we will read from the flash and set the mac
> + * address.
> + * For now set the lower 3 bytes to be same as board number
> + */
Do it right, otherwise you risk issues with multiple systems with same address!
> + boardno = netxen_nic_get_board_num(adapter);
> + port->hw.mac_addr[0] = 0x00;
> + port->hw.mac_addr[1] = 0x0e;
> + port->hw.mac_addr[2] = 0x1e;
> + port->hw.mac_addr[3] = ((boardno & (0xff << 16)) >> 16) + i;
> + port->hw.mac_addr[4] = (boardno & (0xff << 8)) >> 8;
> + port->hw.mac_addr[5] = boardno & 0xff;
> + netxen_nic_macaddr_set (port, port->hw.mac_addr);
> + memcpy(netdev->dev_addr, port->hw.mac_addr,
> netdev->addr_len);
> + if(!is_valid_ether_addr(netdev->dev_addr)) {
> + DPRINTK(1, ERR, "BAD MAC :is_valid_ether_addr"
> + " aborting:%d\n", err);
> + break;
> + }
> + INIT_WORK(adapter->tx_timeout_task + i,
> + (void (*)(void *))netxen_tx_timeout_task,
> netdev);
> + netif_carrier_off(netdev);
> + netif_stop_queue(netdev);
> +
> + if((err = register_netdev(netdev))) {
> + DPRINTK(1, ERR, "register_netdev failed port #%d"
> + " aborting\n", i+1);
> + break;
> + }
> + procfile = create_proc_entry(netdev->name, S_IRUGO,
> + netxen_proc_dir_entry);
> + if (procfile) {
> + procfile->data = netdev;
> + procfile->owner = THIS_MODULE;
> + procfile->read_proc = netxen_nic_port_read_proc;
> + }
Is the /proc entry really needed? If so use seq_file. Also netdev->name can
change so you need to track name changes...
Enough crap for now.
-
To unsubscribe from this list: send the line "unsubscribe netdev" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at http://vger.kernel.org/majordomo-info.html
