rrunner.c

powerpc内核mpc8241linux系统下net驱动程序

	struct rr_private *rrpriv;
	struct rr_regs *regs;
	u32 sram_size, rev;

	rrpriv = (struct rr_private *)dev->priv;
	regs = rrpriv->regs;

	rev = regs->FwRev;
	if (rev > 0x00020024)
		printk("  Firmware revision: %i.%i.%i\n", (rev >> 16),
		       ((rev >> 8) & 0xff), (rev & 0xff));
	else if (rev >= 0x00020000) {
		printk("  Firmware revision: %i.%i.%i (2.0.37 or "
		       "later is recommended)\n", (rev >> 16),
		       ((rev >> 8) & 0xff), (rev & 0xff));
	}else{
		printk("  Firmware revision too old: %i.%i.%i, please "
		       "upgrade to 2.0.37 or later.\n",
		       (rev >> 16), ((rev >> 8) & 0xff), (rev & 0xff));
		return -EFAULT;
		
	}

	printk("  Maximum receive rings %i\n", regs->MaxRxRng);

	sram_size = read_eeprom_word(rrpriv, (void *)8);
	printk("  SRAM size 0x%06x\n", sram_size);

	if (sysctl_rmem_max < 262144){
		printk("  Receive socket buffer limit too low (%i), "
		       "setting to 262144\n", sysctl_rmem_max);
		sysctl_rmem_max = 262144;
	}

	if (sysctl_wmem_max < 262144){
		printk("  Transmit socket buffer limit too low (%i), "
		       "setting to 262144\n", sysctl_wmem_max);
		sysctl_wmem_max = 262144;
	}

	return 0;
}


static int rr_init1(struct device *dev)
{
	struct rr_private *rrpriv;
	struct rr_regs *regs;
	u32 hostctrl;
	unsigned long myjif, flags, tmp_ptr;
	struct cmd cmd;
	short i;

	rrpriv = (struct rr_private *)dev->priv;
	regs = rrpriv->regs;

	spin_lock_irqsave(&rrpriv->lock, flags);

	hostctrl = regs->HostCtrl;
	regs->HostCtrl |= HALT_NIC;

	if (hostctrl & PARITY_ERR){
		printk("%s: Parity error halting NIC - this is serious!\n",
		       dev->name);
		spin_unlock_irqrestore(&rrpriv->lock, flags);
		return -EFAULT;
	}


	memset(rrpriv->rx_ctrl, 0, 256 * sizeof(struct ring_ctrl));
	memset(rrpriv->info, 0, sizeof(struct rr_info));

	tmp_ptr = virt_to_bus((void *)rrpriv->rx_ctrl);
#if (BITS_PER_LONG == 64)
	regs->RxRingHi = (tmp_ptr >> 32);
#else
	regs->RxRingHi = 0;
#endif
	regs->RxRingLo = ((tmp_ptr) & 0xffffffff);

	tmp_ptr = virt_to_bus((void *)rrpriv->info);
#if (BITS_PER_LONG == 64)
	regs->InfoPtrHi = (tmp_ptr >> 32);
#else
	regs->InfoPtrHi = 0;
#endif
	regs->InfoPtrLo = ((tmp_ptr) & 0xffffffff);

	rrpriv->info->evt_ctrl.entry_size = sizeof(struct event);
	rrpriv->info->evt_ctrl.entries = EVT_RING_ENTRIES;
	rrpriv->info->evt_ctrl.mode = 0;
	rrpriv->info->evt_ctrl.pi = 0;
	rrpriv->info->evt_ctrl.rngptr = virt_to_bus(rrpriv->evt_ring);

	rrpriv->info->cmd_ctrl.entry_size = sizeof(struct cmd);
	rrpriv->info->cmd_ctrl.entries = CMD_RING_ENTRIES;
	rrpriv->info->cmd_ctrl.mode = 0;
	rrpriv->info->cmd_ctrl.pi = 15;

	for (i = 0; i < CMD_RING_ENTRIES; i++) {
		regs->CmdRing[i] = 0;
	}

	for (i = 0; i < TX_RING_ENTRIES; i++) {
		rrpriv->tx_ring[i].size = 0;
		rrpriv->tx_ring[i].addr = 0;
		rrpriv->tx_skbuff[i] = 0;
	}

	rrpriv->info->tx_ctrl.entry_size = sizeof(struct tx_desc);
	rrpriv->info->tx_ctrl.entries = TX_RING_ENTRIES;
	rrpriv->info->tx_ctrl.mode = 0;
	rrpriv->info->tx_ctrl.pi = 0;
	rrpriv->info->tx_ctrl.rngptr = virt_to_bus(rrpriv->tx_ring);

	/*
	 * Set dirty_tx before we start receiving interrupts, otherwise
	 * the interrupt handler might think it is supposed to process
	 * tx ints before we are up and running, which may cause a null
	 * pointer access in the int handler.
	 */
	rrpriv->tx_full = 0;
	rrpriv->cur_rx = 0;
	rrpriv->dirty_rx = rrpriv->dirty_tx = 0;

	rr_reset(dev);

	regs->IntrTmr = 0x60;
	regs->WriteDmaThresh = 0x80 | 0x1f;
	regs->ReadDmaThresh = 0x80 | 0x1f;

	rrpriv->fw_running = 0;

	hostctrl &= ~(HALT_NIC | INVALID_INST_B | PARITY_ERR);
	regs->HostCtrl = hostctrl;

	spin_unlock_irqrestore(&rrpriv->lock, flags);

	udelay(1000);

	/*
	 * Now start the FirmWare.
	 */
	cmd.code = C_START_FW;
	cmd.ring = 0;
	cmd.index = 0;

	rr_issue_cmd(rrpriv, &cmd);

	/*
	 * Give the FirmWare time to chew on the `get running' command.
	 */
	myjif = jiffies + 5 * HZ;
	while ((jiffies < myjif) && !rrpriv->fw_running);

	for (i = 0; i < RX_RING_ENTRIES; i++) {
		struct sk_buff *skb;

		rrpriv->rx_ring[i].mode = 0;
		skb = alloc_skb(dev->mtu + HIPPI_HLEN, GFP_ATOMIC);
		rrpriv->rx_skbuff[i] = skb;
		/*
		 * Sanity test to see if we conflict with the DMA
		 * limitations of the Roadrunner.
		 */
		if ((((unsigned long)skb->data) & 0xfff) > ~65320)
			printk("skb alloc error\n");

#if (BITS_PER_LONG == 32)
		rrpriv->rx_ring[i].zero = 0;
#endif
		rrpriv->rx_ring[i].addr = virt_to_bus(skb->data);
		rrpriv->rx_ring[i].size = dev->mtu + HIPPI_HLEN;
	}

	rrpriv->rx_ctrl[4].entry_size = sizeof(struct rx_desc);
	rrpriv->rx_ctrl[4].entries = RX_RING_ENTRIES;
	rrpriv->rx_ctrl[4].mode = 8;
	rrpriv->rx_ctrl[4].pi = 0;
	rrpriv->rx_ctrl[4].rngptr = virt_to_bus(rrpriv->rx_ring);

	cmd.code = C_NEW_RNG;
	cmd.ring = 4;
	cmd.index = 0;
	rr_issue_cmd(rrpriv, &cmd);

#if 0
{
	u32 tmp;
	tmp = regs->ExtIo;
	regs->ExtIo = 0x80;
	
	i = jiffies + 1 * HZ;
	while (jiffies < i);
	regs->ExtIo = tmp;
}
#endif
	dev->tbusy = 0;
#if 0
	dev->interrupt = 0;
#endif
	dev->start = 1;
	return 0;
}


/*
 * All events are considered to be slow (RX/TX ints do not generate
 * events) and are handled here, outside the main interrupt handler,
 * to reduce the size of the handler.
 */
static u32 rr_handle_event(struct device *dev, u32 prodidx)
{
	struct rr_private *rrpriv;
	struct rr_regs *regs;
	u32 tmp, eidx;

	rrpriv = (struct rr_private *)dev->priv;
	regs = rrpriv->regs;
	eidx = rrpriv->info->evt_ctrl.pi;

	while (prodidx != eidx){
		switch (rrpriv->evt_ring[eidx].code){
		case E_NIC_UP:
			tmp = regs->FwRev;
			printk("%s: Firmware revision %i.%i.%i up and running\n",
			       dev->name, (tmp >> 16), ((tmp >> 8) & 0xff),
			       (tmp & 0xff));
			rrpriv->fw_running = 1;
			break;
		case E_LINK_ON:
			printk("%s: Optical link ON\n", dev->name);
			break;
		case E_LINK_OFF:
			printk("%s: Optical link OFF\n", dev->name);
			break;
		case E_RX_IDLE:
			printk("%s: RX data not moving\n", dev->name);
			break;
		case E_WATCHDOG:
			printk("%s: The watchdog is here to see us\n",
			       dev->name);
			break;
		/*
		 * TX events.
		 */
		case E_CON_REJ:
			printk("%s: Connection rejected\n", dev->name);
			rrpriv->stats.tx_aborted_errors++;
			break;
		case E_CON_TMOUT:
			printk("%s: Connection timeout\n", dev->name);
			break;
		case E_DISC_ERR:
			printk("%s: HIPPI disconnect error\n", dev->name);
			rrpriv->stats.tx_aborted_errors++;
			break;
		case E_TX_IDLE:
			printk("%s: Transmitter idle\n", dev->name);
			break;
		case E_TX_LINK_DROP:
			printk("%s: Link lost during transmit\n", dev->name);
			rrpriv->stats.tx_aborted_errors++;
			break;
		/*
		 * RX events.
		 */
		case E_VAL_RNG:		/* Should be ignored */
#if (DEBUG > 2)
			printk("%s: RX ring valid event\n", dev->name);
#endif
			regs->IpRxPi = RX_RING_ENTRIES - 1;
			break;
		case E_INV_RNG:
			printk("%s: RX ring invalid event\n", dev->name);
			break;
		case E_RX_RNG_OUT:
			printk("%s: Receive ring full\n", dev->name);
			break;

		case E_RX_PAR_ERR:
			printk("%s: Receive parity error.\n", dev->name);
			break;
		case E_RX_LLRC_ERR:
			printk("%s: Receive LLRC error.\n", dev->name);
			break;
		case E_PKT_LN_ERR:
			printk("%s: Receive packet length error.\n",
			       dev->name);
			break;
		default:
			printk("%s: Unhandled event 0x%02x\n",
			       dev->name, rrpriv->evt_ring[eidx].code);
		}
		eidx = (eidx + 1) % EVT_RING_ENTRIES;
	}

	rrpriv->info->evt_ctrl.pi = eidx;
	return eidx;
}


static int rx_int(struct device *dev, u32 rxlimit)
{
	struct rr_private *rrpriv = (struct rr_private *)dev->priv;
	u32 index, pkt_len;
	struct rr_regs *regs = rrpriv->regs;

	index = rrpriv->cur_rx;

	while(index != rxlimit){
		pkt_len = rrpriv->rx_ring[index].size;
#if (DEBUG > 2)
		printk("index %i, rxlimit %i\n", index, rxlimit);
		printk("len %x, mode %x\n", pkt_len,
		       rrpriv->rx_ring[index].mode);
#endif
#if 0
/*
 * I have never seen this occur
 */
		if(!(rrpriv->rx_skbuff[index])){
			printk("Trying to receive in empty skbuff\n");
			goto out;
		}
#endif

		if (pkt_len > 0){
			struct sk_buff *skb;

			if (pkt_len < PKT_COPY_THRESHOLD) {
				skb = alloc_skb(pkt_len, GFP_ATOMIC);
				if (skb == NULL){
					printk("%s: Out of memory deferring "
					       "packet\n", dev->name);
					rrpriv->stats.rx_dropped++;
					goto defer;
				}else
					memcpy(skb_put(skb, pkt_len),
					       rrpriv->rx_skbuff[index]->data,
					       pkt_len);
			}else{
				struct sk_buff *newskb;

				newskb = alloc_skb(dev->mtu + HIPPI_HLEN,
						   GFP_ATOMIC);
				if (newskb){
					skb = rrpriv->rx_skbuff[index];
					skb_put(skb, pkt_len);
					rrpriv->rx_skbuff[index] = newskb;
					rrpriv->rx_ring[index].addr = virt_to_bus(newskb->data);
				}else{
					printk("%s: Out of memory, deferring "
					       "packet\n", dev->name);
					rrpriv->stats.rx_dropped++;
					goto defer;
				}
			}
			skb->dev = dev;
			skb->protocol = hippi_type_trans(skb, dev);

			netif_rx(skb);		/* send it up */

			rrpriv->stats.rx_packets++;
			rrpriv->stats.rx_bytes += skb->len;
		}
	defer:
		rrpriv->rx_ring[index].mode = 0;
		rrpriv->rx_ring[index].size = dev->mtu + HIPPI_HLEN;

		if ((index & 7) == 7)
			regs->IpRxPi = index;

		index = (index + 1) % RX_RING_ENTRIES;
	}

	rrpriv->cur_rx = index;
	return index;
}


static void rr_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
{
	struct rr_private *rrpriv;
	struct rr_regs *regs;
	struct device *dev = (struct device *)dev_id;
	u32 prodidx, eidx, txcsmr, rxlimit, txcon;
	unsigned long flags;

	rrpriv = (struct rr_private *)dev->priv;
	regs = rrpriv->regs;

	if (!(regs->HostCtrl & RR_INT))
		return;

#if 0
	if (test_and_set_bit(0, (void*)&dev->interrupt) != 0) {
		printk("%s: Re-entering the interrupt handler.\n", dev->name);
		return;
	}
#endif

	spin_lock_irqsave(&rrpriv->lock, flags);

	prodidx = regs->EvtPrd;
	txcsmr = (prodidx >> 8) & 0xff;
	rxlimit = (prodidx >> 16) & 0xff;
	prodidx &= 0xff;

#if (DEBUG > 2)
	printk("%s: interrupt, prodidx = %i, eidx = %i\n", dev->name,
	       prodidx, rrpriv->info->evt_ctrl.pi);
#endif

	txcon = rrpriv->dirty_tx;
	if (txcsmr != txcon) {
		do {
			rrpriv->stats.tx_packets++;
			rrpriv->stats.tx_bytes +=rrpriv->tx_skbuff[txcon]->len;
			dev_kfree_skb(rrpriv->tx_skbuff[txcon]);

			rrpriv->tx_skbuff[txcon] = NULL;
			rrpriv->tx_ring[txcon].size = 0;
			rrpriv->tx_ring[txcon].addr = 0;
			rrpriv->tx_ring[txcon].mode = 0;

			txcon = (txcon + 1) % TX_RING_ENTRIES;
		} while (txcsmr != txcon);

		rrpriv->dirty_tx = txcon;
		if (rrpriv->tx_full && dev->tbusy &&
		    (((rrpriv->info->tx_ctrl.pi + 1) % TX_RING_ENTRIES)
		     != rrpriv->dirty_tx)){
			rrpriv->tx_full = 0;
			dev->tbusy = 0;
			mark_bh(NET_BH);
		}
	}

	rx_int(dev, rxlimit);

	eidx = rrpriv->info->evt_ctrl.pi;

	if (prodidx != eidx)
		eidx = rr_handle_event(dev, prodidx);

	eidx |= ((txcsmr << 8) | (rxlimit << 16));
	regs->EvtCon = eidx;

	spin_unlock_irqrestore(&rrpriv->lock, flags);

#if 0
	dev->interrupt = 0;
#endif
}


static int rr_open(struct device *dev)
{
	struct rr_private *rrpriv;