Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

mmc: Convert pr_warning to pr_warn

Use the much more common pr_warn instead of pr_warning.

Other miscellanea:

o Coalesce formats
o Realign arguments
o Remove extra spaces when coalescing formats

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>

authored by

Joe Perches and committed by
Ulf Hansson
6606110d 48d11e06

+69 -92
+2 -2
drivers/mmc/card/block.c
··· 1928 1928 case MMC_BLK_ECC_ERR: 1929 1929 if (brq->data.blocks > 1) { 1930 1930 /* Redo read one sector at a time */ 1931 - pr_warning("%s: retrying using single block read\n", 1932 - req->rq_disk->disk_name); 1931 + pr_warn("%s: retrying using single block read\n", 1932 + req->rq_disk->disk_name); 1933 1933 disable_multi = 1; 1934 1934 break; 1935 1935 }
+2 -4
drivers/mmc/card/queue.c
··· 229 229 if (bouncesz > 512) { 230 230 mqrq_cur->bounce_buf = kmalloc(bouncesz, GFP_KERNEL); 231 231 if (!mqrq_cur->bounce_buf) { 232 - pr_warning("%s: unable to " 233 - "allocate bounce cur buffer\n", 232 + pr_warn("%s: unable to allocate bounce cur buffer\n", 234 233 mmc_card_name(card)); 235 234 } 236 235 mqrq_prev->bounce_buf = kmalloc(bouncesz, GFP_KERNEL); 237 236 if (!mqrq_prev->bounce_buf) { 238 - pr_warning("%s: unable to " 239 - "allocate bounce prev buffer\n", 237 + pr_warn("%s: unable to allocate bounce prev buffer\n", 240 238 mmc_card_name(card)); 241 239 kfree(mqrq_cur->bounce_buf); 242 240 mqrq_cur->bounce_buf = NULL;
+4 -5
drivers/mmc/card/sdio_uart.c
··· 1063 1063 return -ENOMEM; 1064 1064 1065 1065 if (func->class == SDIO_CLASS_UART) { 1066 - pr_warning("%s: need info on UART class basic setup\n", 1067 - sdio_func_id(func)); 1066 + pr_warn("%s: need info on UART class basic setup\n", 1067 + sdio_func_id(func)); 1068 1068 kfree(port); 1069 1069 return -ENOSYS; 1070 1070 } else if (func->class == SDIO_CLASS_GPS) { ··· 1082 1082 break; 1083 1083 } 1084 1084 if (!tpl) { 1085 - pr_warning( 1086 - "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n", 1087 - sdio_func_id(func)); 1085 + pr_warn("%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n", 1086 + sdio_func_id(func)); 1088 1087 kfree(port); 1089 1088 return -EINVAL; 1090 1089 }
+4 -4
drivers/mmc/core/core.c
··· 433 433 */ 434 434 if (cmd->sanitize_busy && cmd->error == -ETIMEDOUT) { 435 435 if (!mmc_interrupt_hpi(host->card)) { 436 - pr_warning("%s: %s: Interrupted sanitize\n", 437 - mmc_hostname(host), __func__); 436 + pr_warn("%s: %s: Interrupted sanitize\n", 437 + mmc_hostname(host), __func__); 438 438 cmd->error = 0; 439 439 break; 440 440 } else { ··· 1417 1417 if (!host->ops->start_signal_voltage_switch) 1418 1418 return -EPERM; 1419 1419 if (!host->ops->card_busy) 1420 - pr_warning("%s: cannot verify signal voltage switch\n", 1421 - mmc_hostname(host)); 1420 + pr_warn("%s: cannot verify signal voltage switch\n", 1421 + mmc_hostname(host)); 1422 1422 1423 1423 cmd.opcode = SD_SWITCH_VOLTAGE; 1424 1424 cmd.arg = 0;
+7 -10
drivers/mmc/core/mmc.c
··· 226 226 "Card will be ignored.\n", 227 227 mmc_hostname(card->host)); 228 228 } else { 229 - pr_warning("%s: unable to read " 230 - "EXT_CSD, performance might " 231 - "suffer.\n", 229 + pr_warn("%s: unable to read EXT_CSD, performance might suffer\n", 232 230 mmc_hostname(card->host)); 233 231 err = 0; 234 232 } ··· 814 816 ext_csd->raw_pwr_cl_200_360; 815 817 break; 816 818 default: 817 - pr_warning("%s: Voltage range not supported " 818 - "for power class.\n", mmc_hostname(host)); 819 + pr_warn("%s: Voltage range not supported for power class\n", 820 + mmc_hostname(host)); 819 821 return -EINVAL; 820 822 } 821 823 ··· 1488 1490 if (err && err != -EBADMSG) 1489 1491 goto free_card; 1490 1492 if (err) { 1491 - pr_warning("%s: Enabling HPI failed\n", 1492 - mmc_hostname(card->host)); 1493 + pr_warn("%s: Enabling HPI failed\n", 1494 + mmc_hostname(card->host)); 1493 1495 err = 0; 1494 1496 } else 1495 1497 card->ext_csd.hpi_en = 1; ··· 1510 1512 * Only if no error, cache is turned on successfully. 1511 1513 */ 1512 1514 if (err) { 1513 - pr_warning("%s: Cache is supported, " 1514 - "but failed to turn on (%d)\n", 1515 - mmc_hostname(card->host), err); 1515 + pr_warn("%s: Cache is supported, but failed to turn on (%d)\n", 1516 + mmc_hostname(card->host), err); 1516 1517 card->ext_csd.cache_ctrl = 0; 1517 1518 err = 0; 1518 1519 } else {
+2 -2
drivers/mmc/core/mmc_ops.c
··· 649 649 int err; 650 650 651 651 if (!card->ext_csd.hpi) { 652 - pr_warning("%s: Card didn't support HPI command\n", 653 - mmc_hostname(card->host)); 652 + pr_warn("%s: Card didn't support HPI command\n", 653 + mmc_hostname(card->host)); 654 654 return -EINVAL; 655 655 } 656 656
+14 -19
drivers/mmc/core/sd.c
··· 229 229 u32 *ssr; 230 230 231 231 if (!(card->csd.cmdclass & CCC_APP_SPEC)) { 232 - pr_warning("%s: card lacks mandatory SD Status " 233 - "function.\n", mmc_hostname(card->host)); 232 + pr_warn("%s: card lacks mandatory SD Status function\n", 233 + mmc_hostname(card->host)); 234 234 return 0; 235 235 } 236 236 ··· 240 240 241 241 err = mmc_app_sd_status(card, ssr); 242 242 if (err) { 243 - pr_warning("%s: problem reading SD Status " 244 - "register.\n", mmc_hostname(card->host)); 243 + pr_warn("%s: problem reading SD Status register\n", 244 + mmc_hostname(card->host)); 245 245 err = 0; 246 246 goto out; 247 247 } ··· 265 265 card->ssr.erase_offset = eo * 1000; 266 266 } 267 267 } else { 268 - pr_warning("%s: SD Status: Invalid Allocation Unit size.\n", 269 - mmc_hostname(card->host)); 268 + pr_warn("%s: SD Status: Invalid Allocation Unit size\n", 269 + mmc_hostname(card->host)); 270 270 } 271 271 } 272 272 out: ··· 286 286 return 0; 287 287 288 288 if (!(card->csd.cmdclass & CCC_SWITCH)) { 289 - pr_warning("%s: card lacks mandatory switch " 290 - "function, performance might suffer.\n", 289 + pr_warn("%s: card lacks mandatory switch function, performance might suffer\n", 291 290 mmc_hostname(card->host)); 292 291 return 0; 293 292 } ··· 315 316 if (err != -EINVAL && err != -ENOSYS && err != -EFAULT) 316 317 goto out; 317 318 318 - pr_warning("%s: problem reading Bus Speed modes.\n", 319 + pr_warn("%s: problem reading Bus Speed modes\n", 319 320 mmc_hostname(card->host)); 320 321 err = 0; 321 322 ··· 371 372 goto out; 372 373 373 374 if ((status[16] & 0xF) != 1) { 374 - pr_warning("%s: Problem switching card " 375 - "into high-speed mode!\n", 375 + pr_warn("%s: Problem switching card into high-speed mode!\n", 376 376 mmc_hostname(card->host)); 377 377 err = 0; 378 378 } else { ··· 438 440 return err; 439 441 440 442 if ((status[15] & 0xF) != drive_strength) { 441 - pr_warning("%s: Problem setting drive strength!\n", 443 + pr_warn("%s: Problem setting drive strength!\n", 442 444 mmc_hostname(card->host)); 443 445 return 0; 444 446 } ··· 516 518 return err; 517 519 518 520 if ((status[16] & 0xF) != card->sd_bus_speed) 519 - pr_warning("%s: Problem setting bus speed mode!\n", 521 + pr_warn("%s: Problem setting bus speed mode!\n", 520 522 mmc_hostname(card->host)); 521 523 else { 522 524 mmc_set_timing(card->host, timing); ··· 596 598 return err; 597 599 598 600 if (((status[15] >> 4) & 0x0F) != current_limit) 599 - pr_warning("%s: Problem setting current limit!\n", 601 + pr_warn("%s: Problem setting current limit!\n", 600 602 mmc_hostname(card->host)); 601 603 602 604 } ··· 725 727 try_again: 726 728 if (!retries) { 727 729 ocr &= ~SD_OCR_S18R; 728 - pr_warning("%s: Skipping voltage switch\n", 729 - mmc_hostname(host)); 730 + pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host)); 730 731 } 731 732 732 733 /* ··· 869 872 } 870 873 871 874 if (ro < 0) { 872 - pr_warning("%s: host does not " 873 - "support reading read-only " 874 - "switch. assuming write-enable.\n", 875 + pr_warn("%s: host does not support reading read-only switch, assuming write-enable\n", 875 876 mmc_hostname(host)); 876 877 } else if (ro > 0) { 877 878 mmc_card_set_readonly(card);
+3 -4
drivers/mmc/core/sdio.c
··· 216 216 return ret; 217 217 218 218 if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED) 219 - pr_warning("%s: SDIO_CCCR_IF is invalid: 0x%02x\n", 220 - mmc_hostname(card->host), ctrl); 219 + pr_warn("%s: SDIO_CCCR_IF is invalid: 0x%02x\n", 220 + mmc_hostname(card->host), ctrl); 221 221 222 222 /* set as 4-bit bus width */ 223 223 ctrl &= ~SDIO_BUS_WIDTH_MASK; ··· 605 605 606 606 try_again: 607 607 if (!retries) { 608 - pr_warning("%s: Skipping voltage switch\n", 609 - mmc_hostname(host)); 608 + pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host)); 610 609 ocr &= ~R4_18V_PRESENT; 611 610 } 612 611
+2 -2
drivers/mmc/core/sdio_bus.c
··· 177 177 drv->remove(func); 178 178 179 179 if (func->irq_handler) { 180 - pr_warning("WARNING: driver %s did not remove " 181 - "its interrupt handler!\n", drv->name); 180 + pr_warn("WARNING: driver %s did not remove its interrupt handler!\n", 181 + drv->name); 182 182 sdio_claim_host(func); 183 183 sdio_release_irq(func); 184 184 sdio_release_host(func);
+3 -4
drivers/mmc/core/sdio_irq.c
··· 69 69 if (pending & (1 << i)) { 70 70 func = card->sdio_func[i - 1]; 71 71 if (!func) { 72 - pr_warning("%s: pending IRQ for " 73 - "non-existent function\n", 72 + pr_warn("%s: pending IRQ for non-existent function\n", 74 73 mmc_card_id(card)); 75 74 ret = -EINVAL; 76 75 } else if (func->irq_handler) { 77 76 func->irq_handler(func); 78 77 count++; 79 78 } else { 80 - pr_warning("%s: pending IRQ with no handler\n", 81 - sdio_func_id(func)); 79 + pr_warn("%s: pending IRQ with no handler\n", 80 + sdio_func_id(func)); 82 81 ret = -EINVAL; 83 82 } 84 83 }
+2 -1
drivers/mmc/host/s3cmci.c
··· 985 985 * one block being transferred. */ 986 986 987 987 if (data->blocks > 1) { 988 - pr_warning("%s: can't do non-word sized block transfers (blksz %d)\n", __func__, data->blksz); 988 + pr_warn("%s: can't do non-word sized block transfers (blksz %d)\n", 989 + __func__, data->blksz); 989 990 return -EINVAL; 990 991 } 991 992 }
+16 -18
drivers/mmc/host/sdhci.c
··· 1754 1754 ret = regulator_set_voltage(mmc->supply.vqmmc, 2700000, 1755 1755 3600000); 1756 1756 if (ret) { 1757 - pr_warning("%s: Switching to 3.3V signalling voltage " 1758 - " failed\n", mmc_hostname(mmc)); 1757 + pr_warn("%s: Switching to 3.3V signalling voltage failed\n", 1758 + mmc_hostname(mmc)); 1759 1759 return -EIO; 1760 1760 } 1761 1761 } ··· 1767 1767 if (!(ctrl & SDHCI_CTRL_VDD_180)) 1768 1768 return 0; 1769 1769 1770 - pr_warning("%s: 3.3V regulator output did not became stable\n", 1771 - mmc_hostname(mmc)); 1770 + pr_warn("%s: 3.3V regulator output did not became stable\n", 1771 + mmc_hostname(mmc)); 1772 1772 1773 1773 return -EAGAIN; 1774 1774 case MMC_SIGNAL_VOLTAGE_180: ··· 1776 1776 ret = regulator_set_voltage(mmc->supply.vqmmc, 1777 1777 1700000, 1950000); 1778 1778 if (ret) { 1779 - pr_warning("%s: Switching to 1.8V signalling voltage " 1780 - " failed\n", mmc_hostname(mmc)); 1779 + pr_warn("%s: Switching to 1.8V signalling voltage failed\n", 1780 + mmc_hostname(mmc)); 1781 1781 return -EIO; 1782 1782 } 1783 1783 } ··· 1794 1794 if (ctrl & SDHCI_CTRL_VDD_180) 1795 1795 return 0; 1796 1796 1797 - pr_warning("%s: 1.8V regulator output did not became stable\n", 1798 - mmc_hostname(mmc)); 1797 + pr_warn("%s: 1.8V regulator output did not became stable\n", 1798 + mmc_hostname(mmc)); 1799 1799 1800 1800 return -EAGAIN; 1801 1801 case MMC_SIGNAL_VOLTAGE_120: ··· 1803 1803 ret = regulator_set_voltage(mmc->supply.vqmmc, 1100000, 1804 1804 1300000); 1805 1805 if (ret) { 1806 - pr_warning("%s: Switching to 1.2V signalling voltage " 1807 - " failed\n", mmc_hostname(mmc)); 1806 + pr_warn("%s: Switching to 1.2V signalling voltage failed\n", 1807 + mmc_hostname(mmc)); 1808 1808 return -EIO; 1809 1809 } 1810 1810 } ··· 2844 2844 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) { 2845 2845 if (host->ops->enable_dma) { 2846 2846 if (host->ops->enable_dma(host)) { 2847 - pr_warning("%s: No suitable DMA " 2848 - "available. Falling back to PIO.\n", 2847 + pr_warn("%s: No suitable DMA available - falling back to PIO\n", 2849 2848 mmc_hostname(mmc)); 2850 2849 host->flags &= 2851 2850 ~(SDHCI_USE_SDMA | SDHCI_USE_ADMA); ··· 2866 2867 dma_free_coherent(mmc_dev(mmc), ADMA_SIZE, 2867 2868 host->adma_desc, host->adma_addr); 2868 2869 kfree(host->align_buffer); 2869 - pr_warning("%s: Unable to allocate ADMA " 2870 - "buffers. Falling back to standard DMA.\n", 2870 + pr_warn("%s: Unable to allocate ADMA buffers - falling back to standard DMA\n", 2871 2871 mmc_hostname(mmc)); 2872 2872 host->flags &= ~SDHCI_USE_ADMA; 2873 2873 host->adma_desc = NULL; 2874 2874 host->align_buffer = NULL; 2875 2875 } else if (host->adma_addr & 3) { 2876 - pr_warning("%s: unable to allocate aligned ADMA descriptor\n", 2877 - mmc_hostname(mmc)); 2876 + pr_warn("%s: unable to allocate aligned ADMA descriptor\n", 2877 + mmc_hostname(mmc)); 2878 2878 host->flags &= ~SDHCI_USE_ADMA; 2879 2879 dma_free_coherent(mmc_dev(mmc), ADMA_SIZE, 2880 2880 host->adma_desc, host->adma_addr); ··· 3200 3202 mmc->max_blk_size = (caps[0] & SDHCI_MAX_BLOCK_MASK) >> 3201 3203 SDHCI_MAX_BLOCK_SHIFT; 3202 3204 if (mmc->max_blk_size >= 3) { 3203 - pr_warning("%s: Invalid maximum block size, " 3204 - "assuming 512 bytes\n", mmc_hostname(mmc)); 3205 + pr_warn("%s: Invalid maximum block size, assuming 512 bytes\n", 3206 + mmc_hostname(mmc)); 3205 3207 mmc->max_blk_size = 0; 3206 3208 } 3207 3209 }
+2 -2
drivers/mmc/host/tifm_sd.c
··· 952 952 953 953 if (!(TIFM_SOCK_STATE_OCCUPIED 954 954 & readl(sock->addr + SOCK_PRESENT_STATE))) { 955 - pr_warning("%s : card gone, unexpectedly\n", 956 - dev_name(&sock->dev)); 955 + pr_warn("%s : card gone, unexpectedly\n", 956 + dev_name(&sock->dev)); 957 957 return rc; 958 958 } 959 959
+6 -15
drivers/mmc/host/wbsd.c
··· 803 803 804 804 default: 805 805 #ifdef CONFIG_MMC_DEBUG 806 - pr_warning("%s: Data command %d is not " 807 - "supported by this controller.\n", 806 + pr_warn("%s: Data command %d is not supported by this controller\n", 808 807 mmc_hostname(host->mmc), cmd->opcode); 809 808 #endif 810 809 cmd->error = -EINVAL; ··· 1428 1429 free_dma(dma); 1429 1430 1430 1431 err: 1431 - pr_warning(DRIVER_NAME ": Unable to allocate DMA %d. " 1432 - "Falling back on FIFO.\n", dma); 1432 + pr_warn(DRIVER_NAME ": Unable to allocate DMA %d - falling back on FIFO\n", 1433 + dma); 1433 1434 } 1434 1435 1435 1436 static void wbsd_release_dma(struct wbsd_host *host) ··· 1663 1664 ret = wbsd_scan(host); 1664 1665 if (ret) { 1665 1666 if (pnp && (ret == -ENODEV)) { 1666 - pr_warning(DRIVER_NAME 1667 - ": Unable to confirm device presence. You may " 1668 - "experience lock-ups.\n"); 1667 + pr_warn(DRIVER_NAME ": Unable to confirm device presence - you may experience lock-ups\n"); 1669 1668 } else { 1670 1669 wbsd_free_mmc(dev); 1671 1670 return ret; ··· 1685 1688 */ 1686 1689 if (pnp) { 1687 1690 if ((host->config != 0) && !wbsd_chip_validate(host)) { 1688 - pr_warning(DRIVER_NAME 1689 - ": PnP active but chip not configured! " 1690 - "You probably have a buggy BIOS. " 1691 - "Configuring chip manually.\n"); 1691 + pr_warn(DRIVER_NAME ": PnP active but chip not configured! You probably have a buggy BIOS. Configuring chip manually.\n"); 1692 1692 wbsd_chip_config(host); 1693 1693 } 1694 1694 } else ··· 1878 1884 */ 1879 1885 if (host->config != 0) { 1880 1886 if (!wbsd_chip_validate(host)) { 1881 - pr_warning(DRIVER_NAME 1882 - ": PnP active but chip not configured! " 1883 - "You probably have a buggy BIOS. " 1884 - "Configuring chip manually.\n"); 1887 + pr_warn(DRIVER_NAME ": PnP active but chip not configured! You probably have a buggy BIOS. Configuring chip manually.\n"); 1885 1888 wbsd_chip_config(host); 1886 1889 } 1887 1890 }