phy: coding style fixes

/*

 * drivers/net/phy/phy.c

 *

 * Framework for configuring and reading PHY devices

/* Framework for configuring and reading PHY devices

 * Based on code in sungem_phy.c and gianfar_phy.c

 *

 * Author: Andy Fleming

#include <linux/timer.h>

#include <linux/workqueue.h>

#include <linux/mdio.h>

#include <linux/io.h>

#include <linux/uaccess.h>

#include <linux/atomic.h>

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/uaccess.h>

/**

 * phy_print_status - Convenience function to print out the current phy status

 */

void phy_print_status(struct phy_device *phydev)

{

	if (phydev->link)

	if (phydev->link) {

		pr_info("%s - Link is Up - %d/%s\n",

			dev_name(&phydev->dev),

			phydev->speed,

			DUPLEX_FULL == phydev->duplex ? "Full" : "Half");

	else

	} else	{

		pr_info("%s - Link is Down\n", dev_name(&phydev->dev));

	}

}

EXPORT_SYMBOL(phy_print_status);

/**

}

/* A structure for mapping a particular speed and duplex

 * combination to a particular SUPPORTED and ADVERTISED value */

 * combination to a particular SUPPORTED and ADVERTISED value

 */

struct phy_setting {

	int speed;

	int duplex;

	int idx = 0;

	while (idx < ARRAY_SIZE(settings) &&

			(settings[idx].speed != speed ||

			settings[idx].duplex != duplex))

	       (settings[idx].speed != speed || settings[idx].duplex != duplex))

		idx++;

	return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1;

	if (cmd->phy_address != phydev->addr)

		return -EINVAL;

	/* We make sure that we don't pass unsupported

	 * values in to the PHY */

	/* We make sure that we don't pass unsupported values in to the PHY */

	cmd->advertising &= phydev->supported;

	/* Verify the settings we care about. */

 * PHYCONTROL layer.  It changes registers without regard to

 * current state.  Use at own risk.

 */

int phy_mii_ioctl(struct phy_device *phydev,

		struct ifreq *ifr, int cmd)

int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)

{

	struct mii_ioctl_data *mii_data = if_mii(ifr);

	u16 val = mii_data->val_in;

					phydev->autoneg = AUTONEG_DISABLE;

				else

					phydev->autoneg = AUTONEG_ENABLE;

				if ((!phydev->autoneg) && (val & BMCR_FULLDPLX))

				if (!phydev->autoneg && (val & BMCR_FULLDPLX))

					phydev->duplex = DUPLEX_FULL;

				else

					phydev->duplex = DUPLEX_HALF;

				if ((!phydev->autoneg) &&

						(val & BMCR_SPEED1000))

				if (!phydev->autoneg && (val & BMCR_SPEED1000))

					phydev->speed = SPEED_1000;

				else if ((!phydev->autoneg) &&

				else if (!phydev->autoneg &&

					 (val & BMCR_SPEED100))

					phydev->speed = SPEED_100;

				break;

	/* 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. */

	 * interrupt, and then reenable the irq line.

	 */

	disable_irq_nosync(irq);

	atomic_inc(&phydev->irq_disable);

	free_irq(phydev->irq, phydev);

	/*

	 * Cannot call flush_scheduled_work() here as desired because

	/* Cannot call flush_scheduled_work() here as desired because

	 * of rtnl_lock(), but we do not really care about what would

	 * be done, except from enable_irq(), so cancel any work

	 * possibly pending and take care of the matter below.

	 */

	cancel_work_sync(&phydev->phy_queue);

	/*

	 * If work indeed has been cancelled, disable_irq() will have

	/* If work indeed has been cancelled, disable_irq() will have

	 * been left unbalanced from phy_interrupt() and enable_irq()

	 * has to be called so that other devices on the line work.

	 */

out_unlock:

	mutex_unlock(&phydev->lock);

	/*

	 * Cannot call flush_scheduled_work() here as desired because

	/* Cannot call flush_scheduled_work() here as desired because

	 * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change()

	 * will not reenable interrupts.

	 */

}

EXPORT_SYMBOL(phy_stop);

/**

	}

	mutex_unlock(&phydev->lock);

}

EXPORT_SYMBOL(phy_stop);

EXPORT_SYMBOL(phy_start);

/**

		if (err < 0)

			break;

		/* If the link is down, give up on

		 * negotiation for now */

		/* If the link is down, give up on negotiation for now */

		if (!phydev->link) {

			phydev->state = PHY_NOLINK;

			netif_carrier_off(phydev->attached_dev);

			break;

		}

		/* Check if negotiation is done.  Break

		 * if there's an error */

		/* Check if negotiation is done.  Break if there's an error */

		err = phy_aneg_done(phydev);

		if (err < 0)

			break;

		} else if (0 == phydev->link_timeout--) {

			needs_aneg = 1;

			/* If we have the magic_aneg bit,

			 * we try again */

			/* If we have the magic_aneg bit, we try again */

			if (phydev->drv->flags & PHY_HAS_MAGICANEG)

				break;

		}

		if (err)

			break;

		err = phy_config_interrupt(phydev,

				PHY_INTERRUPT_ENABLED);

		err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);

		if (err)

			break;

				break;

			/* err > 0 if AN is done.

			 * Otherwise, it's 0, and we're

			 * still waiting for AN */

			 * Otherwise, it's 0, and we're  still waiting for AN

			 */

			if (err > 0) {

				err = phy_read_status(phydev);

				if (err)

				if (phydev->link) {

					phydev->state = PHY_RUNNING;

					netif_carrier_on(phydev->attached_dev);

				} else

				} else	{

					phydev->state = PHY_NOLINK;

				}

				phydev->adjust_link(phydev->attached_dev);

			} else {

				phydev->state = PHY_AN;

			if (phydev->link) {

				phydev->state = PHY_RUNNING;

				netif_carrier_on(phydev->attached_dev);

			} else

			} else	{

				phydev->state = PHY_NOLINK;

			}

			phydev->adjust_link(phydev->attached_dev);

		}

		break;

{

	return phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_WK_ERR,

				     MDIO_MMD_PCS, phydev->addr);

}

EXPORT_SYMBOL(phy_get_eee_err);

/*

 * drivers/net/phy/phy_device.c

 *

 * Framework for finding and configuring PHYs.

/* Framework for finding and configuring PHYs.

 * Also contains generic PHY driver

 *

 * Author: Andy Fleming

#include <linux/mii.h>

#include <linux/ethtool.h>

#include <linux/phy.h>

#include <linux/io.h>

#include <linux/uaccess.h>

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/uaccess.h>

MODULE_DESCRIPTION("PHY library");

MODULE_AUTHOR("Andy Fleming");

}

static struct phy_driver genphy_driver;

extern int mdio_bus_init(void);

extern void mdio_bus_exit(void);

static LIST_HEAD(phy_fixup_list);

static DEFINE_MUTEX(phy_fixup_lock);

static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,

			     u32 flags, phy_interface_t interface);

/*

 * Creates a new phy_fixup and adds it to the list

/**

 * phy_register_fixup - creates a new phy_fixup and adds it to the list

 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)

 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)

 *	It can also be PHY_ANY_UID

{

	struct phy_fixup *fixup;

	fixup = kzalloc(sizeof(struct phy_fixup), GFP_KERNEL);

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

	if (!fixup)

		return -ENOMEM;

}

EXPORT_SYMBOL(phy_register_fixup_for_id);

/*

 * Returns 1 if fixup matches phydev in bus_id and phy_uid.

/* Returns 1 if fixup matches phydev in bus_id and phy_uid.

 * Fixups can be set to match any in one or more fields.

 */

static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)

EXPORT_SYMBOL(phy_scan_fixups);

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)

				     bool is_c45,

				     struct phy_c45_device_ids *c45_ids)

{

	struct phy_device *dev;

	/* We allocate the device, and initialize the

	 * default values */

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

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

	if (NULL == dev)

	dev->speed = 0;

	dev->duplex = -1;

	dev->pause = dev->asym_pause = 0;

	dev->pause = 0;

	dev->asym_pause = 0;

	dev->link = 1;

	dev->interface = PHY_INTERFACE_MODE_GMII;

	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. */

	 * 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);

	if (is_c45)

		return get_phy_c45_ids(bus, addr, phy_id, c45_ids);

	/* Grab the bits from PHYIR1, and put them

	 * in the upper half */

	/* Grab the bits from PHYIR1, and put them in the upper half */

	phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);

	if (phy_reg < 0)

}

/**

 * get_phy_device - reads the specified PHY device and returns its @phy_device struct

 * get_phy_device - reads the specified PHY device and returns its @phy_device

 *		    struct

 * @bus: the target MII bus

 * @addr: PHY address on the MII bus

 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol

{

	int err;

	/* Don't register a phy if one is already registered at this

	 * address */

	/* Don't register a phy if one is already registered at this address */

	if (phydev->bus->phy_map[phydev->addr])

		return -EINVAL;

	phydev->bus->phy_map[phydev->addr] = phydev;

	int rc;

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

	 * PHY with the requested name */

	 * 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);

EXPORT_SYMBOL(phy_connect);

/**

 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY device

 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY

 *		    device

 * @phydev: target phy_device struct

 */

void phy_disconnect(struct phy_device *phydev)

	if (ret & BMCR_RESET)

		return -ETIMEDOUT;

	/*

	 * Some chips (smsc911x) may still need up to another 1ms after the

	/* Some chips (smsc911x) may still need up to another 1ms after the

	 * BMCR_RESET bit is cleared before they are usable.

	 */

	msleep(1);

	int err;

	/* Assume that if there is no driver, that it doesn't

	 * exist, and we should use the genphy driver. */

	 * exist, and we should use the genphy driver.

	 */

	if (NULL == d->driver) {

		if (phydev->is_c45) {

			pr_err("No driver for phy %x\n", phydev->phy_id);

	/* Do initial configuration here, now that

	 * we have certain key parameters

	 * (dev_flags and interface) */

	 * (dev_flags and interface)

	 */

	err = phy_init_hw(phydev);

	if (err)

		phy_detach(phydev);

 * Description: Same as phy_attach_direct() except that a PHY bus_id

 *     string is passed instead of a pointer to a struct phy_device.

 */

struct phy_device *phy_attach(struct net_device *dev,

		const char *bus_id, phy_interface_t interface)

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

			      phy_interface_t interface)

{

	struct bus_type *bus = &mdio_bus_type;

	struct phy_device *phydev;

	int rc;

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

	 * PHY with the requested name */

	 * PHY with the requested name

	 */

	d = bus_find_device_by_name(bus, NULL, bus_id);

	if (!d) {

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

	/* If the device had no specific driver before (i.e. - it

	 * was using the generic driver), we unbind the device

	 * from the generic driver so that there's a chance a

	 * real driver could be loaded */

	 * real driver could be loaded

	 */

	if (phydev->dev.driver == &genphy_driver.driver)

		device_release_driver(&phydev->dev);

}

	int oldadv, adv;

	int err, changed = 0;

	/* Only allow advertising what

	 * this PHY supports */

	/* Only allow advertising what this PHY supports */

	phydev->advertising &= phydev->supported;

	advertise = phydev->advertising;

	/* Setup standard advertisement */

	oldadv = adv = phy_read(phydev, MII_ADVERTISE);

	adv = phy_read(phydev, MII_ADVERTISE);

	if (adv < 0)

		return adv;

	oldadv = adv;

	adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |

		 ADVERTISE_PAUSE_ASYM);

	adv |= ethtool_adv_to_mii_adv_t(advertise);

	/* Configure gigabit if it's supported */

	if (phydev->supported & (SUPPORTED_1000baseT_Half |

				 SUPPORTED_1000baseT_Full)) {

		oldadv = adv = phy_read(phydev, MII_CTRL1000);

		adv = phy_read(phydev, MII_CTRL1000);

		if (adv < 0)

			return adv;

		oldadv = adv;

		adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);

		adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);

	int err;

	int ctl = 0;

	phydev->pause = phydev->asym_pause = 0;

	phydev->pause = 0;

	phydev->asym_pause = 0;

	if (SPEED_1000 == phydev->speed)

		ctl |= BMCR_SPEED1000;

	if (ctl < 0)

		return ctl;

	ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);

	ctl |= BMCR_ANENABLE | BMCR_ANRESTART;

	/* Don't isolate the PHY if we're negotiating */

	ctl &= ~(BMCR_ISOLATE);

	ctl &= ~BMCR_ISOLATE;

	ctl = phy_write(phydev, MII_BMCR, ctl);

	if (result == 0) {

		/* Advertisement hasn't changed, but maybe aneg was never on to

		 * begin with?  Or maybe phy was isolated? */

		 * begin with?  Or maybe phy was isolated?

		 */

		int ctl = phy_read(phydev, MII_BMCR);

		if (ctl < 0)

	}

	/* Only restart aneg if we are advertising something different

	 * than we were before.	 */

	 * than we were before.

	 */

	if (result > 0)

		result = genphy_restart_aneg(phydev);

	int lpa;

	int lpagb = 0;

	/* Update the link, but return if there

	 * was an error */

	/* Update the link, but return if there was an error */

	err = genphy_update_link(phydev);

	if (err)

		return err;

		phydev->speed = SPEED_10;

		phydev->duplex = DUPLEX_HALF;

		phydev->pause = phydev->asym_pause = 0;

		phydev->pause = 0;

		phydev->asym_pause = 0;

		if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {

			phydev->speed = SPEED_1000;

		}

	} else {

		int bmcr = phy_read(phydev, MII_BMCR);

		if (bmcr < 0)

			return bmcr;

		else

			phydev->speed = SPEED_10;

		phydev->pause = phydev->asym_pause = 0;

		phydev->pause = 0;

		phydev->asym_pause = 0;

	}

	return 0;

	u32 features;

	/* For now, I'll claim that the generic driver supports

	 * all possible port types */

	 * all possible port types

	 */

	features = (SUPPORTED_TP | SUPPORTED_MII

			| SUPPORTED_AUI | SUPPORTED_FIBRE |

			SUPPORTED_BNC);

	mutex_lock(&phydev->lock);

	value = phy_read(phydev, MII_BMCR);

	phy_write(phydev, MII_BMCR, (value | BMCR_PDOWN));

	phy_write(phydev, MII_BMCR, value | BMCR_PDOWN);

	mutex_unlock(&phydev->lock);

	mutex_lock(&phydev->lock);

	value = phy_read(phydev, MII_BMCR);

	phy_write(phydev, MII_BMCR, (value & ~BMCR_PDOWN));

	phy_write(phydev, MII_BMCR, value & ~BMCR_PDOWN);

	mutex_unlock(&phydev->lock);

	/* Start out supporting everything. Eventually,

	 * a controller will attach, and may modify one

	 * or both of these values */

	 * or both of these values

	 */

	phydev->supported = phydrv->features;

	phydev->advertising = phydrv->features;

	mutex_unlock(&phydev->lock);

	return err;

}

static int phy_remove(struct device *dev)

void phy_drivers_unregister(struct phy_driver *drv, int n)

{

	int i;

	for (i = 0; i < n; i++) {

	for (i = 0; i < n; i++)

		phy_driver_unregister(drv + i);

}

}

EXPORT_SYMBOL(phy_drivers_unregister);

static struct phy_driver genphy_driver = {