[POWERPC] QE: clean up ucc_slow.c and ucc_fast.c

Refactored and cleaned up ucc_fast.c and ucc_slow.c so that the two files
look more alike and are easier to read.  Removed uccf_printk() and related
functions, because they were just front-ends to printk().  Fixed some
spacing and tabbing issues.  Minor optimizations of some code.  Changed
the type of some variables to their proper type (mostly buffer
descriptors).

Signed-off-by: Timur Tabi <timur@freescale.com>
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>

1 files changed, 61 insertions, 102 deletions

diff --git a/arch/powerpc/sysdev/qe_lib/ucc_fast.c b/arch/powerpc/sysdev/qe_lib/ucc_fast.c
index e657559bea93..a457ac1c6639 100644
--- a/arch/powerpc/sysdev/qe_lib/ucc_fast.c
+++ b/arch/powerpc/sysdev/qe_lib/ucc_fast.c
@@ -1,13 +1,12 @@
 /*
- * arch/powerpc/sysdev/qe_lib/ucc_fast.c
- *
- * QE UCC Fast API Set - UCC Fast specific routines implementations.
- *
  * Copyright (C) 2006 Freescale Semicondutor, Inc. All rights reserved.
  *
  * Authors:     Shlomi Gridish <gridish@freescale.com>
  *              Li Yang <leoli@freescale.com>
  *
+ * Description:
+ * QE UCC Fast API Set - UCC Fast specific routines implementations.
+ *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
  * Free Software Foundation;  either version 2 of the  License, or (at your
@@ -27,79 +26,61 @@
 #include <asm/ucc.h>
 #include <asm/ucc_fast.h>
 
-#define uccf_printk(level, format, arg...) \
-        printk(level format "\n", ## arg)
-
-#define uccf_dbg(format, arg...) \
-        uccf_printk(KERN_DEBUG , format , ## arg)
-#define uccf_err(format, arg...) \
-        uccf_printk(KERN_ERR , format , ## arg)
-#define uccf_info(format, arg...) \
-        uccf_printk(KERN_INFO , format , ## arg)
-#define uccf_warn(format, arg...) \
-        uccf_printk(KERN_WARNING , format , ## arg)
-
-#ifdef UCCF_VERBOSE_DEBUG
-#define uccf_vdbg uccf_dbg
-#else
-#define uccf_vdbg(fmt, args...) do { } while (0)
-#endif                          /* UCCF_VERBOSE_DEBUG */
-
 void ucc_fast_dump_regs(struct ucc_fast_private * uccf)
 {
-        uccf_info("UCC%d Fast registers:", uccf->uf_info->ucc_num);
-        uccf_info("Base address: 0x%08x", (u32) uccf->uf_regs);
+        printk(KERN_INFO "UCC%d Fast registers:", uccf->uf_info->ucc_num);
+        printk(KERN_INFO "Base address: 0x%08x", (u32) uccf->uf_regs);
 
-        uccf_info("gumr  : addr - 0x%08x, val - 0x%08x",
+        printk(KERN_INFO "gumr  : addr - 0x%08x, val - 0x%08x",
                   (u32) & uccf->uf_regs->gumr, in_be32(&uccf->uf_regs->gumr));
-        uccf_info("upsmr : addr - 0x%08x, val - 0x%08x",
+        printk(KERN_INFO "upsmr : addr - 0x%08x, val - 0x%08x",
                   (u32) & uccf->uf_regs->upsmr, in_be32(&uccf->uf_regs->upsmr));
-        uccf_info("utodr : addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "utodr : addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->utodr, in_be16(&uccf->uf_regs->utodr));
-        uccf_info("udsr  : addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "udsr  : addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->udsr, in_be16(&uccf->uf_regs->udsr));
-        uccf_info("ucce  : addr - 0x%08x, val - 0x%08x",
+        printk(KERN_INFO "ucce  : addr - 0x%08x, val - 0x%08x",
                   (u32) & uccf->uf_regs->ucce, in_be32(&uccf->uf_regs->ucce));
-        uccf_info("uccm  : addr - 0x%08x, val - 0x%08x",
+        printk(KERN_INFO "uccm  : addr - 0x%08x, val - 0x%08x",
                   (u32) & uccf->uf_regs->uccm, in_be32(&uccf->uf_regs->uccm));
-        uccf_info("uccs  : addr - 0x%08x, val - 0x%02x",
+        printk(KERN_INFO "uccs  : addr - 0x%08x, val - 0x%02x",
                   (u32) & uccf->uf_regs->uccs, uccf->uf_regs->uccs);
-        uccf_info("urfb  : addr - 0x%08x, val - 0x%08x",
+        printk(KERN_INFO "urfb  : addr - 0x%08x, val - 0x%08x",
                   (u32) & uccf->uf_regs->urfb, in_be32(&uccf->uf_regs->urfb));
-        uccf_info("urfs  : addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "urfs  : addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->urfs, in_be16(&uccf->uf_regs->urfs));
-        uccf_info("urfet : addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "urfet : addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->urfet, in_be16(&uccf->uf_regs->urfet));
-        uccf_info("urfset: addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "urfset: addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->urfset,
                   in_be16(&uccf->uf_regs->urfset));
-        uccf_info("utfb  : addr - 0x%08x, val - 0x%08x",
+        printk(KERN_INFO "utfb  : addr - 0x%08x, val - 0x%08x",
                   (u32) & uccf->uf_regs->utfb, in_be32(&uccf->uf_regs->utfb));
-        uccf_info("utfs  : addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "utfs  : addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->utfs, in_be16(&uccf->uf_regs->utfs));
-        uccf_info("utfet : addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "utfet : addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->utfet, in_be16(&uccf->uf_regs->utfet));
-        uccf_info("utftt : addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "utftt : addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->utftt, in_be16(&uccf->uf_regs->utftt));
-        uccf_info("utpt  : addr - 0x%08x, val - 0x%04x",
+        printk(KERN_INFO "utpt  : addr - 0x%08x, val - 0x%04x",
                   (u32) & uccf->uf_regs->utpt, in_be16(&uccf->uf_regs->utpt));
-        uccf_info("urtry : addr - 0x%08x, val - 0x%08x",
+        printk(KERN_INFO "urtry : addr - 0x%08x, val - 0x%08x",
                   (u32) & uccf->uf_regs->urtry, in_be32(&uccf->uf_regs->urtry));
-        uccf_info("guemr : addr - 0x%08x, val - 0x%02x",
+        printk(KERN_INFO "guemr : addr - 0x%08x, val - 0x%02x",
                   (u32) & uccf->uf_regs->guemr, uccf->uf_regs->guemr);
 }
 
 u32 ucc_fast_get_qe_cr_subblock(int uccf_num)
 {
         switch (uccf_num) {
-        case 0: return QE_CR_SUBBLOCK_UCCFAST1;
+        case 0: return QE_CR_SUBBLOCK_UCCFAST1;
         case 1: return QE_CR_SUBBLOCK_UCCFAST2;
         case 2: return QE_CR_SUBBLOCK_UCCFAST3;
         case 3: return QE_CR_SUBBLOCK_UCCFAST4;
         case 4: return QE_CR_SUBBLOCK_UCCFAST5;
         case 5: return QE_CR_SUBBLOCK_UCCFAST6;
         case 6: return QE_CR_SUBBLOCK_UCCFAST7;
-        case 7: return QE_CR_SUBBLOCK_UCCFAST8;
+        case 7: return QE_CR_SUBBLOCK_UCCFAST8;
         default: return QE_CR_SUBBLOCK_INVALID;
         }
 }
@@ -153,84 +134,72 @@ int ucc_fast_init(struct ucc_fast_info * uf_info, struct ucc_fast_private ** ucc
 {
         struct ucc_fast_private *uccf;
         struct ucc_fast *uf_regs;
-        u32 gumr = 0;
+        u32 gumr;
         int ret;
 
-        uccf_vdbg("%s: IN", __FUNCTION__);
-
         if (!uf_info)
                 return -EINVAL;
 
         /* check if the UCC port number is in range. */
         if ((uf_info->ucc_num < 0) || (uf_info->ucc_num > UCC_MAX_NUM - 1)) {
-                uccf_err("ucc_fast_init: Illegal UCC number!");
+                printk(KERN_ERR "%s: illegal UCC number", __FUNCTION__);
                 return -EINVAL;
         }
 
         /* Check that 'max_rx_buf_length' is properly aligned (4). */
         if (uf_info->max_rx_buf_length & (UCC_FAST_MRBLR_ALIGNMENT - 1)) {
-                uccf_err("ucc_fast_init: max_rx_buf_length not aligned.");
+                printk(KERN_ERR "%s: max_rx_buf_length not aligned", __FUNCTION__);
                 return -EINVAL;
         }
 
         /* Validate Virtual Fifo register values */
         if (uf_info->urfs < UCC_FAST_URFS_MIN_VAL) {
-                uccf_err
-                    ("ucc_fast_init: Virtual Fifo register urfs too small.");
+                printk(KERN_ERR "%s: urfs is too small", __FUNCTION__);
                 return -EINVAL;
         }
 
         if (uf_info->urfs & (UCC_FAST_VIRT_FIFO_REGS_ALIGNMENT - 1)) {
-                uccf_err
-                    ("ucc_fast_init: Virtual Fifo register urfs not aligned.");
+                printk(KERN_ERR "%s: urfs is not aligned", __FUNCTION__);
                 return -EINVAL;
         }
 
         if (uf_info->urfet & (UCC_FAST_VIRT_FIFO_REGS_ALIGNMENT - 1)) {
-                uccf_err
-                    ("ucc_fast_init: Virtual Fifo register urfet not aligned.");
+                printk(KERN_ERR "%s: urfet is not aligned.", __FUNCTION__);
                 return -EINVAL;
         }
 
         if (uf_info->urfset & (UCC_FAST_VIRT_FIFO_REGS_ALIGNMENT - 1)) {
-                uccf_err
-                   ("ucc_fast_init: Virtual Fifo register urfset not aligned.");
+                printk(KERN_ERR "%s: urfset is not aligned", __FUNCTION__);
                 return -EINVAL;
         }
 
         if (uf_info->utfs & (UCC_FAST_VIRT_FIFO_REGS_ALIGNMENT - 1)) {
-                uccf_err
-                    ("ucc_fast_init: Virtual Fifo register utfs not aligned.");
+                printk(KERN_ERR "%s: utfs is not aligned", __FUNCTION__);
                 return -EINVAL;
         }
 
         if (uf_info->utfet & (UCC_FAST_VIRT_FIFO_REGS_ALIGNMENT - 1)) {
-                uccf_err
-                    ("ucc_fast_init: Virtual Fifo register utfet not aligned.");
+                printk(KERN_ERR "%s: utfet is not aligned", __FUNCTION__);
                 return -EINVAL;
         }
 
         if (uf_info->utftt & (UCC_FAST_VIRT_FIFO_REGS_ALIGNMENT - 1)) {
-                uccf_err
-                    ("ucc_fast_init: Virtual Fifo register utftt not aligned.");
+                printk(KERN_ERR "%s: utftt is not aligned", __FUNCTION__);
                 return -EINVAL;
         }
 
         uccf = kzalloc(sizeof(struct ucc_fast_private), GFP_KERNEL);
         if (!uccf) {
-                uccf_err
-                    ("ucc_fast_init: No memory for UCC slow data structure!");
+                printk(KERN_ERR "%s: Cannot allocate private data", __FUNCTION__);
                 return -ENOMEM;
         }
 
         /* Fill fast UCC structure */
         uccf->uf_info = uf_info;
         /* Set the PHY base address */
-        uccf->uf_regs =
-            (struct ucc_fast *) ioremap(uf_info->regs, sizeof(struct ucc_fast));
+        uccf->uf_regs = ioremap(uf_info->regs, sizeof(struct ucc_fast));
         if (uccf->uf_regs == NULL) {
-                uccf_err
-                    ("ucc_fast_init: No memory map for UCC slow controller!");
+                printk(KERN_ERR "%s: Cannot map UCC registers", __FUNCTION__);
                 return -ENOMEM;
         }
 
@@ -249,7 +218,7 @@ int ucc_fast_init(struct ucc_fast_info * uf_info, struct ucc_fast_private ** ucc
 
         /* Init Guemr register */
         if ((ret = ucc_init_guemr((struct ucc_common *) (uf_regs)))) {
-                uccf_err("ucc_fast_init: Could not init the guemr register.");
+                printk(KERN_ERR "%s: cannot init GUEMR", __FUNCTION__);
                 ucc_fast_free(uccf);
                 return ret;
         }
@@ -258,7 +227,7 @@ int ucc_fast_init(struct ucc_fast_info * uf_info, struct ucc_fast_private ** ucc
         if ((ret = ucc_set_type(uf_info->ucc_num,
                                 (struct ucc_common *) (uf_regs),
                                 UCC_SPEED_TYPE_FAST))) {
-                uccf_err("ucc_fast_init: Could not set type to fast.");
+                printk(KERN_ERR "%s: cannot set UCC type", __FUNCTION__);
                 ucc_fast_free(uccf);
                 return ret;
         }
@@ -267,10 +236,9 @@ int ucc_fast_init(struct ucc_fast_info * uf_info, struct ucc_fast_private ** ucc
 
         /* Set GUMR */
         /* For more details see the hardware spec. */
-        /* gumr starts as zero. */
+        gumr = uf_info->ttx_trx;
         if (uf_info->tci)
                 gumr |= UCC_FAST_GUMR_TCI;
-        gumr |= uf_info->ttx_trx;
         if (uf_info->cdp)
                 gumr |= UCC_FAST_GUMR_CDP;
         if (uf_info->ctsp)
@@ -298,9 +266,7 @@ int ucc_fast_init(struct ucc_fast_info * uf_info, struct ucc_fast_private ** ucc
         uccf->ucc_fast_tx_virtual_fifo_base_offset =
             qe_muram_alloc(uf_info->utfs, UCC_FAST_VIRT_FIFO_REGS_ALIGNMENT);
         if (IS_MURAM_ERR(uccf->ucc_fast_tx_virtual_fifo_base_offset)) {
-                uccf_err
-                    ("ucc_fast_init: Can not allocate MURAM memory for "
-                        "struct ucc_fastx_virtual_fifo_base_offset.");
+                printk(KERN_ERR "%s: cannot allocate MURAM for TX FIFO", __FUNCTION__);
                 uccf->ucc_fast_tx_virtual_fifo_base_offset = 0;
                 ucc_fast_free(uccf);
                 return -ENOMEM;
@@ -308,14 +274,11 @@ int ucc_fast_init(struct ucc_fast_info * uf_info, struct ucc_fast_private ** ucc
 
         /* Allocate memory for Rx Virtual Fifo */
         uccf->ucc_fast_rx_virtual_fifo_base_offset =
-            qe_muram_alloc(uf_info->urfs +
-                           (u32)
+                qe_muram_alloc(uf_info->urfs +
                            UCC_FAST_RECEIVE_VIRTUAL_FIFO_SIZE_FUDGE_FACTOR,
                            UCC_FAST_VIRT_FIFO_REGS_ALIGNMENT);
         if (IS_MURAM_ERR(uccf->ucc_fast_rx_virtual_fifo_base_offset)) {
-                uccf_err
-                    ("ucc_fast_init: Can not allocate MURAM memory for "
-                        "ucc_fast_rx_virtual_fifo_base_offset.");
+                printk(KERN_ERR "%s: cannot allocate MURAM for RX FIFO", __FUNCTION__);
                 uccf->ucc_fast_rx_virtual_fifo_base_offset = 0;
                 ucc_fast_free(uccf);
                 return -ENOMEM;
@@ -342,26 +305,22 @@ int ucc_fast_init(struct ucc_fast_info * uf_info, struct ucc_fast_private ** ucc
         /* If NMSI (not Tsa), set Tx and Rx clock. */
         if (!uf_info->tsa) {
                 /* Rx clock routing */
-                if (uf_info->rx_clock != QE_CLK_NONE) {
-                        if (ucc_set_qe_mux_rxtx
-                            (uf_info->ucc_num, uf_info->rx_clock,
-                             COMM_DIR_RX)) {
-                                uccf_err
-                ("ucc_fast_init: Illegal value for parameter 'RxClock'.");
-                                ucc_fast_free(uccf);
-                                return -EINVAL;
-                        }
+                if ((uf_info->rx_clock != QE_CLK_NONE) &&
+                    ucc_set_qe_mux_rxtx(uf_info->ucc_num, uf_info->rx_clock,
+                                        COMM_DIR_RX)) {
+                        printk(KERN_ERR "%s: illegal value for RX clock",
+                               __FUNCTION__);
+                        ucc_fast_free(uccf);
+                        return -EINVAL;
                 }
                 /* Tx clock routing */
-                if (uf_info->tx_clock != QE_CLK_NONE) {
-                        if (ucc_set_qe_mux_rxtx
-                            (uf_info->ucc_num, uf_info->tx_clock,
-                             COMM_DIR_TX)) {
-                                uccf_err
-                ("ucc_fast_init: Illegal value for parameter 'TxClock'.");
-                                ucc_fast_free(uccf);
-                                return -EINVAL;
-                        }
+                if ((uf_info->tx_clock != QE_CLK_NONE) &&
+                    ucc_set_qe_mux_rxtx(uf_info->ucc_num, uf_info->tx_clock,
+                                        COMM_DIR_TX)) {
+                        printk(KERN_ERR "%s: illegal value for TX clock",
+                               __FUNCTION__);
+                        ucc_fast_free(uccf);
+                        return -EINVAL;
                 }
         }
 
@@ -370,9 +329,9 @@ int ucc_fast_init(struct ucc_fast_info * uf_info, struct ucc_fast_private ** ucc
 
         /* First, clear anything pending at UCC level,
          * otherwise, old garbage may come through
-         * as soon as the dam is opened
-         * Writing '1' clears
-         */
+         * as soon as the dam is opened. */
+
+        /* Writing '1' clears */
         out_be32(&uf_regs->ucce, 0xffffffff);
 
         *uccf_ret = uccf;