if (OCTEON_IS_MODEL(OCTEON_CN68XX)) {
                old_group_mask = cvmx_read_csr(CVMX_SSO_PPX_GRP_MSK(coreid));
                cvmx_write_csr(CVMX_SSO_PPX_GRP_MSK(coreid),
-                               1ull << pow_receive_group);
+                              1ull << pow_receive_group);
                cvmx_read_csr(CVMX_SSO_PPX_GRP_MSK(coreid)); /* Flush */
        } else {
                old_group_mask = cvmx_read_csr(CVMX_POW_PP_GRP_MSKX(coreid));
                cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(coreid),
-                       (old_group_mask & ~0xFFFFull) | 1 << pow_receive_group);
+                              (old_group_mask & ~0xFFFFull) |
+                              1 << pow_receive_group);
        }
 
        if (USE_ASYNC_IOBDMA) {
                         * doesn't exist.
                         */
                        printk_ratelimited("Port %d not controlled by Linux, packet dropped\n",
-                                  port);
+                                          port);
                        dev_kfree_skb_irq(skb);
                }
                /*
 
                                                 number_to_free);
                if (num_freed != number_to_free) {
                        cvmx_fau_atomic_add32(FAU_NUM_PACKET_BUFFERS_TO_FREE,
-                                       number_to_free - num_freed);
+                                             number_to_free - num_freed);
                }
        }
 }
 
                                        priv->fau + qos * 4, MAX_SKB_TO_FREE);
                        }
                        skb_to_free = cvm_oct_adjust_skb_to_free(skb_to_free,
-                                                       priv->fau + qos * 4);
+                                                                priv->fau +
+                                                                qos * 4);
                        spin_lock_irqsave(&priv->tx_free_list[qos].lock, flags);
                        goto skip_xmit;
                }
        }
 
        skb_to_free = cvm_oct_adjust_skb_to_free(skb_to_free,
-                                               priv->fau + qos * 4);
+                                                priv->fau + qos * 4);
 
        /*
         * If we're sending faster than the receive can free them then
 
 }
 
 static struct device_node *cvm_oct_node_for_port(struct device_node *pip,
-                                                       int interface, int port)
+                                                int interface, int port)
 {
        struct device_node *ni, *np;
 
                                free_netdev(dev);
                        } else if (register_netdev(dev) < 0) {
                                pr_err("Failed to register ethernet device for interface %d, port %d\n",
-                                        interface, priv->port);
+                                      interface, priv->port);
                                free_netdev(dev);
                        } else {
                                cvm_oct_device[priv->port] = dev;