#ifndef LINUX_BCM47XX_PRIVATE_H_
 #define LINUX_BCM47XX_PRIVATE_H_
 
+#ifndef pr_fmt
+#define pr_fmt(fmt)            "bcm47xx: " fmt
+#endif
+
 #include <linux/kernel.h>
 
 /* prom.c */
 
        err = bcm47xx_nvram_getenv("boardtype", buf, sizeof(buf));
 
        /* init of nvram failed, probably too early now */
-       if (err == -ENXIO) {
+       if (err == -ENXIO)
                return;
-       }
 
        board_detected = bcm47xx_board_get_nvram();
        bcm47xx_board.board = board_detected->board;
 
 #include <linux/mtd/mtd.h>
 #include <linux/bcm47xx_nvram.h>
 
-#define NVRAM_MAGIC            0x48534C46      /* 'FLSH' */
-#define NVRAM_SPACE            0x8000
+#define NVRAM_MAGIC                    0x48534C46      /* 'FLSH' */
+#define NVRAM_SPACE                    0x8000
+#define NVRAM_MAX_GPIO_ENTRIES         32
+#define NVRAM_MAX_GPIO_VALUE_LEN       30
 
 #define FLASH_MIN              0x00020000      /* Minimum flash size */
 
                pr_err("nvram on flash (%i bytes) is bigger than the reserved space in memory, will just copy the first %i bytes\n",
                       header->len, NVRAM_SPACE);
 
-       src = (u32 *) header;
-       dst = (u32 *) nvram_buf;
+       src = (u32 *)header;
+       dst = (u32 *)nvram_buf;
        for (i = 0; i < sizeof(struct nvram_header); i += 4)
                *dst++ = __raw_readl(src++);
        for (; i < header->len && i < NVRAM_SPACE && i < size; i += 4)
        /* Look for name=value and return value */
        var = &nvram_buf[sizeof(struct nvram_header)];
        end = nvram_buf + sizeof(nvram_buf) - 2;
-       end[0] = end[1] = '\0';
+       end[0] = '\0';
+       end[1] = '\0';
        for (; *var; var = value + strlen(value) + 1) {
                data_left = end - var;
 
                if (!eq)
                        break;
                value = eq + 1;
-               if ((eq - var) == strlen(name) &&
-                       strncmp(var, name, (eq - var)) == 0) {
+               if (eq - var == strlen(name) &&
+                   strncmp(var, name, eq - var) == 0)
                        return snprintf(val, val_len, "%s", value);
                }
-       }
        return -ENOENT;
 }
 EXPORT_SYMBOL(bcm47xx_nvram_getenv);
 int bcm47xx_nvram_gpio_pin(const char *name)
 {
        int i, err;
-       char nvram_var[10];
-       char buf[30];
+       char nvram_var[] = "gpioXX";
+       char buf[NVRAM_MAX_GPIO_VALUE_LEN];
 
-       for (i = 0; i < 32; i++) {
+       /* TODO: Optimize it to don't call getenv so many times */
+       for (i = 0; i < NVRAM_MAX_GPIO_ENTRIES; i++) {
                err = snprintf(nvram_var, sizeof(nvram_var), "gpio%i", i);
                if (err <= 0)
                        continue;
 
 #include <bcm47xx.h>
 #include <bcm47xx_board.h>
 
-
 static char bcm47xx_system_type[20] = "Broadcom BCM47XX";
 
 const char *get_system_type(void)
                /* Loop condition may be not enough, off may be over 1 MiB */
                if (off + mem >= max) {
                        mem = max;
-                       printk(KERN_DEBUG "assume 128MB RAM\n");
+                       pr_debug("Assume 128MB RAM\n");
                        break;
                }
                if (!memcmp(prom_init, prom_init + mem, 32))
 
                struct plat_serial8250_port *p = &(uart8250_data[i]);
                struct ssb_serial_port *ssb_port = &(mcore->serial_ports[i]);
 
-               p->mapbase = (unsigned int) ssb_port->regs;
-               p->membase = (void *) ssb_port->regs;
+               p->mapbase = (unsigned int)ssb_port->regs;
+               p->membase = (void *)ssb_port->regs;
                p->irq = ssb_port->irq + 2;
                p->uartclk = ssb_port->baud_base;
                p->regshift = ssb_port->reg_shift;
                struct bcma_serial_port *bcma_port;
                bcma_port = &(cc->serial_ports[i]);
 
-               p->mapbase = (unsigned int) bcma_port->regs;
-               p->membase = (void *) bcma_port->regs;
+               p->mapbase = (unsigned int)bcma_port->regs;
+               p->membase = (void *)bcma_port->regs;
                p->irq = bcma_port->irq;
                p->uartclk = bcma_port->baud_base;
                p->regshift = bcma_port->reg_shift;
 
 
 static void bcm47xx_machine_restart(char *command)
 {
-       printk(KERN_ALERT "Please stand by while rebooting the system...\n");
+       pr_alert("Please stand by while rebooting the system...\n");
        local_irq_disable();
        /* Set the watchdog timer to reset immediately */
        switch (bcm47xx_bus_type) {
        char buf[20];
 
        /* Fill boardinfo structure */
-       memset(&(iv->boardinfo), 0 , sizeof(struct ssb_boardinfo));
+       memset(&iv->boardinfo, 0 , sizeof(struct ssb_boardinfo));
 
        bcm47xx_fill_ssb_boardinfo(&iv->boardinfo, NULL);
 
        char buf[100];
        struct ssb_mipscore *mcore;
 
-       err = ssb_bus_ssbbus_register(&(bcm47xx_bus.ssb), SSB_ENUM_BASE,
+       err = ssb_bus_ssbbus_register(&bcm47xx_bus.ssb, SSB_ENUM_BASE,
                                      bcm47xx_get_invariants);
        if (err)
                panic("Failed to initialize SSB bus (err %d)", err);
                if (strstr(buf, "console=ttyS1")) {
                        struct ssb_serial_port port;
 
-                       printk(KERN_DEBUG "Swapping serial ports!\n");
+                       pr_debug("Swapping serial ports!\n");
                        /* swap serial ports */
                        memcpy(&port, &mcore->serial_ports[0], sizeof(port));
                        memcpy(&mcore->serial_ports[0], &mcore->serial_ports[1],
        struct cpuinfo_mips *c = ¤t_cpu_data;
 
        if ((c->cputype == CPU_74K) || (c->cputype == CPU_1074K)) {
-               printk(KERN_INFO "bcm47xx: using bcma bus\n");
+               pr_info("Using bcma bus\n");
 #ifdef CONFIG_BCM47XX_BCMA
                bcm47xx_bus_type = BCM47XX_BUS_TYPE_BCMA;
                bcm47xx_sprom_register_fallbacks();
 #endif
 #endif
        } else {
-               printk(KERN_INFO "bcm47xx: using ssb bus\n");
+               pr_info("Using ssb bus\n");
 #ifdef CONFIG_BCM47XX_SSB
                bcm47xx_bus_type = BCM47XX_BUS_TYPE_SSB;
                bcm47xx_sprom_register_fallbacks();
 
                bcm47xx_fill_sprom_path_r4589(sprom, prefix, fallback);
                break;
        default:
-               pr_warn("Unsupported SPROM revision %d detected. Will extract"
-                       " v1\n", sprom->revision);
+               pr_warn("Unsupported SPROM revision %d detected. Will extract v1\n",
+                       sprom->revision);
                sprom->revision = 1;
                bcm47xx_fill_sprom_r1234589(sprom, prefix, fallback);
                bcm47xx_fill_sprom_r12389(sprom, prefix, fallback);
                bcm47xx_fill_sprom(out, prefix, false);
                return 0;
        } else {
-               pr_warn("bcm47xx: unable to fill SPROM for given bustype.\n");
+               pr_warn("Unable to fill SPROM for given bustype.\n");
                return -EINVAL;
        }
 }
                }
                return 0;
        default:
-               pr_warn("bcm47xx: unable to fill SPROM for given bustype.\n");
+               pr_warn("Unable to fill SPROM for given bustype.\n");
                return -EINVAL;
        }
 }
 
  *  675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-
 #include <linux/init.h>
 #include <linux/ssb/ssb.h>
 #include <asm/time.h>