Examples

本文主要是学习gpio模拟mdc/mdio通信。

运行环境是在ATMEL的sama5d35MCU，两个GPIO引脚模拟MDC/MDIO通信，读取百兆phy的寄存器的值。

#include<linux/init.h>
#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/sched.h>
#include<linux/init.h>
#include<linux/sched.h>
#include<linux/completion.h>
#include <asm/system.h>
#include <linux/param.h>
#include<linux/gpio.h>
#include<linux/cdev.h>
#include<linux/fs.h>
#include<linux/device.h>
#include<linux/slab.h>
#include<asm/uaccess.h>
#include<linux/delay.h>
#include<linux/miscdevice.h>


/* bb:bit-bang,通过gpio引脚，用软件模拟通信*/

#define MDIO 117  /* MDIO correspond PD21 */
#define MDC 116  /* MDC correspond PD20 */
#define MDIO_DELAY 250
#define MDIO_READ_DELAY 350

/*  Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit 
 *   IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips. 
 *   */ 
#define MII_ADDR_C45 (1<<30)

#define MDIO_READ 2
#define MDIO_WRITE 1

#define MDIO_C45 (1<<15)
#define MDIO_C45_ADDR (MDIO_C45 | 0)
#define MDIO_C45_READ (MDIO_C45 | 3)
#define MDIO_C45_WRITE (MDIO_C45 | 1)

#define MDIO_SETUP_TIME 10
#define MDIO_HOLD_TIME 10


//#define READ_REG 0x37
//#define WRITE_REG 0x38


#define MDIO_C45_TEST 0


typedef struct gpio_ctrl_blk{
    int pin;
    int value;
}gpio_cblk_t;

typedef struct phy_reg_blk{
    unsigned int phy_address;
    unsigned int reg_address;
    unsigned int reg_value;
}phy_reg_cblk_t;


#define MDIO_DEV_ID 't'
#define READ_REG             _IOWR (MDIO_DEV_ID,0x37,phy_reg_cblk_t)
#define WRITE_REG            _IOWR (MDIO_DEV_ID,0x38,phy_reg_cblk_t)
static void MDC_OUT(void);
static void MDIO_OUT(void);
static void MDIO_IN(void);
static void MDC_H(void);
static void MDC_L(void);
static int GET_MDIO(void);
static void SET_MDIO(int val);


/* 设置MDC为输出引脚，在MDC输出时钟之前设置 */
static void MDC_OUT(void)
{
    gpio_cblk_t gpio_dev;
    gpio_dev.pin = MDC;
    at91_set_gpio_output(gpio_dev.pin,1); 
}

/* 设置MDIO的gpio引脚为输出引脚 */
static void MDIO_OUT(void)
{
    gpio_cblk_t gpio_dev;
    gpio_dev.pin = MDIO;
    at91_set_gpio_output(gpio_dev.pin,1); 
}

/* 设置MDIO的gpio引脚为输入引脚 */
static void MDIO_IN(void)
{
    gpio_cblk_t gpio_dev;
    gpio_dev.pin = MDIO;
    at91_set_gpio_input(gpio_dev.pin,1); 
}

/* MDC输出高电平，在MDC设置为输出后调用 */
static void MDC_H(void)
{
    gpio_cblk_t gpio_dev;

    gpio_dev.pin = MDC;
    gpio_dev.value = 1;
    at91_set_gpio_value(gpio_dev.pin,gpio_dev.value);
}

/* MDC输出低电平，在MDC设置为输出后调用 */
static void MDC_L(void)
{
    gpio_cblk_t gpio_dev;

    gpio_dev.pin = MDC;
    gpio_dev.value = 0;
    at91_set_gpio_value(gpio_dev.pin,gpio_dev.value);
}

/* 获得MDIO的数据，只获得一个bit */
static int GET_MDIO(void)
{
    gpio_cblk_t gpio_dev;

    gpio_dev.pin = MDIO;
    gpio_dev.value = at91_get_gpio_value(gpio_dev.pin);

    return gpio_dev.value;
}

/* 设置MDIO的数据，一个bit */
static void SET_MDIO(int val)
{
    gpio_cblk_t gpio_dev;

    gpio_dev.pin = MDIO;
    gpio_dev.value = val;
    at91_set_gpio_value(gpio_dev.pin,gpio_dev.value);
}


/* MDIO发送一个bit的数据，MDIO必须已经被配置为输出 */
static void mdio_bb_send_bit(int val)
{
    MDC_OUT();    
    SET_MDIO(val);
    ndelay(MDIO_DELAY);
    MDC_L();
    ndelay(MDIO_DELAY);
    MDC_H();
}

/*  MDIO 获取一个bit的数据，MDIO必须已经被配置为输入. */   
static int mdio_bb_get_bit(void)
{
    int value;

    MDC_OUT();    
    ndelay(MDIO_DELAY);
    MDC_L();
    ndelay(MDIO_READ_DELAY);
//    ndelay(MDIO_DELAY);
    MDC_H();
    
    value = GET_MDIO();
    
    return value;
}

 /*  
  *  MDIO发送一个数据,MDIO 必须被配置为输出模式. 
  *  value:要发送的数据
  *  bits:数据的位数
  *  
  *  */  
static void mdio_bb_send_num(unsigned int value ,int bits)
{
    int i;
    MDIO_OUT();
    
    for(i = bits - 1; i >= 0; i--)
        mdio_bb_send_bit((value >> i) & 1);
}

 /*  
  *  MDIO获取一个数据,MDIO 必须被配置为输入模式. 
  *  bits:获取数据的位数
  *  
  *  */  
static int mdio_bb_get_num(int bits)
{
    int i;
    int ret = 0;
    for(i = bits - 1; i >= 0; i--)
    {
        ret <<= 1;
        ret |= mdio_bb_get_bit(); 
    }

    return ret;
}



/*  Utility to send the preamble, address, and
*   register (common to read and write). 
*/
static void mdio_bb_cmd(int op,int phy,int reg)
{
    int i = 0 ;
    MDIO_OUT();  //设置MDIO引脚为输出引脚

    /*发送32bit的1，这个帧前缀域不是必须的，某些物理层芯片的MDIO操作就没有这个域*/
    for(i = 0; i < 32; i++)
        mdio_bb_send_bit(1);


    /* 发送开始位(01),和读操作码(10),写操作码(01)
     * Clause 45 操作，开始位是(00),(11)为读,(10)为写
    */

#if MDIO_C45_TEST
    mdio_bb_send_bit(0);
    if(op & MDIO_C45)
        mdio_bb_send_bit(0);
    else
        mdio_bb_send_bit(1);


#else
    mdio_bb_send_bit(0);
    mdio_bb_send_bit(1);
    
#endif
    mdio_bb_send_bit((op >> 1) & 1);
    mdio_bb_send_bit((op >> 0) & 1);

    mdio_bb_send_num(phy,5);
    mdio_bb_send_num(reg,5);

}

static int mdio_bb_cmd_addr(int phy,int addr)
{
    unsigned int dev_addr = (addr >> 16) & 0x1F;
    unsigned int reg = addr & 0xFFFF;

    mdio_bb_cmd(MDIO_C45_ADDR,phy,dev_addr);

    /*  send the turnaround (10) */  
    mdio_bb_send_bit(1);
    mdio_bb_send_bit(0);

    mdio_bb_send_num(reg,16);
    
    MDIO_IN();
    mdio_bb_get_bit();

    return dev_addr;
}

void mdio_set_turnaround(void)
{
    int i = 0;

    MDIO_IN();
    MDC_OUT();
    for(i=0;i<2;i++)
    {
        ndelay(MDIO_DELAY);
        MDC_L();
        ndelay(MDIO_DELAY);
        MDC_H();
    }
}

static unsigned int mdio_bb_read(int phy,int reg)
{
    unsigned int ret,i;

#if MDIO_C45_TEST
    /* 寄存器是否满足有C45标志 */
    if(reg & MII_ADDR_C45)
    {
        reg = mdio_bb_cmd_addr(phy,reg);
        mdio_bb_cmd(MDIO_C45_READ,phy,reg);
    }
    else
        mdio_bb_cmd(MDIO_READ,phy,reg);
#else
        mdio_bb_cmd(MDIO_READ,phy,reg);
#endif
    MDIO_IN();
    //mdio_set_turnaround();
    /*  check the turnaround bit: the PHY should be driving it to zero */ 
    if(mdio_bb_get_bit() != 0)
    {
        /* PHY didn't driver TA low -- flush any bits it may be trying to send*/
        for(i = 0; i < 32; i++)
            mdio_bb_get_bit();
        return 0xFFFF;
    }

    ret = mdio_bb_get_num(16);
    mdio_bb_get_bit();
    
    return ret;
}



static int mdio_bb_write(unsigned int phy,unsigned int reg,unsigned int val)
{
#if MDIO_C45_TEST
    if(reg & MII_ADDR_C45)
    {
        reg = mdio_bb_cmd_addr(phy,reg);
        mdio_bb_cmd(MDIO_C45_WRITE,phy,reg);
    }
    else
        mdio_bb_cmd(MDIO_WRITE,phy,reg);
#else
        mdio_bb_cmd(MDIO_WRITE,phy,reg);
#endif


#if 1
    /*  send the turnaround (10) */  
    mdio_bb_send_bit(1);
    mdio_bb_send_bit(0);
#else
    mdio_set_turnaround();
#endif
    mdio_bb_send_num(val,16);
    
    MDIO_IN();
    //mdio_bb_get_bit();

    return 0;
}


static int mdio_ctrl_drv_open(struct inode *inode, struct file *file )
{
    return 0;
}

static int mdio_ctrl_drv_release(struct inode *inode, struct file *file )
{
    return 0;
}

static long mdio_ctrl_drv_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    phy_reg_cblk_t phy_reg;
    int ret = 0;
    
     void __user *argp = (void __user *)arg;
     if( argp==NULL )
     {
         return -EFAULT; 
     }

    if (copy_from_user(&phy_reg, argp, sizeof(phy_reg_cblk_t))) {
                return -EFAULT;
            }
    
    switch (cmd) {
    case READ_REG:
            phy_reg.reg_value = mdio_bb_read(phy_reg.phy_address,phy_reg.reg_address);
            if(copy_to_user(argp,&phy_reg,sizeof(phy_reg_cblk_t)))
            {
                return -EFAULT;
            }
            break;
    case WRITE_REG:
            ret = mdio_bb_write(phy_reg.phy_address,phy_reg.reg_address,phy_reg.reg_value);
    default:
        return -EINVAL;

    }
    
    return 0;
}

static struct file_operations mdio_ctl_drv_fileops = {
    .owner = THIS_MODULE,
    .open = mdio_ctrl_drv_open,
    .unlocked_ioctl = mdio_ctrl_drv_unlocked_ioctl,
    .release = mdio_ctrl_drv_release
};

static struct miscdevice mdio_dev = {
    MISC_DYNAMIC_MINOR,
    "mdio_dev",
    &mdio_ctl_drv_fileops,
};


int mdio_ctrl_drv_module_init(void)
{
    int ret = 0;

    ret = misc_register(&mdio_dev);
    if(ret != 0)
    {
        ret = -EFAULT;
        return ret;
    }
    printk("mdio_drv_init ok
");
    return 0;
}


void mdio_ctrl_drv_module_exit(void)
{
    misc_deregister(&mdio_dev);
    printk("mdio_drv_exit ok
");
}



module_init(mdio_ctrl_drv_module_init);
module_exit(mdio_ctrl_drv_module_exit);
MODULE_LICENSE("GPL");