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

USB: remove info() macro from usb/serial drivers

USB should not be having it's own printk macros, so remove info() and
use the system-wide standard of dev_info() wherever possible.

Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Greg Kroah-Hartman c197a8db 46fcaec5

+96 -63
+3 -2
drivers/usb/serial/belkin_sa.c
··· 187 187 /* see comments at top of file */ 188 188 priv->bad_flow_control = 189 189 (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0; 190 - info("bcdDevice: %04x, bfc: %d", 190 + dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n", 191 191 le16_to_cpu(dev->descriptor.bcdDevice), 192 192 priv->bad_flow_control); 193 193 ··· 577 577 retval = usb_register(&belkin_driver); 578 578 if (retval) 579 579 goto failed_usb_register; 580 - info(DRIVER_DESC " " DRIVER_VERSION); 580 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 581 + DRIVER_DESC "\n"); 581 582 return 0; 582 583 failed_usb_register: 583 584 usb_serial_deregister(&belkin_device);
+2 -1
drivers/usb/serial/cp2101.c
··· 753 753 } 754 754 755 755 /* Success */ 756 - info(DRIVER_DESC " " DRIVER_VERSION); 756 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 757 + DRIVER_DESC "\n"); 757 758 return 0; 758 759 } 759 760
+3 -2
drivers/usb/serial/cyberjack.c
··· 499 499 if (retval) 500 500 goto failed_usb_register; 501 501 502 - info(DRIVER_VERSION " " DRIVER_AUTHOR); 503 - info(DRIVER_DESC); 502 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION " " 503 + DRIVER_AUTHOR "\n"); 504 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 504 505 505 506 return 0; 506 507 failed_usb_register:
+2 -1
drivers/usb/serial/cypress_m8.c
··· 1658 1658 if (retval) 1659 1659 goto failed_usb_register; 1660 1660 1661 - info(DRIVER_DESC " " DRIVER_VERSION); 1661 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1662 + DRIVER_DESC "\n"); 1662 1663 return 0; 1663 1664 1664 1665 failed_usb_register:
+2 -1
drivers/usb/serial/digi_acceleport.c
··· 1854 1854 retval = usb_register(&digi_driver); 1855 1855 if (retval) 1856 1856 goto failed_usb_register; 1857 - info(DRIVER_VERSION ":" DRIVER_DESC); 1857 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1858 + DRIVER_DESC "\n"); 1858 1859 return 0; 1859 1860 failed_usb_register: 1860 1861 usb_serial_deregister(&digi_acceleport_4_device);
+2 -1
drivers/usb/serial/empeg.c
··· 519 519 if (retval) 520 520 goto failed_usb_register; 521 521 522 - info(DRIVER_VERSION ":" DRIVER_DESC); 522 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 523 + DRIVER_DESC "\n"); 523 524 524 525 return 0; 525 526 failed_usb_register:
+7 -4
drivers/usb/serial/ftdi_sio.c
··· 1154 1154 /* Assume its an FT232R */ 1155 1155 priv->chip_type = FT232RL; 1156 1156 } 1157 - info("Detected %s", ftdi_chip_name[priv->chip_type]); 1157 + dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]); 1158 1158 } 1159 1159 1160 1160 ··· 1410 1410 dbg("%s", __func__); 1411 1411 1412 1412 if (interface == udev->actconfig->interface[0]) { 1413 - info("Ignoring serial port reserved for JTAG"); 1413 + dev_info(&udev->dev, 1414 + "Ignoring serial port reserved for JTAG\n"); 1414 1415 return -ENODEV; 1415 1416 } 1416 1417 ··· 1429 1428 1430 1429 if (ep->enabled && ep_desc->wMaxPacketSize == 0) { 1431 1430 ep_desc->wMaxPacketSize = cpu_to_le16(0x40); 1432 - info("Fixing invalid wMaxPacketSize on read pipe"); 1431 + dev_info(&serial->dev->dev, 1432 + "Fixing invalid wMaxPacketSize on read pipe\n"); 1433 1433 } 1434 1434 1435 1435 return 0; ··· 2428 2426 if (retval) 2429 2427 goto failed_usb_register; 2430 2428 2431 - info(DRIVER_VERSION ":" DRIVER_DESC); 2429 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 2430 + DRIVER_DESC "\n"); 2432 2431 return 0; 2433 2432 failed_usb_register: 2434 2433 usb_serial_deregister(&ftdi_sio_device);
+2 -1
drivers/usb/serial/garmin_gps.c
··· 1585 1585 retval = usb_register(&garmin_driver); 1586 1586 if (retval) 1587 1587 goto failed_usb_register; 1588 - info(DRIVER_DESC " " DRIVER_VERSION); 1588 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1589 + DRIVER_DESC "\n"); 1589 1590 1590 1591 return 0; 1591 1592 failed_usb_register:
+2 -1
drivers/usb/serial/hp4x.c
··· 63 63 retval = usb_register(&hp49gp_driver); 64 64 if (retval) 65 65 goto failed_usb_register; 66 - info(DRIVER_DESC " " DRIVER_VERSION); 66 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 67 + DRIVER_DESC "\n"); 67 68 return 0; 68 69 failed_usb_register: 69 70 usb_serial_deregister(&hp49gp_device);
+2 -1
drivers/usb/serial/io_edgeport.c
··· 3253 3253 if (retval) 3254 3254 goto failed_usb_register; 3255 3255 atomic_set(&CmdUrbs, 0); 3256 - info(DRIVER_DESC " " DRIVER_VERSION); 3256 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 3257 + DRIVER_DESC "\n"); 3257 3258 return 0; 3258 3259 3259 3260 failed_usb_register:
+2 -1
drivers/usb/serial/io_ti.c
··· 2978 2978 retval = usb_register(&io_driver); 2979 2979 if (retval) 2980 2980 goto failed_usb_register; 2981 - info(DRIVER_DESC " " DRIVER_VERSION); 2981 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 2982 + DRIVER_DESC "\n"); 2982 2983 return 0; 2983 2984 failed_usb_register: 2984 2985 usb_serial_deregister(&edgeport_2port_device);
+2 -1
drivers/usb/serial/ipaq.c
··· 976 976 retval = usb_serial_register(&ipaq_device); 977 977 if (retval) 978 978 goto failed_usb_serial_register; 979 - info(DRIVER_DESC " " DRIVER_VERSION); 980 979 if (vendor) { 981 980 ipaq_id_table[0].idVendor = vendor; 982 981 ipaq_id_table[0].idProduct = product; ··· 984 985 if (retval) 985 986 goto failed_usb_register; 986 987 988 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 989 + DRIVER_DESC "\n"); 987 990 return 0; 988 991 failed_usb_register: 989 992 usb_serial_deregister(&ipaq_device);
+2 -1
drivers/usb/serial/ipw.c
··· 485 485 usb_serial_deregister(&ipw_device); 486 486 return retval; 487 487 } 488 - info(DRIVER_DESC " " DRIVER_VERSION); 488 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 489 + DRIVER_DESC "\n"); 489 490 return 0; 490 491 } 491 492
+2 -1
drivers/usb/serial/ir-usb.c
··· 602 602 if (retval) 603 603 goto failed_usb_register; 604 604 605 - info(DRIVER_DESC " " DRIVER_VERSION); 605 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 606 + DRIVER_DESC "\n"); 606 607 607 608 return 0; 608 609
+2 -1
drivers/usb/serial/iuu_phoenix.c
··· 1185 1185 retval = usb_register(&iuu_driver); 1186 1186 if (retval) 1187 1187 goto failed_usb_register; 1188 - info(DRIVER_DESC " " DRIVER_VERSION); 1188 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1189 + DRIVER_DESC "\n"); 1189 1190 return 0; 1190 1191 failed_usb_register: 1191 1192 usb_serial_deregister(&iuu_device);
+2 -1
drivers/usb/serial/keyspan.c
··· 217 217 if (retval) 218 218 goto failed_usb_register; 219 219 220 - info(DRIVER_VERSION ":" DRIVER_DESC); 220 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 221 + DRIVER_DESC "\n"); 221 222 222 223 return 0; 223 224 failed_usb_register:
+2 -1
drivers/usb/serial/keyspan_pda.c
··· 874 874 retval = usb_register(&keyspan_pda_driver); 875 875 if (retval) 876 876 goto failed_usb_register; 877 - info(DRIVER_DESC " " DRIVER_VERSION); 877 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 878 + DRIVER_DESC "\n"); 878 879 return 0; 879 880 failed_usb_register: 880 881 #ifdef XIRCOM
+12 -11
drivers/usb/serial/kl5kusb105.c
··· 183 183 KLSI_TIMEOUT); 184 184 if (rc < 0) 185 185 err("Change port settings failed (error = %d)", rc); 186 - info("%s - %d byte block, baudrate %x, databits %d, u1 %d, u2 %d", 187 - __func__, 188 - settings->pktlen, 189 - settings->baudrate, settings->databits, 190 - settings->unknown1, settings->unknown2); 186 + dev_info(&port->serial->dev->dev, 187 + "%d byte block, baudrate %x, databits %d, u1 %d, u2 %d\n", 188 + settings->pktlen, settings->baudrate, settings->databits, 189 + settings->unknown1, settings->unknown2); 191 190 return rc; 192 191 } /* klsi_105_chg_port_settings */ 193 192 ··· 214 215 __u8 status_buf[KLSI_STATUSBUF_LEN] = { -1, -1}; 215 216 __u16 status; 216 217 217 - info("%s - sending SIO Poll request", __func__); 218 + dev_info(&port->serial->dev->dev, "sending SIO Poll request\n"); 218 219 rc = usb_control_msg(port->serial->dev, 219 220 usb_rcvctrlpipe(port->serial->dev, 0), 220 221 KL5KUSB105A_SIO_POLL, ··· 229 230 else { 230 231 status = get_unaligned_le16(status_buf); 231 232 232 - info("%s - read status %x %x", __func__, 233 - status_buf[0], status_buf[1]); 233 + dev_info(&port->serial->dev->dev, "read status %x %x", 234 + status_buf[0], status_buf[1]); 234 235 235 236 *line_state_p = klsi_105_status2linestate(status); 236 237 } ··· 474 475 /* FIXME */ 475 476 /* wgg - do I need this? I think so. */ 476 477 usb_kill_urb(port->interrupt_in_urb); 477 - info("kl5kusb105 port stats: %ld bytes in, %ld bytes out", 478 - priv->bytes_in, priv->bytes_out); 478 + dev_info(&port->serial->dev->dev, 479 + "port stats: %ld bytes in, %ld bytes out\n", 480 + priv->bytes_in, priv->bytes_out); 479 481 } /* klsi_105_close */ 480 482 481 483 ··· 960 960 if (retval) 961 961 goto failed_usb_register; 962 962 963 - info(DRIVER_DESC " " DRIVER_VERSION); 963 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 964 + DRIVER_DESC "\n"); 964 965 return 0; 965 966 failed_usb_register: 966 967 usb_serial_deregister(&kl5kusb105d_device);
+2 -2
drivers/usb/serial/kobil_sct.c
··· 744 744 if (retval) 745 745 goto failed_usb_register; 746 746 747 - info(DRIVER_VERSION " " DRIVER_AUTHOR); 748 - info(DRIVER_DESC); 747 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 748 + DRIVER_DESC "\n"); 749 749 750 750 return 0; 751 751 failed_usb_register:
+2 -1
drivers/usb/serial/mct_u232.c
··· 817 817 retval = usb_register(&mct_u232_driver); 818 818 if (retval) 819 819 goto failed_usb_register; 820 - info(DRIVER_DESC " " DRIVER_VERSION); 820 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 821 + DRIVER_DESC "\n"); 821 822 return 0; 822 823 failed_usb_register: 823 824 usb_serial_deregister(&mct_u232_device);
+2 -1
drivers/usb/serial/mos7720.c
··· 1585 1585 if (retval) 1586 1586 goto failed_port_device_register; 1587 1587 1588 - info(DRIVER_DESC " " DRIVER_VERSION); 1588 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1589 + DRIVER_DESC "\n"); 1589 1590 1590 1591 /* Register with the usb */ 1591 1592 retval = usb_register(&usb_driver);
+2 -1
drivers/usb/serial/mos7840.c
··· 2743 2743 goto failed_port_device_register; 2744 2744 2745 2745 dbg("%s\n", "Entring..."); 2746 - info(DRIVER_DESC " " DRIVER_VERSION); 2746 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 2747 + DRIVER_DESC "\n"); 2747 2748 2748 2749 /* Register with the usb */ 2749 2750 retval = usb_register(&io_driver);
+2 -1
drivers/usb/serial/omninet.c
··· 364 364 retval = usb_register(&omninet_driver); 365 365 if (retval) 366 366 goto failed_usb_register; 367 - info(DRIVER_VERSION ":" DRIVER_DESC); 367 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 368 + DRIVER_DESC "\n"); 368 369 return 0; 369 370 failed_usb_register: 370 371 usb_serial_deregister(&zyxel_omninet_device);
+2 -1
drivers/usb/serial/option.c
··· 420 420 if (retval) 421 421 goto failed_driver_register; 422 422 423 - info(DRIVER_DESC ": " DRIVER_VERSION); 423 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 424 + DRIVER_DESC "\n"); 424 425 425 426 return 0; 426 427
+1 -1
drivers/usb/serial/pl2303.c
··· 1147 1147 retval = usb_register(&pl2303_driver); 1148 1148 if (retval) 1149 1149 goto failed_usb_register; 1150 - info(DRIVER_DESC); 1150 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1151 1151 return 0; 1152 1152 failed_usb_register: 1153 1153 usb_serial_deregister(&pl2303_device);
+6 -7
drivers/usb/serial/safe_serial.c
··· 250 250 if (!fcs) { 251 251 int actual_length = data[length - 2] >> 2; 252 252 if (actual_length <= (length - 2)) { 253 - info("%s - actual: %d", __func__, 254 - actual_length); 253 + dev_info(&urb->dev->dev, "%s - actual: %d\n", 254 + __func__, actual_length); 255 255 tty_insert_flip_string(tty, 256 256 data, actual_length); 257 257 tty_flip_buffer_push(tty); ··· 428 428 { 429 429 int i, retval; 430 430 431 - info(DRIVER_VERSION " " DRIVER_AUTHOR); 432 - info(DRIVER_DESC); 433 - info("vendor: %x product: %x safe: %d padded: %d\n", 434 - vendor, product, safe, padded); 431 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 432 + DRIVER_DESC "\n"); 435 433 436 434 /* if we have vendor / product parameters patch them into id list */ 437 435 if (vendor || product) { 438 - info("vendor: %x product: %x\n", vendor, product); 436 + printk(KERN_INFO KBUILD_MODNAME ": vendor: %x product: %x\n", 437 + vendor, product); 439 438 440 439 for (i = 0; i < ARRAY_SIZE(id_table); i++) { 441 440 if (!id_table[i].idVendor && !id_table[i].idProduct) {
+2 -1
drivers/usb/serial/sierra.c
··· 750 750 if (retval) 751 751 goto failed_driver_register; 752 752 753 - info(DRIVER_DESC ": " DRIVER_VERSION); 753 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 754 + DRIVER_DESC "\n"); 754 755 755 756 return 0; 756 757
+2 -1
drivers/usb/serial/spcp8x5.c
··· 1054 1054 retval = usb_register(&spcp8x5_driver); 1055 1055 if (retval) 1056 1056 goto failed_usb_register; 1057 - info(DRIVER_DESC " " DRIVER_VERSION); 1057 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1058 + DRIVER_DESC "\n"); 1058 1059 return 0; 1059 1060 failed_usb_register: 1060 1061 usb_serial_deregister(&spcp8x5_device);
+2 -1
drivers/usb/serial/ti_usb_3410_5052.c
··· 382 382 if (ret) 383 383 goto failed_usb; 384 384 385 - info(TI_DRIVER_DESC " " TI_DRIVER_VERSION); 385 + printk(KERN_INFO KBUILD_MODNAME ": " TI_DRIVER_VERSION ":" 386 + TI_DRIVER_DESC "\n"); 386 387 387 388 return 0; 388 389
+4 -3
drivers/usb/serial/usb-serial.c
··· 1160 1160 goto exit_generic; 1161 1161 } 1162 1162 1163 - info(DRIVER_DESC); 1163 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1164 1164 1165 1165 return result; 1166 1166 ··· 1237 1237 retval, driver->description); 1238 1238 list_del(&driver->driver_list); 1239 1239 } else 1240 - info("USB Serial support registered for %s", 1240 + printk(KERN_INFO "USB Serial support registered for %s\n", 1241 1241 driver->description); 1242 1242 1243 1243 return retval; ··· 1248 1248 void usb_serial_deregister(struct usb_serial_driver *device) 1249 1249 { 1250 1250 /* must be called with BKL held */ 1251 - info("USB Serial deregistering driver %s", device->description); 1251 + printk(KERN_INFO "USB Serial deregistering driver %s\n", 1252 + device->description); 1252 1253 list_del(&device->driver_list); 1253 1254 usb_serial_bus_deregister(device); 1254 1255 }
+9 -6
drivers/usb/serial/visor.c
··· 971 971 break; 972 972 } 973 973 } 974 - info( 975 - "Untested USB device specified at time of module insertion"); 976 - info("Warning: This is not guaranteed to work"); 977 - info("Using a newer kernel is preferred to this method"); 978 - info("Adding Palm OS protocol 4.x support for unknown device: 0x%x/0x%x", 974 + printk(KERN_INFO KBUILD_MODNAME 975 + ": Untested USB device specified at time of module insertion\n"); 976 + printk(KERN_INFO KBUILD_MODNAME 977 + ": Warning: This is not guaranteed to work\n"); 978 + printk(KERN_INFO KBUILD_MODNAME 979 + ": Using a newer kernel is preferred to this method\n"); 980 + printk(KERN_INFO KBUILD_MODNAME 981 + ": Adding Palm OS protocol 4.x support for unknown device: 0x%x/0x%x\n", 979 982 vendor, product); 980 983 } 981 984 retval = usb_serial_register(&handspring_device); ··· 993 990 retval = usb_register(&visor_driver); 994 991 if (retval) 995 992 goto failed_usb_register; 996 - info(DRIVER_DESC); 993 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 997 994 998 995 return 0; 999 996 failed_usb_register:
+5 -3
drivers/usb/serial/whiteheat.c
··· 452 452 453 453 hw_info = (struct whiteheat_hw_info *)&result[1]; 454 454 455 - info("%s: Driver %s: Firmware v%d.%02d", serial->type->description, 456 - DRIVER_VERSION, hw_info->sw_major_rev, hw_info->sw_minor_rev); 455 + dev_info(&serial->dev->dev, "%s: Driver %s: Firmware v%d.%02d\n", 456 + serial->type->description, DRIVER_VERSION, 457 + hw_info->sw_major_rev, hw_info->sw_minor_rev); 457 458 458 459 for (i = 0; i < serial->num_ports; i++) { 459 460 port = serial->port[i]; ··· 1557 1556 retval = usb_register(&whiteheat_driver); 1558 1557 if (retval) 1559 1558 goto failed_usb_register; 1560 - info(DRIVER_DESC " " DRIVER_VERSION); 1559 + printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 1560 + DRIVER_DESC "\n"); 1561 1561 return 0; 1562 1562 failed_usb_register: 1563 1563 usb_serial_deregister(&whiteheat_device);