ddrdma_cmd.va = pci_alloc_consistent(adapter->pdev, ddrdma_cmd.size,
                                        &ddrdma_cmd.dma);
        if (!ddrdma_cmd.va) {
-               dev_err(&adapter->pdev->dev, "Memory allocation failure \n");
+               dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
                return -ENOMEM;
        }
 
 
                        PCICFG_PM_CONTROL_OFFSET, PCICFG_PM_CONTROL_MASK);
                if (status) {
                        dev_err(&adapter->pdev->dev,
-                               "Could not enable Wake-on-lan \n");
+                               "Could not enable Wake-on-lan\n");
                        pci_free_consistent(adapter->pdev, cmd.size, cmd.va,
                                        cmd.dma);
                        return status;
 
                                MDIO_AN_REG_ADV_PAUSE_MASK) >> 8;
                pause_result |= (lp_pause &
                                 MDIO_AN_REG_ADV_PAUSE_MASK) >> 10;
-               DP(NETIF_MSG_LINK, "Ext PHY pause result 0x%x \n",
+               DP(NETIF_MSG_LINK, "Ext PHY pause result 0x%x\n",
                   pause_result);
                bnx2x_pause_resolve(vars, pause_result);
                if (vars->flow_ctrl == BNX2X_FLOW_CTRL_NONE &&
                                MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 7;
 
                        bnx2x_pause_resolve(vars, pause_result);
-                       DP(NETIF_MSG_LINK, "Ext PHY CL37 pause result 0x%x \n",
+                       DP(NETIF_MSG_LINK, "Ext PHY CL37 pause result 0x%x\n",
                                 pause_result);
                }
        }
                }
        }
 
-       DP(NETIF_MSG_LINK, "gp_status 0x%x  phy_link_up %x line_speed %x \n",
+       DP(NETIF_MSG_LINK, "gp_status 0x%x  phy_link_up %x line_speed %x\n",
                 gp_status, vars->phy_link_up, vars->line_speed);
        DP(NETIF_MSG_LINK, "duplex %x  flow_ctrl 0x%x"
                 " autoneg 0x%x\n",
                                    SPEED_AUTO_NEG) &&
                                   ((params->speed_cap_mask &
                                     PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))) {
-                               DP(NETIF_MSG_LINK, "Setting 1G clause37 \n");
+                               DP(NETIF_MSG_LINK, "Setting 1G clause37\n");
                                bnx2x_cl45_write(bp, params->port, ext_phy_type,
                                               ext_phy_addr, MDIO_AN_DEVAD,
                                               MDIO_AN_REG_ADV, 0x20);
                                      ext_phy_addr,
                                      MDIO_PMA_DEVAD,
                                      MDIO_PMA_REG_10G_CTRL2, &tmp1);
-                               DP(NETIF_MSG_LINK, "1.7 = 0x%x \n", tmp1);
+                               DP(NETIF_MSG_LINK, "1.7 = 0x%x\n", tmp1);
 
                        } else if ((params->req_line_speed ==
                                    SPEED_AUTO_NEG) &&
                                   ((params->speed_cap_mask &
                                     PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))) {
 
-                               DP(NETIF_MSG_LINK, "Setting 1G clause37 \n");
+                               DP(NETIF_MSG_LINK, "Setting 1G clause37\n");
                                bnx2x_cl45_write(bp, params->port, ext_phy_type,
                                               ext_phy_addr, MDIO_AN_DEVAD,
                                               MDIO_PMA_REG_8727_MISC_CTRL, 0);
 
        }
 
        if (num_grat_arp < 0 || num_grat_arp > 255) {
-               pr_warning("Warning: num_grat_arp (%d) not in range 0-255 so it was reset to 1 \n",
+               pr_warning("Warning: num_grat_arp (%d) not in range 0-255 so it was reset to 1\n",
                           num_grat_arp);
                num_grat_arp = 1;
        }
 
        if (num_unsol_na < 0 || num_unsol_na > 255) {
-               pr_warning("Warning: num_unsol_na (%d) not in range 0-255 so it was reset to 1 \n",
+               pr_warning("Warning: num_unsol_na (%d) not in range 0-255 so it was reset to 1\n",
                           num_unsol_na);
                num_unsol_na = 1;
        }
 
 
        dev_info(&pdev->dev, "Dave DNET at 0x%p (0x%08x) irq %d %pM\n",
               bp->regs, mem_base, dev->irq, dev->dev_addr);
-       dev_info(&pdev->dev, "has %smdio, %sirq, %sgigabit, %sdma \n",
+       dev_info(&pdev->dev, "has %smdio, %sirq, %sgigabit, %sdma\n",
               (bp->capabilities & DNET_HAS_MDIO) ? "" : "no ",
               (bp->capabilities & DNET_HAS_IRQ) ? "" : "no ",
               (bp->capabilities & DNET_HAS_GIGABIT) ? "" : "no ",
 
                return -EINVAL;
        }
        if (!request_region(dev->base_addr, SER12_EXTENT, "baycom_ser_fdx")) {
-               printk(KERN_WARNING "BAYCOM_SER_FSX: I/O port 0x%04lx busy \n", 
+               printk(KERN_WARNING "BAYCOM_SER_FSX: I/O port 0x%04lx busy\n",
                       dev->base_addr);
                return -EACCES;
        }
 
 
        err = mlx4_en_DUMP_ETH_STATS(mdev, priv->port, 0);
        if (err)
-               en_dbg(HW, priv, "Could not update stats \n");
+               en_dbg(HW, priv, "Could not update stats\n");
 
        mutex_lock(&mdev->state_lock);
        if (mdev->device_up) {
 
                                       "%x.\n",
                                       ndev->name, net_rsp->opcode);
                                printk(KERN_ERR PFX
-                                      "0x%08lx 0x%08lx 0x%08lx 0x%08lx \n",
+                                      "0x%08lx 0x%08lx 0x%08lx 0x%08lx\n",
                                       (unsigned long int)tmp[0],
                                       (unsigned long int)tmp[1],
                                       (unsigned long int)tmp[2],
 
 
        for (i = 0; i < count; i += 8) {
                printk(KERN_ERR "%.08x: %.08x %.08x %.08x %.08x %.08x "
-                       "%.08x %.08x %.08x \n", i,
+                       "%.08x %.08x %.08x\n", i,
                        tmp[i + 0],
                        tmp[i + 1],
                        tmp[i + 2],
               ob_mac_tso_iocb->flags2 & OB_MAC_TSO_IOCB_LSO ? "LSO" : "",
               ob_mac_tso_iocb->flags2 & OB_MAC_TSO_IOCB_UC ? "UC" : "",
               ob_mac_tso_iocb->flags2 & OB_MAC_TSO_IOCB_TC ? "TC" : "");
-       printk(KERN_ERR PFX "flags3          = %s %s %s \n",
+       printk(KERN_ERR PFX "flags3          = %s %s %s\n",
               ob_mac_tso_iocb->flags3 & OB_MAC_TSO_IOCB_IC ? "IC" : "",
               ob_mac_tso_iocb->flags3 & OB_MAC_TSO_IOCB_DFP ? "DFP" : "",
               ob_mac_tso_iocb->flags3 & OB_MAC_TSO_IOCB_V ? "V" : "");
 
        }
 
        if(netif_msg_link(sis_priv))
-               printk(KERN_INFO "%s: Media Link On %s %s-duplex \n",
+               printk(KERN_INFO "%s: Media Link On %s %s-duplex\n",
                                        net_dev->name,
                                        *speed == HW_SPEED_100_MBPS ?
                                                "100mbps" : "10mbps",
        int i;
 
        if(netif_msg_tx_err(sis_priv))
-               printk(KERN_INFO "%s: Transmit timeout, status %8.8x %8.8x \n",
+               printk(KERN_INFO "%s: Transmit timeout, status %8.8x %8.8x\n",
                        net_dev->name, inl(ioaddr + cr), inl(ioaddr + isr));
 
        /* Disable interrupts by clearing the interrupt mask. */
 
        /*
         * MIB timer and hardware timer have the same resolution of 80nS
         */
-       DB_RMT("RMT: setting new fddiPATHT_Rmode, t = %d ns \n",
+       DB_RMT("RMT: setting new fddiPATHT_Rmode, t = %d ns\n",
                (int) smc->mib.a[PATH0].fddiPATHT_Rmode,0) ;
        outpd(ADDR(B2_RTM_INI),smc->mib.a[PATH0].fddiPATHT_Rmode) ;
 }
 
 
        mib = phy->mib ;
 
-       DB_PCMN(1,"SIG rec %x %x: \n", bit,phy->r_val[bit] ) ;
+       DB_PCMN(1,"SIG rec %x %x:\n", bit,phy->r_val[bit] ) ;
        bit++ ;
 
        switch(bit) {
                mib->fddiPORTMacIndicated.T_val = phy->t_val[9] ;
                break ;
        }
-       DB_PCMN(1,"SIG snd %x %x: \n", bit,phy->t_val[bit] ) ;
+       DB_PCMN(1,"SIG snd %x %x:\n", bit,phy->t_val[bit] ) ;
 }
 
 /*
 
        smt->smt_len = SMT_MAX_INFO_LEN - pcon.pc_len ;
        mb->sm_len = smt->smt_len + sizeof(struct smt_header) ;
 
-       DB_SMT("SRF: sending SRF at %x, len %d \n",smt,mb->sm_len) ;
+       DB_SMT("SRF: sending SRF at %x, len %d\n",smt,mb->sm_len) ;
        DB_SMT("SRF: state SR%d Threshold %d\n",
                smc->srf.sr_state,smc->srf.SRThreshold/TICKS_PER_SECOND) ;
 #ifdef DEBUG
 
                           t->csum_offs, t->csum_write, t->csum_start);
        }
 
-       seq_printf(seq, "\nRx Ring: \n");
+       seq_printf(seq, "\nRx Ring:\n");
        for (e = skge->rx_ring.to_clean; ; e = e->next) {
                const struct skge_rx_desc *r = e->desc;
 
 
 {
        int i;
 
-       DBG(KERN_DEBUG "DWMAC 100 DMA CSR \n");
+       DBG(KERN_DEBUG "DWMAC 100 DMA CSR\n");
        for (i = 0; i < 9; i++)
                pr_debug("\t CSR%d (offset 0x%x): 0x%08x\n", i,
                       (DMA_BUS_MODE + i * 4),
 
 #ifdef CONFIG_STMMAC_TIMER
        priv->tm = kzalloc(sizeof(struct stmmac_timer *), GFP_KERNEL);
        if (unlikely(priv->tm == NULL)) {
-               pr_err("%s: ERROR: timer memory alloc failed \n", __func__);
+               pr_err("%s: ERROR: timer memory alloc failed\n", __func__);
                return -ENOMEM;
        }
        priv->tm->freq = tmrate;
 
                printk( "TLAN:   Device %s, Unmanaged PHY.\n", dev->name );
        } else if ( phy <= TLAN_PHY_MAX_ADDR ) {
                printk( "TLAN:   Device %s, PHY 0x%02x.\n", dev->name, phy );
-               printk( "TLAN:      Off.  +0     +1     +2     +3 \n" );
+               printk( "TLAN:      Off.  +0     +1     +2     +3\n" );
                 for ( i = 0; i < 0x20; i+= 4 ) {
                        printk( "TLAN:      0x%02x", i );
                        TLan_MiiReadReg( dev, phy, i, &data0 );
 
                        return;
                udelay(10);
        }
-       printk(KERN_ERR "%s function time out \n", __func__);
+       printk(KERN_ERR "%s function time out\n", __func__);
 }
 
 static int mii_speed(struct mii_if_info *mii)
                        return;
                udelay(10);
        }
-       printk(KERN_ERR "%s function time out \n", __func__);
+       printk(KERN_ERR "%s function time out\n", __func__);
 }
 
 static void tsi108_reset_ether(struct tsi108_prv_data * data)
                udelay(10);
        }
        if (i == 0)
-               printk(KERN_ERR "%s function time out \n", __func__);
+               printk(KERN_ERR "%s function time out\n", __func__);
 
        if (data->phy_type == TSI108_PHY_BCM54XX) {
                tsi108_write_mii(data, 0x09, 0x0300);
 
        }
 
        if (netif_msg_probe(&debug))
-               printk(KERN_INFO "ucc_geth: UCC%1d at 0x%8x (irq = %d) \n",
+               printk(KERN_INFO "ucc_geth: UCC%1d at 0x%8x (irq = %d)\n",
                        ug_info->uf_info.ucc_num + 1, ug_info->uf_info.regs,
                        ug_info->uf_info.irq);
 
 
                        ret = pci_enable_sriov(pdev, max_config_dev - 1);
                        if (ret)
                                vxge_debug_ll_config(VXGE_ERR,
-                                       "Failed to enable SRIOV: %d \n", ret);
+                                       "Failed to enable SRIOV: %d\n", ret);
        }
 
        /*
 
        u16 next_bd = card->chan[ch].tx_next_bd;
        u32 scabase = card->hw.scabase;
 
-       printk ("\nnfree_tx_bd = %d \n", card->chan[ch].nfree_tx_bd);
+       printk ("\nnfree_tx_bd = %d\n", card->chan[ch].nfree_tx_bd);
        printk("#CH%d: f_bd = %d(0x%08x), n_bd = %d(0x%08x)\n", ch,
               first_bd, TX_BD_ADDR(ch, first_bd),
               next_bd, TX_BD_ADDR(ch, next_bd));
 
        int res;
 
        if (!tty || !tty->driver_data ) {
-               CPC_TTY_DBG("hdlx-tty: no TTY in close \n");
+               CPC_TTY_DBG("hdlx-tty: no TTY in close\n");
                return;
        }
 
 
                return(-EINVAL);
 
        if (!request_region(map->base_addr, SDLA_IO_EXTENTS, dev->name)){
-               printk(KERN_WARNING "SDLA: io-port 0x%04lx in use \n", dev->base_addr);
+               printk(KERN_WARNING "SDLA: io-port 0x%04lx in use\n", dev->base_addr);
                return(-EINVAL);
        }
        base = map->base_addr;
 
                         pl_type, buf_len);
                tx_msg->num_pls = le16_to_cpu(num_pls+1);
                tx_msg->size += padded_len;
-               d_printf(2, dev, "TX: appended %zu b (up to %u b) pl #%u \n",
+               d_printf(2, dev, "TX: appended %zu b (up to %u b) pl #%u\n",
                        padded_len, tx_msg->size, num_pls+1);
                d_printf(2, dev,
                         "TX: appended hdr @%zu %zu b pl #%u @%zu %zu/%zu b\n",