linux get phy id不对,linux kernel对phy中断的设计

1. phy设备何处获得irq编号

在phy_device_create函数里面， dev->irq从bus->irq[addr]获得， 所以如果希望phy

设备跟中断联系起来，需要在mdio bus里面为irq[addr]赋值。

struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,

bool is_c45,

struct phy_c45_device_ids *c45_ids)

{

struct phy_device *dev;

/* We allocate the device, and initialize the default values */

dev = kzalloc(sizeof(*dev), GFP_KERNEL);

if (NULL == dev)

return (struct phy_device *)PTR_ERR((void *)-ENOMEM);

dev->dev.release = phy_device_release;

dev->speed = 0;

dev->duplex = -1;

dev->pause = 0;

dev->asym_pause = 0;

dev->link = 1;

dev->interface = PHY_INTERFACE_MODE_GMII;

dev->autoneg = AUTONEG_ENABLE;

dev->is_c45 = is_c45;

dev->addr = addr;

dev->phy_id = phy_id;

if (c45_ids)

dev->c45_ids = *c45_ids;

dev->bus = bus;

dev->dev.parent = bus->parent;

dev->dev.bus = &mdio_bus_type;

dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;

dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);

dev->state = PHY_DOWN;

mutex_init(&dev->lock);

/* 注意这里初始化了两个工作队列*/

/* dev->state_queue这个工作队列在这里只是初始化了一下，当并没有调度，在什么地方调度呢？*/

INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);

INIT_WORK(&dev->phy_queue, phy_change);

/* Request the appropriate module unconditionally; don't

* bother trying to do so only if it isn't already loaded,

* because that gets complicated. A hotplug event would have

* done an unconditional modprobe anyway.

* We don't do normal hotplug because it won't work for MDIO

* -- because it relies on the device staying around for long

* enough for the driver to get loaded. With MDIO, the NIC

* driver will get bored and give up as soon as it finds that

* there's no driver _already_ loaded.

*/

request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));

device_initialize(&dev->dev);

return dev;

}

2. net_device的和phy_device何时关联到一起

net_device的open函数通常会调用phy_connect函数将net_device的和phy_device关联到一起。

以cpsw.c为例，函数调用的顺序为：

cpsw_ndo_open->

cpsw_slave_open->

phy_connect(priv->ndev, slave->data->phy_id,

&cpsw_adjust_link, slave->data->phy_if);

->phy_connect_direct

->phy_start_machine(phydev);

->queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ);

static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)

{

.......

slave->phy = phy_connect(priv->ndev, slave->data->phy_id,

&cpsw_adjust_link, slave->data->phy_if);

if (IS_ERR(slave->phy)) {

dev_err(priv->dev, "phy %s not found on slave %d\n",

slave->data->phy_id, slave->slave_num);

slave->phy = NULL;

} else {

dev_info(priv->dev, "phy found : id is : 0x%x\n",

slave->phy->phy_id);

phy_start(slave->phy);

/* Configure GMII_SEL register */

cpsw_phy_sel(&priv->pdev->dev, slave->phy->interface,

slave->slave_num);

}

}

------

看看phy_connect实际干了什么

mdio总线在scan时，已经调用phy_device_create函数创建了phy_device, 并且把这个device注册到mdio总线上了，此处从总线上找到名称为bus_id的phy_device. 将net_device与

phy_device建立起联系。

struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,

void (*handler)(struct net_device *),

phy_interface_t interface)

{

struct phy_device *phydev;

struct device *d;

int rc;

/* Search the list of PHY devices on the mdio bus for the

* PHY with the requested name

*/

d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);

if (!d) {

pr_err("PHY %s not found\n", bus_id);

return ERR_PTR(-ENODEV);

}

phydev = to_phy_device(d);

rc = phy_connect_direct(dev, phydev, handler, interface);

if (rc)

return ERR_PTR(rc);

return phydev;

}

在phy_device_create中会有对state_queue的初始化

{

...

INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);

...

}

void phy_start_machine(struct phy_device *phydev)

{

queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ);

}

真正将net_device与phy_device建立起联系的函数是phy_connect_direct

int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,

void (*handler)(struct net_device *),

phy_interface_t interface)

{

int rc;

rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);

if (rc)

return rc;

phy_prepare_link(phydev, handler);

/* phy_start_machine实际上是queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ);

将phydev->state_queue这个工作队列调度到system_power_efficient_wq上等待执行 */

phy_start_machine(phydev);

/* 如果这个phy设备支持中断，就会进行中断的注册 */

if (phydev->irq > 0)

phy_start_interrupts(phydev);

return 0;

}

3. phy中断的注册

函数phy_connect_direct中，如果phy设备支持中断，就会调用

phy_start_interrupts进行中断的注册

cpsw_slave_open->

phy_connect(priv->ndev, slave->data->phy_id,

&cpsw_adjust_link, slave->data->phy_if);

->phy_start_interrupts

/**

* phy_start_interrupts - request and enable interrupts for a PHY device

* @phydev: target phy_device struct

*

* Description: Request the interrupt for the given PHY.

*   If this fails, then we set irq to PHY_POLL.

*   Otherwise, we enable the interrupts in the PHY.

*   This should only be called with a valid IRQ number.

*   Returns 0 on success or < 0 on error.

*/

int phy_start_interrupts(struct phy_device *phydev)

{

atomic_set(&phydev->irq_disable, 0);

if (request_irq(phydev->irq, phy_interrupt, 0, "phy_interrupt",

phydev) < 0) {

pr_warn("%s: Can't get IRQ %d (PHY)\n",

phydev->bus->name, phydev->irq);

phydev->irq = PHY_POLL;

return 0;

}

return phy_enable_interrupts(phydev);/* clean 中断，config中断，

实际上是调用phydev->drv->ack_interrupt

phydev->drv->config_intr  */

}

/**

* phy_enable_interrupts - Enable the interrupts from the PHY side

* @phydev: target phy_device struct

*/

static int phy_enable_interrupts(struct phy_device *phydev)

{

int err = phy_clear_interrupt(phydev); /* phydev->drv->ack_interrupt */

if (err < 0)

return err;

return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); /* phydev->drv->config_intr  */

}

看看中断服务程序干了些什么

phy_interrupt这个isr会把phydev->phy_queue这个工作队列调度到system_power_efficient_wq上

static irqreturn_t phy_interrupt(int irq, void *phy_dat)

{

struct phy_device *phydev = phy_dat;

if (PHY_HALTED == phydev->state)

return IRQ_NONE;        /* It can't be ours.  */

/* The MDIO bus is not allowed to be written in interrupt

* context, so we need to disable the irq here.  A work

* queue will write the PHY to disable and clear the

* interrupt, and then reenable the irq line.

*/

disable_irq_nosync(irq);

atomic_inc(&phydev->irq_disable);

/* 调度phydev->phy_queue。 phy_queue在phy_device_create已经初始化了 */

queue_work(system_power_efficient_wq, &phydev->phy_queue);

return IRQ_HANDLED;

}

在phy_device_create函数里，已经初始化了phy_queue，相应的处理函数是phy_change.

phy_device_create

{...

INIT_WORK(&dev->phy_queue, phy_change);

....

}

看看phy_change干了什么？

/**

* phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes

* @work: work_struct that describes the work to be done

*/

void phy_change(struct work_struct *work)

{

struct phy_device *phydev =

container_of(work, struct phy_device, phy_queue);

if (phydev->drv->did_interrupt &&

!phydev->drv->did_interrupt(phydev))

goto ignore;

if (phy_disable_interrupts(phydev))

goto phy_err;

mutex_lock(&phydev->lock);

if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state))

phydev->state = PHY_CHANGELINK;

mutex_unlock(&phydev->lock);

atomic_dec(&phydev->irq_disable);

enable_irq(phydev->irq);

/* Reenable interrupts */

if (PHY_HALTED != phydev->state &&

phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED))

goto irq_enable_err;

/* reschedule state queue work to run as soon as possible */

cancel_delayed_work_sync(&phydev->state_queue);/* phydev->state_queue本来是一个delayed work_queue,中断来时，将这个delayed的wq取消掉，改成立刻调度 */

queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0);  /* 立刻调度state_queue */

return;

ignore:

atomic_dec(&phydev->irq_disable);

enable_irq(phydev->irq);

return;

irq_enable_err:

disable_irq(phydev->irq);

atomic_inc(&phydev->irq_disable);

phy_err:

phy_error(phydev);

}