Use the much more common pr_warn instead of pr_warning.
Other miscellanea:
o Typo fixes submiting/submitting
o Coalesce formats
o Realign arguments
o Add missing terminating '\n' to formats
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
        int ioaddr = dev->base_addr;
 
        /* Transmitter timeout, serious problems. */
-       pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
-                  dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
-                  inw(ioaddr + TX_FREE));
+       pr_warn("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d\n",
+               dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
+               inw(ioaddr + TX_FREE));
        dev->stats.tx_errors++;
        dev->trans_start = jiffies; /* prevent tx timeout */
        /* Issue TX_RESET and TX_START commands. */
 
                        if (pnp_device_attach(idev) < 0)
                                continue;
                        if (pnp_activate_dev(idev) < 0) {
-                               pr_warning("pnp activate failed (out of resources?)\n");
+                               pr_warn("pnp activate failed (out of resources?)\n");
                                pnp_device_detach(idev);
                                continue;
                        }
        pr_cont(", IRQ %d\n", dev->irq);
        /* Tell them about an invalid IRQ. */
        if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
-               pr_warning(" *** Warning: this IRQ is unlikely to work! ***\n");
+               pr_warn(" *** Warning: this IRQ is unlikely to work! ***\n");
 
        {
                static const char * const ram_split[] = {
        struct corkscrew_private *vp = netdev_priv(dev);
        int ioaddr = dev->base_addr;
 
-       pr_warning("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
-              dev->name, inb(ioaddr + TxStatus),
-              inw(ioaddr + EL3_STATUS));
+       pr_warn("%s: transmit timed out, tx_status %2.2x status %4.4x\n",
+               dev->name, inb(ioaddr + TxStatus),
+               inw(ioaddr + EL3_STATUS));
        /* Slight code bloat to be user friendly. */
        if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
-               pr_warning("%s: Transmitter encountered 16 collisions --"
-                      " network cable problem?\n", dev->name);
+               pr_warn("%s: Transmitter encountered 16 collisions -- network cable problem?\n",
+                       dev->name);
 #ifndef final_version
        pr_debug("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
               vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
                                temp = skb_put(skb, pkt_len);
                                /* Remove this checking code for final release. */
                                if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
-                                       pr_warning("%s: Warning -- the skbuff addresses do not match"
-                                            " in boomerang_rx: %p vs. %p / %p.\n",
-                                            dev->name,
-                                            isa_bus_to_virt(vp->
-                                                        rx_ring[entry].
-                                                        addr), skb->head,
-                                            temp);
+                                       pr_warn("%s: Warning -- the skbuff addresses do not match in boomerang_rx: %p vs. %p / %p\n",
+                                               dev->name,
+                                               isa_bus_to_virt(vp->rx_ring[entry].addr),
+                                               skb->head, temp);
                                rx_nocopy++;
                        }
                        skb->protocol = eth_type_trans(skb, dev);
 
                pr_cont(", IRQ %d\n", dev->irq);
        /* Tell them about an invalid IRQ. */
        if (dev->irq <= 0 || dev->irq >= nr_irqs)
-               pr_warning(" *** Warning: IRQ %d is unlikely to work! ***\n",
-                          dev->irq);
+               pr_warn(" *** Warning: IRQ %d is unlikely to work! ***\n",
+                       dev->irq);
 
        step = (window_read8(vp, 4, Wn4_NetDiag) & 0x1e) >> 1;
        if (print_info) {
                }
                mii_preamble_required--;
                if (phy_idx == 0) {
-                       pr_warning("  ***WARNING*** No MII transceivers found!\n");
+                       pr_warn("  ***WARNING*** No MII transceivers found!\n");
                        vp->phys[0] = 24;
                } else {
                        vp->advertising = mdio_read(dev, vp->phys[0], MII_ADVERTISE);
                        pci_restore_state(VORTEX_PCI(vp));
                err = pci_enable_device(VORTEX_PCI(vp));
                if (err) {
-                       pr_warning("%s: Could not enable device\n",
-                               dev->name);
+                       pr_warn("%s: Could not enable device\n", dev->name);
                        goto err_out;
                }
        }
                /* This occurs when we have the wrong media type! */
                if (DoneDidThat == 0  &&
                        ioread16(ioaddr + EL3_STATUS) & StatsFull) {
-                       pr_warning("%s: Updating statistics failed, disabling "
-                                  "stats as an interrupt source.\n", dev->name);
+                       pr_warn("%s: Updating statistics failed, disabling stats as an interrupt source\n",
+                               dev->name);
                        iowrite16(SetIntrEnb |
                                  (window_read16(vp, 5, 10) & ~StatsFull),
                                  ioaddr + EL3_CMD);
 
        if (vp->cur_tx - vp->dirty_tx >= TX_RING_SIZE) {
                if (vortex_debug > 0)
-                       pr_warning("%s: BUG! Tx Ring full, refusing to send buffer.\n",
-                                  dev->name);
+                       pr_warn("%s: BUG! Tx Ring full, refusing to send buffer\n",
+                               dev->name);
                netif_stop_queue(dev);
                return NETDEV_TX_BUSY;
        }
                }
 
                if (--work_done < 0) {
-                       pr_warning("%s: Too much work in interrupt, status %4.4x.\n",
+                       pr_warn("%s: Too much work in interrupt, status %4.4x\n",
                                dev->name, status);
                        /* Disable all pending interrupts. */
                        do {
                        vortex_error(dev, status);
 
                if (--work_done < 0) {
-                       pr_warning("%s: Too much work in interrupt, status %4.4x.\n",
+                       pr_warn("%s: Too much work in interrupt, status %4.4x\n",
                                dev->name, status);
                        /* Disable all pending interrupts. */
                        do {
                        if (skb == NULL) {
                                static unsigned long last_jif;
                                if (time_after(jiffies, last_jif + 10 * HZ)) {
-                                       pr_warning("%s: memory shortage\n", dev->name);
+                                       pr_warn("%s: memory shortage\n",
+                                               dev->name);
                                        last_jif = jiffies;
                                }
                                if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE)
        if (vp->rx_csumhits &&
            (vp->drv_flags & HAS_HWCKSM) == 0 &&
            (vp->card_idx >= MAX_UNITS || hw_checksums[vp->card_idx] == -1)) {
-               pr_warning("%s supports hardware checksums, and we're not using them!\n", dev->name);
+               pr_warn("%s supports hardware checksums, and we're not using them!\n",
+                       dev->name);
        }
 #endif
 
 
        }
        return;
 error:
-       pr_warning("PHY: cannot reset MII transceiver isolate bit\n");
+       pr_warn("PHY: cannot reset MII transceiver isolate bit\n");
 }
 #else
 static inline void b44_wap54g10_workaround(struct b44 *bp)
 
         */
        if ((err == ERR_ECMDUNKNOWN) ||
                (!err && !(vdev->args[0] && vdev->args[1] && vdev->args[2]))) {
-               pr_warning("Using default conversion factor for "
-                       "interrupt coalesce timer\n");
+               pr_warn("Using default conversion factor for interrupt coalesce timer\n");
                vnic_dev_intr_coal_timer_info_default(vdev);
                return 0;
        }
 
 {
        u16 v = 0;
        if (__xm_phy_read(hw, port, reg, &v))
-               pr_warning("%s: phy read timed out\n", hw->dev[port]->name);
+               pr_warn("%s: phy read timed out\n", hw->dev[port]->name);
        return v;
 }
 
                        return 0;
        }
 
-       pr_warning("%s: phy write timeout\n", hw->dev[port]->name);
+       pr_warn("%s: phy write timeout\n", hw->dev[port]->name);
        return -EIO;
 }
 
 {
        u16 v = 0;
        if (__gm_phy_read(hw, port, reg, &v))
-               pr_warning("%s: phy read timeout\n", hw->dev[port]->name);
+               pr_warn("%s: phy read timeout\n", hw->dev[port]->name);
        return v;
 }
 
 
 
                default:
                        if (net_ratelimit())
-                               pr_warning("unknown status opcode 0x%x\n", opcode);
+                               pr_warn("unknown status opcode 0x%x\n", opcode);
                }
        } while (hw->st_idx != idx);
 
 
        /* Note: these should be KERN_DEBUG. */
        if (yellowfin_debug) {
                int i;
-               pr_warning("  Rx ring %p: ", yp->rx_ring);
+               pr_warn("  Rx ring %p: ", yp->rx_ring);
                for (i = 0; i < RX_RING_SIZE; i++)
                        pr_cont(" %08x", yp->rx_ring[i].result_status);
                pr_cont("\n");
-               pr_warning("  Tx ring %p: ", yp->tx_ring);
+               pr_warn("  Tx ring %p: ", yp->tx_ring);
                for (i = 0; i < TX_RING_SIZE; i++)
                        pr_cont(" %04x /%08x",
                               yp->tx_status[i].tx_errs,
 
        u32 val;
 
        if (pdev->revision >= NX_P3_A0 && pdev->revision <= NX_P3_B1) {
-               pr_warning("%s: chip revisions between 0x%x-0x%x "
-                               "will not be enabled.\n",
-                               module_name(THIS_MODULE), NX_P3_A0, NX_P3_B1);
+               pr_warn("%s: chip revisions between 0x%x-0x%x will not be enabled\n",
+                       module_name(THIS_MODULE), NX_P3_A0, NX_P3_B1);
                return -ENODEV;
        }
 
 
        }
 
        if (!found) {
-               pr_warning("%s: No PHY found\n", ndev->name);
+               pr_warn("%s: No PHY found\n", ndev->name);
                mdiobus_unregister(new_bus);
                mdiobus_free(new_bus);
                return -ENODEV;
 
        pci_cmd |= PCI_COMMAND_PARITY;
        pci_write_config_word(pdev, PCI_COMMAND, pci_cmd);
        if (pci_try_set_mwi(pdev))
-               pr_warning("Could not enable MWI for %s\n", pci_name(pdev));
+               pr_warn("Could not enable MWI for %s\n", pci_name(pdev));
 
        cas_program_bridge(pdev);
 
 
                        parent->txchan_per_port[i] = 1;
        }
        if (tot_rx < NIU_NUM_RXCHAN || tot_tx < NIU_NUM_TXCHAN) {
-               pr_warning("niu%d: Driver bug, wasted channels, RX[%d] TX[%d]\n",
-                          parent->index, tot_rx, tot_tx);
+               pr_warn("niu%d: Driver bug, wasted channels, RX[%d] TX[%d]\n",
+                       parent->index, tot_rx, tot_tx);
        }
 }
 
 
        }
 
        if (unlikely(event != LDC_EVENT_DATA_READY)) {
-               pr_warning("Unexpected LDC event %d\n", event);
+               pr_warn("Unexpected LDC event %d\n", event);
                spin_unlock_irqrestore(&vio->lock, flags);
                return;
        }
 
         */
        if (hv_dev_pwrite(priv->hv_devhdl, 0, (HV_VirtAddr)&dummy,
                          sizeof(dummy), NETIO_IPP_START_SHIM_OFF) < 0) {
-               pr_warning("Failed to start LIPP/LEPP.\n");
+               pr_warn("Failed to start LIPP/LEPP\n");
                return -EIO;
        }
 
 {
        int rc = cpulist_parse_crop(str, &network_cpus_map);
        if (rc != 0) {
-               pr_warning("network_cpus=%s: malformed cpu list\n",
-                      str);
+               pr_warn("network_cpus=%s: malformed cpu list\n", str);
        } else {
 
                /* Remove dedicated cpus. */
 
 
                if (cpumask_empty(&network_cpus_map)) {
-                       pr_warning("Ignoring network_cpus='%s'.\n",
-                              str);
+                       pr_warn("Ignoring network_cpus='%s'\n", str);
                } else {
                        char buf[1024];
                        cpulist_scnprintf(buf, sizeof(buf), &network_cpus_map);
 
                card->usb_boot_state = USB8XXX_FW_READY;
                break;
        default:
-               pr_warning("unknown id_product %#x\n", id_product);
+               pr_warn("unknown id_product %#x\n", id_product);
                card->usb_boot_state = USB8XXX_FW_DNLD;
                break;
        }
 
 
        if (ctx->killed) {
                spin_unlock_irqrestore(&upriv->req_lock, flags);
-               pr_warning("interrupt called with dead ctx");
+               pr_warn("interrupt called with dead ctx\n");
                goto out;
        }
 
        default:
                spin_unlock_irqrestore(&upriv->req_lock, flags);
 
-               pr_warning("Matched IN URB, unexpected context state(0x%x)",
-                    state);
+               pr_warn("Matched IN URB, unexpected context state(0x%x)\n",
+                       state);
                /* Throw this CTX away and try submitting another */
                del_timer(&ctx->timer);
                ctx->outurb->transfer_flags |= URB_ASYNC_UNLINK;
                /* When a device gets unplugged we get this every time
                 * we resubmit, flooding the logs.  Since we don't use
                 * USB timeouts, it shouldn't happen any other time*/
-               pr_warning("%s: urb timed out, not resubmiting", __func__);
+               pr_warn("%s: urb timed out, not resubmitting\n", __func__);
                return;
        }
        if (urb->status == -ECONNABORTED) {
-               pr_warning("%s: connection abort, resubmiting urb",
-                    __func__);
+               pr_warn("%s: connection abort, resubmitting urb\n",
+                       __func__);
                goto resubmit;
        }
        if ((urb->status == -EILSEQ)
                if (usb_endpoint_is_bulk_in(ep)) {
                        /* we found a bulk in endpoint */
                        if (upriv->read_urb != NULL) {
-                               pr_warning("Found a second bulk in ep, ignored");
+                               pr_warn("Found a second bulk in ep, ignored\n");
                                continue;
                        }
 
                                goto error;
                        }
                        if (le16_to_cpu(ep->wMaxPacketSize) != 64)
-                               pr_warning("bulk in: wMaxPacketSize!= 64");
+                               pr_warn("bulk in: wMaxPacketSize!= 64\n");
                        if (ep->bEndpointAddress != (2 | USB_DIR_IN))
-                               pr_warning("bulk in: bEndpointAddress: %d",
-                                    ep->bEndpointAddress);
+                               pr_warn("bulk in: bEndpointAddress: %d\n",
+                                       ep->bEndpointAddress);
                        upriv->read_pipe = usb_rcvbulkpipe(udev,
                                                         ep->
                                                         bEndpointAddress);
                if (usb_endpoint_is_bulk_out(ep)) {
                        /* we found a bulk out endpoint */
                        if (upriv->bap_buf != NULL) {
-                               pr_warning("Found a second bulk out ep, ignored");
+                               pr_warn("Found a second bulk out ep, ignored\n");
                                continue;
                        }
 
                        if (le16_to_cpu(ep->wMaxPacketSize) != 64)
-                               pr_warning("bulk out: wMaxPacketSize != 64");
+                               pr_warn("bulk out: wMaxPacketSize != 64\n");
                        if (ep->bEndpointAddress != 2)
-                               pr_warning("bulk out: bEndpointAddress: %d",
-                                    ep->bEndpointAddress);
+                               pr_warn("bulk out: bEndpointAddress: %d\n",
+                                       ep->bEndpointAddress);
                        upriv->write_pipe = usb_sndbulkpipe(udev,
                                                          ep->
                                                          bEndpointAddress);
 
        pr_err(DRIVER_PREFIX "ERROR " fmt "\n", ##arg)
 
 #define wl1271_warning(fmt, arg...) \
-       pr_warning(DRIVER_PREFIX "WARNING " fmt "\n", ##arg)
+       pr_warn(DRIVER_PREFIX "WARNING " fmt "\n", ##arg)
 
 #define wl1271_notice(fmt, arg...) \
        pr_info(DRIVER_PREFIX fmt "\n", ##arg)