#define CPMAC_TX_ACK(channel)          (0x0640 + (channel) * 4)
 #define CPMAC_RX_ACK(channel)          (0x0660 + (channel) * 4)
 #define CPMAC_REG_END                  0x0680
-/*
- * Rx/Tx statistics
+
+/* Rx/Tx statistics
  * TODO: use some of them to fill stats in cpmac_stats()
  */
 #define CPMAC_STATS_RX_GOOD            0x0200
                        cpmac_write(priv->regs, CPMAC_MAC_HASH_LO, 0xffffffff);
                        cpmac_write(priv->regs, CPMAC_MAC_HASH_HI, 0xffffffff);
                } else {
-                       /*
-                        * cpmac uses some strange mac address hashing
+                       /* cpmac uses some strange mac address hashing
                         * (not crc32)
                         */
                        netdev_for_each_mc_addr(ha, dev) {
 
                if ((desc->dataflags & CPMAC_EOQ) != 0) {
                        /* The last update to eoq->hw_next didn't happen
-                       * soon enough, and the receiver stopped here.
-                       *Remember this descriptor so we can restart
-                       * the receiver after freeing some space.
-                       */
+                        * soon enough, and the receiver stopped here.
+                        * Remember this descriptor so we can restart
+                        * the receiver after freeing some space.
+                        */
                        if (unlikely(restart)) {
                                if (netif_msg_rx_err(priv))
                                        printk(KERN_ERR "%s: poll found a"
 
        if (desc != priv->rx_head) {
                /* We freed some buffers, but not the whole ring,
-                * add what we did free to the rx list */
+                * add what we did free to the rx list
+                */
                desc->prev->hw_next = (u32)0;
                priv->rx_head->prev->hw_next = priv->rx_head->mapping;
        }
 
        /* Optimization: If we did not actually process an EOQ (perhaps because
         * of quota limits), check to see if the tail of the queue has EOQ set.
-       * We should immediately restart in that case so that the receiver can
-       * restart and run in parallel with more packet processing.
-       * This lets us handle slightly larger bursts before running
-       * out of ring space (assuming dev->weight < ring_size) */
+        * We should immediately restart in that case so that the receiver can
+        * restart and run in parallel with more packet processing.
+        * This lets us handle slightly larger bursts before running
+        * out of ring space (assuming dev->weight < ring_size)
+        */
 
        if (!restart &&
             (priv->rx_head->prev->dataflags & (CPMAC_OWN|CPMAC_EOQ))
                    == CPMAC_EOQ &&
             (priv->rx_head->dataflags & CPMAC_OWN) != 0) {
                /* reset EOQ so the poll loop (above) doesn't try to
-               * restart this when it eventually gets to this descriptor.
-               */
+                * restart this when it eventually gets to this descriptor.
+                */
                priv->rx_head->prev->dataflags &= ~CPMAC_EOQ;
                restart = priv->rx_head;
        }
                       priv->dev->name, received);
        if (processed == 0) {
                /* we ran out of packets to read,
-                * revert to interrupt-driven mode */
+                * revert to interrupt-driven mode
+                */
                napi_complete(napi);
                cpmac_write(priv->regs, CPMAC_RX_INT_ENABLE, 1);
                return 0;
 
 fatal_error:
        /* Something went horribly wrong.
-        * Reset hardware to try to recover rather than wedging. */
-
+        * Reset hardware to try to recover rather than wedging.
+        */
        if (netif_msg_drv(priv)) {
                printk(KERN_ERR "%s: cpmac_poll is confused. "
                                "Resetting hardware\n", priv->dev->name);
        if (rx_code || tx_code) {
                if (netif_msg_drv(priv) && net_ratelimit()) {
                        /* Can't find any documentation on what these
-                        *error codes actually are. So just log them and hope..
+                        * error codes actually are. So just log them and hope..
                         */
                        if (rx_code)
                                printk(KERN_WARNING "%s: host error %d on rx "