fec.c

linux驱动源码

		printk(", 10HDX");
	if (!(s & PHY_CONF_SPMASK))
		printk(", No speed/duplex selected?");

	if (s & PHY_CONF_LOOP)
		printk(", loopback enabled");

	printk(".\n");

	fep->sequence_done = 1;
}

static void mii_relink(struct net_device *dev)
{
	struct fec_enet_private *fep = dev->priv;
	int duplex;

	fep->link = (fep->phy_status & PHY_STAT_LINK) ? 1 : 0;
	mii_display_status(dev);
	fep->old_link = fep->link;

	if (fep->link) {
		duplex = 0;
		if (fep->phy_status
		    & (PHY_STAT_100FDX | PHY_STAT_10FDX))
			duplex = 1;
		fec_restart(dev, duplex);

		if (netif_queue_stopped(dev)) {
			netif_wake_queue(dev);
		}
	} else {
		netif_stop_queue(dev);
		fec_stop(dev);
	}
}

static void mii_queue_relink(uint mii_reg, struct net_device *dev, uint data)
{
	struct fec_enet_private *fep = dev->priv;

	fep->phy_task.routine = (void *)mii_relink;
	fep->phy_task.data = dev;
	schedule_task(&fep->phy_task);
}

static void mii_queue_config(uint mii_reg, struct net_device *dev, uint data)
{
	struct fec_enet_private *fep = dev->priv;

	fep->phy_task.routine = (void *)mii_display_config;
	fep->phy_task.data = dev;
	schedule_task(&fep->phy_task);
}



phy_cmd_t phy_cmd_relink[] = { { mk_mii_read(MII_REG_CR), mii_queue_relink },
			       { mk_mii_end, } };
phy_cmd_t phy_cmd_config[] = { { mk_mii_read(MII_REG_CR), mii_queue_config },
			       { mk_mii_end, } };



/* Read remainder of PHY ID.
*/
static void
mii_discover_phy3(uint mii_reg, struct net_device *dev, uint data)
{
	struct fec_enet_private *fep;
	int	i;

	fep = dev->priv;
	fep->phy_id |= (mii_reg & 0xffff);

	for(i = 0; phy_info[i]; i++)
		if(phy_info[i]->id == (fep->phy_id >> 4))
			break;

	if(!phy_info[i])
		panic("%s: PHY id 0x%08x is not supported!\n",
		      dev->name, fep->phy_id);

	fep->phy = phy_info[i];
	fep->phy_id_done = 1;

	printk("%s: Phy @ 0x%x, type %s (0x%08x)\n",
		dev->name, fep->phy_addr, fep->phy->name, fep->phy_id);
}

/* Scan all of the MII PHY addresses looking for someone to respond
 * with a valid ID.  This usually happens quickly.
 */
static void
mii_discover_phy(uint mii_reg, struct net_device *dev, uint data)
{
	struct fec_enet_private *fep;
	uint	phytype;

	fep = dev->priv;

	if ((phytype = (mii_reg & 0xffff)) != 0xffff) {

		/* Got first part of ID, now get remainder.
		*/
		fep->phy_id = phytype << 16;
		mii_queue (dev, mk_mii_read(MII_REG_PHYIR2),
				mii_discover_phy3, 0);
	} else {
		fep->phy_addr++;
		if (fep->phy_addr < 32) {
			mii_queue (dev, mk_mii_read(MII_REG_PHYIR1),
					mii_discover_phy, 0);
		} else {
			printk("fec: No PHY device found.\n");
		}
	}
}
#endif	/* CONFIG_USE_MDIO */

/* This interrupt occurs when the PHY detects a link change.
*/
static void
#ifdef CONFIG_RPXCLASSIC
mii_link_interrupt(void *dev_id)
#else
mii_link_interrupt(int irq, void * dev_id, struct pt_regs * regs)
#endif
{
#ifdef	CONFIG_USE_MDIO
	struct	net_device *dev = dev_id;
	struct fec_enet_private *fep = dev->priv;
	volatile immap_t *immap = (immap_t *)IMAP_ADDR;
	volatile fec_t *fecp = &(immap->im_cpm.cp_fec);
	unsigned int ecntrl = fecp->fec_ecntrl;

        /*
         * Acknowledge the interrupt if possible. If we have not
         * found the PHY yet we can't process or acknowledge the
         * interrupt now. Instead we ignore this interrupt for now,
         * which we can do since it is edge triggered. It will be
         * acknowledged later by fec_enet_open().
	 */
	if (fep->phy) {
		/*
		 * We need the FEC enabled to access the MII
		 */
		if ((ecntrl & FEC_ECNTRL_ETHER_EN) == 0) {
			fecp->fec_ecntrl |= FEC_ECNTRL_ETHER_EN;
		}

		mii_do_cmd(dev, fep->phy->ack_int);
		mii_do_cmd(dev, phy_cmd_relink);  /* restart and display status */

		if ((ecntrl & FEC_ECNTRL_ETHER_EN) == 0) {
			fecp->fec_ecntrl = ecntrl;	/* restore old settings */
		}
	}
#else
	printk ("FEC: unexpected Link interrupt\n");
#endif	/* CONFIG_USE_MDIO */

}

static int
fec_enet_open(struct net_device *dev)
{
	struct fec_enet_private *fep = dev->priv;

	/* I should reset the ring buffers here, but I don't yet know
	 * a simple way to do that.
	 */

#ifdef	CONFIG_USE_MDIO
	fep->sequence_done = 0;
	fep->link = 0;

	if (fep->phy) {
	/*	mii_do_cmd(dev, fep->phy->ack_int);	*/
		mii_do_cmd(dev, fep->phy->config);
		mii_do_cmd(dev, phy_cmd_config);  /* display configuration */
		while(!fep->sequence_done)
			schedule();

		mii_do_cmd(dev, fep->phy->startup);

#if defined(CONFIG_USE_MDIO) && defined(CONFIG_FEC_DP83846A)
		if(fep->phy == &phy_info_dp83846a) {
			/* Initializing timers
			 */
			init_timer( &fep->phy_timer_list );

			/* Starting timer for periodic link status check
			 * After 100 milli-seconds, mdio_timer_callback function is called.
			 */
			fep->phy_timer_list.expires  = jiffies + (100 * HZ / 1000);
			fep->phy_timer_list.data     = (unsigned long)dev;
			fep->phy_timer_list.function = mdio_timer_callback;
			add_timer( &fep->phy_timer_list );
		}

#if defined(CONFIG_IP_PNP)
        printk("%s: Waiting for the link to be up...\n", dev->name);

        while ( fep->link == 0 ||
		((((volatile fec_t*)dev->base_addr)->fec_ecntrl & FEC_ECNTRL_ETHER_EN) == 0))
        {
            schedule();
        }
#endif /* CONFIG_IP_PNP */

#endif /* CONFIG_USE_MDIO && CONFIG_FEC_DP83846A */

		netif_start_queue(dev);
		return 0;		/* Success */
	}
	return -ENODEV;		/* No PHY we understand */
#else
	fep->link = 1;
	netif_start_queue(dev);
	return 0;	/* Success */
#endif	/* CONFIG_USE_MDIO */

}

static int
fec_enet_close(struct net_device *dev)
{
	/* Don't know what to do yet.
	*/
	netif_stop_queue(dev);
	fec_stop(dev);

	return 0;
}

static struct net_device_stats *fec_enet_get_stats(struct net_device *dev)
{
	struct fec_enet_private *fep = (struct fec_enet_private *)dev->priv;

	return &fep->stats;
}

#ifdef CONFIG_USE_MDIO

#if defined(CONFIG_FEC_DP83846A)
/* Execute the ack_int command set and schedules next timer call back.  */
static void mdio_timer_callback(unsigned long data)
{
	struct net_device *dev = (struct net_device *)data;
	struct fec_enet_private *fep = (struct fec_enet_private *)(dev->priv);
	mii_do_cmd(dev, fep->phy->ack_int);

	if(fep->link == 0) {
		fep->phy_timer_list.expires  = jiffies + (100 * HZ / 1000); /* Sleep for 100ms */
	} else {
		fep->phy_timer_list.expires  = jiffies + (1 * HZ); /* Sleep for 1 sec. */
	}
	add_timer( &fep->phy_timer_list );
}
#endif /* CONFIG_FEC_DP83846A */

static void mdio_callback(uint regval, struct net_device *dev, uint data)
{
	mdio_read_data_t* mrd = (mdio_read_data_t *)data;
	mrd->regval = 0xFFFF & regval;
	wake_up_process(mrd->sleeping_task);
}

static int mdio_read(struct net_device *dev, int phy_id, int location)
{
	uint retval;
	mdio_read_data_t* mrd = (mdio_read_data_t *)kmalloc(sizeof(*mrd), GFP_KERNEL);

	mrd->sleeping_task = current;
	set_current_state(TASK_INTERRUPTIBLE);
	mii_queue(dev, mk_mii_read(location), mdio_callback, (unsigned int) mrd);
	schedule();

	retval = mrd->regval;

	kfree(mrd);

	return retval;
}

void mdio_write(struct net_device *dev, int phy_id, int location, int value)
{
	mii_queue(dev, mk_mii_write(location, value), NULL, 0);
}

static int fec_enet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
	struct fec_enet_private *cep = (struct fec_enet_private *)dev->priv;
	struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;

	int phy = cep->phy_addr & 0x1f;
	int retval;

	if (data == NULL) {
		retval = -EINVAL;
	} else {
		switch(cmd) {
		case SIOCETHTOOL:
			return netdev_ethtool_ioctl(dev, (void*)rq->ifr_data);
			break;

		case SIOCGMIIPHY:		/* Get address of MII PHY in use. */
		case SIOCDEVPRIVATE:		/* for binary compat, remove in 2.5 */
			data->phy_id = phy;

		case SIOCGMIIREG:		/* Read MII PHY register.	*/
		case SIOCDEVPRIVATE+1:		/* for binary compat, remove in 2.5 */
			data->val_out = mdio_read (dev,
						data->phy_id & 0x1f,
						data->reg_num & 0x1f);
			retval = 0;
			break;

		case SIOCSMIIREG:		/* Write MII PHY register.	*/
		case SIOCDEVPRIVATE+2:		/* for binary compat, remove in 2.5 */
			if (!capable(CAP_NET_ADMIN)) {
				retval = -EPERM;
			} else {
				mdio_write(dev,
					data->phy_id & 0x1f,
					data->reg_num & 0x1f,
					data->val_in);
				retval = 0;
			}
			break;

		default:
			retval = -EOPNOTSUPP;
			break;
		}
	}
	return retval;
}


static int netdev_ethtool_ioctl (struct net_device *dev, void *useraddr)
{
	u32 ethcmd;

	/* dev_ioctl() in ../../net/core/dev.c has already checked
	   capable(CAP_NET_ADMIN), so don't bother with that here.  */

	if (copy_from_user (&ethcmd, useraddr, sizeof (ethcmd)))
		return -EFAULT;

	switch (ethcmd) {
	case ETHTOOL_GDRVINFO:
		{
			struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
			strcpy (info.driver, dev->name);
			strcpy (info.version, "0.2");
			strcpy (info.bus_info, "");
			if (copy_to_user (useraddr, &info, sizeof (info)))
				return -EFAULT;
			return 0;
		}
	default:
		break;
	}

	return -EOPNOTSUPP;
}

#endif	/* CONFIG_USE_MDIO */


/* Returns the CRC needed when filling in the hash table for
 * multicast group filtering
 * pAddr must point to a MAC address (6 bytes)
 */
static u32 fec_mulicast_calc_crc(char *pAddr)
{
	u8	byte;
	int	byte_count;
	int	bit_count;
	u32	crc = 0xffffffff;
	u8	msb;

	for (byte_count=0; byte_count<6; byte_count++) {
        	byte = pAddr[byte_count];
		for (bit_count=0; bit_count<8; bit_count++) {
            		msb = crc >> 31;
            		crc <<= 1;
            		if (msb ^ (byte & 0x1)) {
                		crc ^= FEC_CRC_POLY;
   	    		}
            		byte >>= 1;
		}
        }
	return (crc);
}

/* Set or clear the multicast filter for this adaptor.
 * Skeleton taken from sunlance driver.
 * The CPM Ethernet implementation allows Multicast as well as individual
 * MAC address filtering.  Some of the drivers check to make sure it is
 * a group multicast address, and discard those that are not.  I guess I
 * will do the same for now, but just remove the test if you want
 * individual filtering as well (do the upper net layers want or support
 * this kind of feature?).
 */

static void set_multicast_list(struct net_device *dev)
{
	struct	fec_enet_private *fep;
	volatile fec_t *ep;

	fep = (struct fec_enet_private *)dev->priv;
	ep = &(((immap_t *)IMAP_ADDR)->im_cpm.cp_fec);

	if (dev->flags&IFF_PROMISC) {

		/* Log any net taps. */
		printk("%s: Promiscuous mode enabled.\n", dev->name);
		ep->fec_r_cntrl |= FEC_RCNTRL_PROM;
	} else {

		ep->fec_r_cntrl &= ~FEC_RCNTRL_PROM;

		if (dev->flags & IFF_ALLMULTI) {
			/* Catch all multicast addresses, so set the
			 * filter to all 1's.
			 */
			ep->fec_hash_table_high = 0xffffffff;
			ep->fec_hash_table_low = 0xffffffff;
		} else {
			struct dev_mc_list *pmc = dev->mc_list;

			/* Clear Hash-Table
			*/
			ep->fec_hash_table_high = 0;
			ep->fec_hash_table_low = 0;

			/* Now populate the hash table
			*/
#ifdef DEBUG_MULTICAST
			if (pmc) {
				printk ("%s: Recalculating hash-table:\n",
					dev->name);
				printk (" MAC Address         high     low\n");
			}
#endif

			while (pmc) {
				u32	crc;
				int	temp;
				u32	csrVal;
				int	hash_index;

				crc = fec_mulicast_calc_crc(pmc->dmi_addr);
				temp = (crc & 0x3f) >> 1;
				hash_index = ((temp & 0x01) << 4) |
					     ((temp & 0x02) << 2) |
					     ((temp & 0x04))      |
					     ((temp & 0x08) >> 2) |
					     ((temp & 0x10) >> 4);
				csrVal = (1 << hash_index);
				if (crc & 1) {
					ep->fec_hash_table_high	|= csrVal;
				}
				else {
					ep->fec_hash_table_low	|= csrVal;
				}
#ifdef DEBUG_MULTICAST
				printk (" %02x:%02x:%02x:%02x:%02x:%02x   %08x %08x\n",
					(int)pmc->dmi_addr[0],
					(int)pmc->dmi_addr[1],
					(int)pmc->dmi_addr[2],
					(int)pmc->dmi_addr[3],
					(int)pmc->dmi_addr[4],
					(int)pmc->dmi_addr[5],
					ep->fec_hash_table_high,
					ep->fec_hash_table_low
				);
#endif
				pmc = pmc->next;
			}
		}
#if 0
		else {
			/* Clear filter and add the addresses in the list.
			*/
			ep->sen_gaddr1 = 0;
			ep->sen_gaddr2 = 0;
			ep->sen_gaddr3 = 0;
			ep->sen_gaddr4 = 0;

			dmi = dev->mc_list;

			for (i=0; i<dev->mc_count; i++) {