Skip to content
Snippets Groups Projects
tsec.c 28.3 KiB
Newer Older
  • Learn to ignore specific revisions
  • 	&phy_info_lxt971,
    
    	NULL
    };
    
    
    /* Grab the identifier of the device's PHY, and search through
    
     * all of the known PHYs to see if one matches.	 If so, return
    
     * it, if not, return NULL */
    struct phy_info * get_phy_info(struct eth_device *dev)
    {
    	struct tsec_private *priv = (struct tsec_private *)dev->priv;
    	uint phy_reg, phy_ID;
    	int i;
    	struct phy_info *theInfo = NULL;
    
    	/* Grab the bits from PHYIR1, and put them in the upper half */
    	phy_reg = read_phy_reg(priv, MIIM_PHYIR1);
    	phy_ID = (phy_reg & 0xffff) << 16;
    
    	/* Grab the bits from PHYIR2, and put them in the lower half */
    	phy_reg = read_phy_reg(priv, MIIM_PHYIR2);
    	phy_ID |= (phy_reg & 0xffff);
    
    	/* loop through all the known PHY types, and find one that */
    	/* matches the ID we read from the PHY. */
    	for(i=0; phy_info[i]; i++) {
    		if(phy_info[i]->id == (phy_ID >> phy_info[i]->shift))
    			theInfo = phy_info[i];
    	}
    
    	if(theInfo == NULL)
    	{
    		printf("%s: PHY id %x is not supported!\n", dev->name, phy_ID);
    		return NULL;
    	} else {
    
    		debug("%s: PHY is %s (%x)\n", dev->name, theInfo->name, phy_ID);
    
    
    /* Execute the given series of commands on the given device's
     * PHY, running functions as necessary*/
    void phy_run_commands(struct tsec_private *priv, struct phy_cmd *cmd)
    {
    	int i;
    	uint result;
    	volatile tsec_t *phyregs = priv->phyregs;
    
    	phyregs->miimcfg = MIIMCFG_RESET;
    
    	phyregs->miimcfg = MIIMCFG_INIT_VALUE;
    
    	while(phyregs->miimind & MIIMIND_BUSY);
    
    	for(i=0;cmd->mii_reg != miim_end;i++) {
    		if(cmd->mii_data == miim_read) {
    			result = read_phy_reg(priv, cmd->mii_reg);
    
    			if(cmd->funct != NULL)
    				(*(cmd->funct))(result, priv);
    
    		} else {
    			if(cmd->funct != NULL)
    				result = (*(cmd->funct))(cmd->mii_reg, priv);
    			else
    				result = cmd->mii_data;
    
    			write_phy_reg(priv, cmd->mii_reg, result);
    
    		}
    		cmd++;
    	}
    }
    
    
    /* Relocate the function pointers in the phy cmd lists */
    static void relocate_cmds(void)
    {
    	struct phy_cmd **cmdlistptr;
    	struct phy_cmd *cmd;
    	int i,j,k;
    	DECLARE_GLOBAL_DATA_PTR;
    
    	for(i=0; phy_info[i]; i++) {
    		/* First thing's first: relocate the pointers to the
    		 * PHY command structures (the structs were done) */
    		phy_info[i] = (struct phy_info *) ((uint)phy_info[i]
    				+ gd->reloc_off);
    		phy_info[i]->name += gd->reloc_off;
    		phy_info[i]->config =
    			(struct phy_cmd *)((uint)phy_info[i]->config
    					   + gd->reloc_off);
    		phy_info[i]->startup =
    			(struct phy_cmd *)((uint)phy_info[i]->startup
    					   + gd->reloc_off);
    		phy_info[i]->shutdown =
    			(struct phy_cmd *)((uint)phy_info[i]->shutdown
    					   + gd->reloc_off);
    
    		cmdlistptr = &phy_info[i]->config;
    		j=0;
    		for(;cmdlistptr <= &phy_info[i]->shutdown;cmdlistptr++) {
    			k=0;
    			for(cmd=*cmdlistptr;cmd->mii_reg != miim_end;cmd++) {
    				/* Only relocate non-NULL pointers */
    				if(cmd->funct)
    					cmd->funct += gd->reloc_off;
    
    				k++;
    			}
    			j++;
    		}
    	}
    
    	relocated = 1;
    }
    
    
    
    #if defined(CONFIG_MII) || (CONFIG_COMMANDS & CFG_CMD_MII) \
    	&& !defined(BITBANGMII)
    
    
    struct tsec_private * get_priv_for_phy(unsigned char phyaddr)
    {
    	int i;
    
    	for(i=0;i<MAXCONTROLLERS;i++) {
    		if(privlist[i]->phyaddr == phyaddr)
    			return privlist[i];
    	}
    
    	return NULL;
    }
    
    
    /*
     * Read a MII PHY register.
     *
     * Returns:
    
    static int tsec_miiphy_read(char *devname, unsigned char addr,
    		unsigned char reg, unsigned short *value)
    
    	unsigned short ret;
    	struct tsec_private *priv = get_priv_for_phy(addr);
    
    	if(NULL == priv) {
    		printf("Can't read PHY at address %d\n", addr);
    		return -1;
    	}
    
    	ret = (unsigned short)read_phy_reg(priv, reg);
    	*value = ret;
    
    
    	return 0;
    }
    
    /*
     * Write a MII PHY register.
     *
     * Returns:
    
    static int tsec_miiphy_write(char *devname, unsigned char addr,
    		unsigned char reg, unsigned short value)
    
    	struct tsec_private *priv = get_priv_for_phy(addr);
    
    	if(NULL == priv) {
    		printf("Can't write PHY at address %d\n", addr);
    		return -1;
    	}
    
    	write_phy_reg(priv, reg, value);
    
    #endif /* defined(CONFIG_MII) || (CONFIG_COMMANDS & CFG_CMD_MII)
    		&& !defined(BITBANGMII) */
    
    #endif /* CONFIG_TSEC_ENET */