*    1     1       0     1     TX
  */
 static void phylink_resolve_flow(struct phylink *pl,
-       struct phylink_link_state *state)
+                                struct phylink_link_state *state)
 {
        int new_pause = 0;
 
 }
 
 struct phylink *phylink_create(struct net_device *ndev, struct device_node *np,
-       phy_interface_t iface, const struct phylink_mac_ops *ops)
+                              phy_interface_t iface,
+                              const struct phylink_mac_ops *ops)
 {
        struct phylink *pl;
        int ret;
        phylink_run_resolve(pl);
 
        netdev_dbg(pl->netdev, "phy link %s %s/%s/%s\n", up ? "up" : "down",
-                  phy_modes(phydev->interface),
+                  phy_modes(phydev->interface),
                   phy_speed_to_str(phydev->speed),
                   phy_duplex_to_str(phydev->duplex));
 }
 }
 
 int phylink_ethtool_ksettings_get(struct phylink *pl,
-       struct ethtool_link_ksettings *kset)
+                                 struct ethtool_link_ksettings *kset)
 {
        struct phylink_link_state link_state;
 
 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get);
 
 int phylink_ethtool_ksettings_set(struct phylink *pl,
-       const struct ethtool_link_ksettings *kset)
+                                 const struct ethtool_link_ksettings *kset)
 {
        struct ethtool_link_ksettings our_kset;
        struct phylink_link_state config;
 }
 EXPORT_SYMBOL_GPL(phylink_mii_ioctl);
 
-
-
 static int phylink_sfp_module_insert(void *upstream,
                                     const struct sfp_eeprom_id *id)
 {
 
        bool started;
 };
 
-
 int sfp_parse_port(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
                   unsigned long *support)
 {
 }
 EXPORT_SYMBOL_GPL(sfp_parse_support);
 
-
 static LIST_HEAD(sfp_buses);
 static DEFINE_MUTEX(sfp_mutex);
 
        bus->registered = false;
 }
 
-
 int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo)
 {
        if (!bus->registered)
 EXPORT_SYMBOL_GPL(sfp_get_module_info);
 
 int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee,
-       u8 *data)
+                         u8 *data)
 {
        if (!bus->registered)
                return -ENOIOCTLCMD;
 EXPORT_SYMBOL_GPL(sfp_upstream_stop);
 
 struct sfp_bus *sfp_register_upstream(struct device_node *np,
-       struct net_device *ndev, void *upstream,
-       const struct sfp_upstream_ops *ops)
+                                     struct net_device *ndev, void *upstream,
+                                     const struct sfp_upstream_ops *ops)
 {
        struct sfp_bus *bus = sfp_bus_get(np);
        int ret = 0;
 }
 EXPORT_SYMBOL_GPL(sfp_unregister_upstream);
 
-
 /* Socket driver entry points */
 int sfp_add_phy(struct sfp_bus *bus, struct phy_device *phydev)
 {
 }
 EXPORT_SYMBOL_GPL(sfp_remove_phy);
 
-
 void sfp_link_up(struct sfp_bus *bus)
 {
        const struct sfp_upstream_ops *ops = sfp_get_upstream_ops(bus);
 
 #define T_PROBE_INIT   msecs_to_jiffies(300)
 #define T_PROBE_RETRY  msecs_to_jiffies(100)
 
-/*
- * SFP modules appear to always have their PHY configured for bus address
+/* SFP modules appear to always have their PHY configured for bus address
  * 0x56 (which with mdio-i2c, translates to a PHY address of 22).
  */
 #define SFP_PHY_ADDR   22
 
-/*
- * Give this long for the PHY to reset.
- */
+/* Give this long for the PHY to reset. */
 #define T_PHY_RESET_MS 50
 
 static DEFINE_MUTEX(sfp_mutex);
                /* If the module is present, drive the signals */
                if (sfp->gpio[GPIO_TX_DISABLE])
                        gpiod_direction_output(sfp->gpio[GPIO_TX_DISABLE],
-                                               state & SFP_F_TX_DISABLE);
+                                              state & SFP_F_TX_DISABLE);
                if (state & SFP_F_RATE_SELECT)
                        gpiod_direction_output(sfp->gpio[GPIO_RATE_SELECT],
-                                               state & SFP_F_RATE_SELECT);
+                                              state & SFP_F_RATE_SELECT);
        } else {
                /* Otherwise, let them float to the pull-ups */
                if (sfp->gpio[GPIO_TX_DISABLE])
 }
 
 static int sfp__i2c_read(struct i2c_adapter *i2c, u8 bus_addr, u8 dev_addr,
-       void *buf, size_t len)
+                        void *buf, size_t len)
 {
        struct i2c_msg msgs[2];
        int ret;
 }
 
 static int sfp_i2c_read(struct sfp *sfp, bool a2, u8 addr, void *buf,
-       size_t len)
+                       size_t len)
 {
        return sfp__i2c_read(sfp->i2c, a2 ? 0x51 : 0x50, addr, buf, len);
 }
        return 0;
 }
 
-
 /* Interface */
 static unsigned int sfp_get_state(struct sfp *sfp)
 {
        sfp_sm_set_timer(sfp, timeout);
 }
 
-static void sfp_sm_ins_next(struct sfp *sfp, unsigned int state, unsigned int timeout)
+static void sfp_sm_ins_next(struct sfp *sfp, unsigned int state,
+                           unsigned int timeout)
 {
        sfp->sm_mod_state = state;
        sfp_sm_set_timer(sfp, timeout);
 static void sfp_sm_fault(struct sfp *sfp, bool warn)
 {
        if (sfp->sm_retries && !--sfp->sm_retries) {
-               dev_err(sfp->dev, "module persistently indicates fault, disabling\n");
+               dev_err(sfp->dev,
+                       "module persistently indicates fault, disabling\n");
                sfp_sm_next(sfp, SFP_S_TX_DISABLE, 0);
        } else {
                if (warn)
        memcpy(date, sfp->id.ext.datecode, 8);
        date[8] = '\0';
 
-       dev_info(sfp->dev, "module %s %s rev %s sn %s dc %s\n", vendor, part, rev, sn, date);
+       dev_info(sfp->dev, "module %s %s rev %s sn %s dc %s\n",
+                vendor, part, rev, sn, date);
 
        /* We only support SFP modules, not the legacy GBIC modules. */
        if (sfp->id.base.phys_id != SFP_PHYS_ID_SFP ||
 }
 
 static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee,
-       u8 *data)
+                            u8 *data)
 {
        unsigned int first, last, len;
        int ret;