gpio模拟mdc/mdio通信

本文主要是学习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,);
 }

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

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

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

     gpio_dev.pin = MDC;
     gpio_dev.value = ;
     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 = ;
     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 - ; i >= ; i--)
         mdio_bb_send_bit((value >> i) & );
 }

  /*
   *  MDIO获取一个数据,MDIO 必须被配置为输入模式.
   *  bits:获取数据的位数
   *
   *  */
 static int mdio_bb_get_num(int bits)
 {
     int i;
     int ret = ;
     for(i = bits - ; i >= ; i--)
     {
         ret <<= ;
         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 =  ;
     MDIO_OUT();  //设置MDIO引脚为输出引脚

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

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

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

 #else
     mdio_bb_send_bit();
     mdio_bb_send_bit();

 #endif
     mdio_bb_send_bit((op >> ) & );
     mdio_bb_send_bit((op >> ) & );

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

 }

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

     mdio_bb_cmd(MDIO_C45_ADDR,phy,dev_addr);

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

     mdio_bb_send_num(reg,);

     MDIO_IN();
     mdio_bb_get_bit();

     return dev_addr;
 }

 void mdio_set_turnaround(void)
 {
     int i = ;

     MDIO_IN();
     MDC_OUT();
     for(i=;i<;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() != )
     {
         /* PHY didn't driver TA low -- flush any bits it may be trying to send*/
         for(i = ; i < ; i++)
             mdio_bb_get_bit();
         return 0xFFFF;
     }

     ret = mdio_bb_get_num();
     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();
     mdio_bb_send_bit();
 #else
     mdio_set_turnaround();
 #endif
     mdio_bb_send_num(val,);

     MDIO_IN();
     //mdio_bb_get_bit();

     return ;
 }

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

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

 static long mdio_ctrl_drv_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
     phy_reg_cblk_t phy_reg;
     int ret = ;

      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 ;
 }

 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 = ;

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

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

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