pcmcia: Convert dev_printk to dev_<level>

+2 -3

drivers/char/pcmcia/cm4040_cs.c

··· 532 532 533 533 fail_rc = pcmcia_enable_device(link); 534 534 if (fail_rc != 0) { 535 - dev_printk(KERN_INFO, &link->dev, 536 - "pcmcia_enable_device failed 0x%x\n", 537 - fail_rc); 535 + dev_info(&link->dev, "pcmcia_enable_device failed 0x%x\n", 536 + fail_rc); 538 537 goto cs_release; 539 538 } 540 539

+4 -6

drivers/pcmcia/cistpl.c

··· 94 94 mem->res = pcmcia_find_mem_region(0, s->map_size, 95 95 s->map_size, 0, s); 96 96 if (mem->res == NULL) { 97 - dev_printk(KERN_NOTICE, &s->dev, 98 - "cs: unable to map card memory!\n"); 97 + dev_notice(&s->dev, "cs: unable to map card memory!\n"); 99 98 return NULL; 100 99 } 101 100 s->cis_virt = NULL; ··· 380 381 381 382 buf = kmalloc(256, GFP_KERNEL); 382 383 if (buf == NULL) { 383 - dev_printk(KERN_WARNING, &s->dev, 384 - "no memory for verifying CIS\n"); 384 + dev_warn(&s->dev, "no memory for verifying CIS\n"); 385 385 return -ENOMEM; 386 386 } 387 387 mutex_lock(&s->ops_mutex); ··· 412 414 const u8 *data, const size_t len) 413 415 { 414 416 if (len > CISTPL_MAX_CIS_SIZE) { 415 - dev_printk(KERN_WARNING, &s->dev, "replacement CIS too big\n"); 417 + dev_warn(&s->dev, "replacement CIS too big\n"); 416 418 return -EINVAL; 417 419 } 418 420 mutex_lock(&s->ops_mutex); 419 421 kfree(s->fake_cis); 420 422 s->fake_cis = kmalloc(len, GFP_KERNEL); 421 423 if (s->fake_cis == NULL) { 422 - dev_printk(KERN_WARNING, &s->dev, "no memory to replace CIS\n"); 424 + dev_warn(&s->dev, "no memory to replace CIS\n"); 423 425 mutex_unlock(&s->ops_mutex); 424 426 return -ENOMEM; 425 427 }

+12 -17

drivers/pcmcia/cs.c

··· 177 177 178 178 wait_for_completion(&socket->thread_done); 179 179 if (!socket->thread) { 180 - dev_printk(KERN_WARNING, &socket->dev, 181 - "PCMCIA: warning: socket thread did not start\n"); 180 + dev_warn(&socket->dev, 181 + "PCMCIA: warning: socket thread did not start\n"); 182 182 return -EIO; 183 183 } 184 184 ··· 275 275 msleep(unreset_check * 10); 276 276 } 277 277 278 - dev_printk(KERN_ERR, &skt->dev, "time out after reset.\n"); 278 + dev_err(&skt->dev, "time out after reset\n"); 279 279 return -ETIMEDOUT; 280 280 } 281 281 ··· 325 325 326 326 s->ops->get_status(s, &status); 327 327 if (status & SS_POWERON) { 328 - dev_printk(KERN_ERR, &s->dev, 329 - "*** DANGER *** unable to remove socket power\n"); 328 + dev_err(&s->dev, 329 + "*** DANGER *** unable to remove socket power\n"); 330 330 } 331 331 332 332 s->state &= ~SOCKET_INUSE; ··· 356 356 } 357 357 358 358 if (status & SS_PENDING) { 359 - dev_printk(KERN_ERR, &skt->dev, 360 - "voltage interrogation timed out.\n"); 359 + dev_err(&skt->dev, "voltage interrogation timed out\n"); 361 360 return -ETIMEDOUT; 362 361 } 363 362 364 363 if (status & SS_CARDBUS) { 365 364 if (!(skt->features & SS_CAP_CARDBUS)) { 366 - dev_printk(KERN_ERR, &skt->dev, 367 - "cardbus cards are not supported.\n"); 365 + dev_err(&skt->dev, "cardbus cards are not supported\n"); 368 366 return -EINVAL; 369 367 } 370 368 skt->state |= SOCKET_CARDBUS; ··· 377 379 else if (!(status & SS_XVCARD)) 378 380 skt->socket.Vcc = skt->socket.Vpp = 50; 379 381 else { 380 - dev_printk(KERN_ERR, &skt->dev, "unsupported voltage key.\n"); 382 + dev_err(&skt->dev, "unsupported voltage key\n"); 381 383 return -EIO; 382 384 } 383 385 ··· 394 396 395 397 skt->ops->get_status(skt, &status); 396 398 if (!(status & SS_POWERON)) { 397 - dev_printk(KERN_ERR, &skt->dev, "unable to apply power.\n"); 399 + dev_err(&skt->dev, "unable to apply power\n"); 398 400 return -EIO; 399 401 } 400 402 ··· 427 429 if (ret == 0) { 428 430 skt->state |= SOCKET_PRESENT; 429 431 430 - dev_printk(KERN_NOTICE, &skt->dev, 431 - "pccard: %s card inserted into slot %d\n", 432 + dev_notice(&skt->dev, "pccard: %s card inserted into slot %d\n", 432 433 (skt->state & SOCKET_CARDBUS) ? "CardBus" : "PCMCIA", 433 434 skt->sock); 434 435 ··· 555 558 556 559 static void socket_remove(struct pcmcia_socket *skt) 557 560 { 558 - dev_printk(KERN_NOTICE, &skt->dev, 559 - "pccard: card ejected from slot %d\n", skt->sock); 561 + dev_notice(&skt->dev, "pccard: card ejected from slot %d\n", skt->sock); 560 562 socket_shutdown(skt); 561 563 } 562 564 ··· 601 605 /* register with the device core */ 602 606 ret = device_register(&skt->dev); 603 607 if (ret) { 604 - dev_printk(KERN_WARNING, &skt->dev, 605 - "PCMCIA: unable to register socket\n"); 608 + dev_warn(&skt->dev, "PCMCIA: unable to register socket\n"); 606 609 skt->thread = NULL; 607 610 complete(&skt->thread_done); 608 611 return 0;

+17 -22

drivers/pcmcia/ds.c

··· 284 284 dev_dbg(dev, "base %x, regs %x", p_dev->config_base, 285 285 p_dev->config_regs); 286 286 } else { 287 - dev_printk(KERN_INFO, dev, 288 - "pcmcia: could not parse base and rmask0 of CIS\n"); 287 + dev_info(dev, 288 + "pcmcia: could not parse base and rmask0 of CIS\n"); 289 289 p_dev->config_base = 0; 290 290 p_dev->config_regs = 0; 291 291 } ··· 382 382 383 383 /* check for proper unloading */ 384 384 if (p_dev->_irq || p_dev->_io || p_dev->_locked) 385 - dev_printk(KERN_INFO, dev, 386 - "pcmcia: driver %s did not release config properly\n", 387 - p_drv->name); 385 + dev_info(dev, 386 + "pcmcia: driver %s did not release config properly\n", 387 + p_drv->name); 388 388 389 389 for (i = 0; i < MAX_WIN; i++) 390 390 if (p_dev->_win & CLIENT_WIN_REQ(i)) 391 - dev_printk(KERN_INFO, dev, 392 - "pcmcia: driver %s did not release window properly\n", 393 - p_drv->name); 391 + dev_info(dev, 392 + "pcmcia: driver %s did not release window properly\n", 393 + p_drv->name); 394 394 395 395 /* references from pcmcia_probe_device */ 396 396 pcmcia_put_dev(p_dev); ··· 578 578 579 579 mutex_unlock(&s->ops_mutex); 580 580 581 - dev_printk(KERN_NOTICE, &p_dev->dev, 582 - "pcmcia: registering new device %s (IRQ: %d)\n", 581 + dev_notice(&p_dev->dev, "pcmcia: registering new device %s (IRQ: %d)\n", 583 582 p_dev->devname, p_dev->irq); 584 583 585 584 pcmcia_device_query(p_dev); ··· 744 745 if (request_firmware(&fw, filename, &dev->dev) == 0) { 745 746 if (fw->size >= CISTPL_MAX_CIS_SIZE) { 746 747 ret = -EINVAL; 747 - dev_printk(KERN_ERR, &dev->dev, 748 - "pcmcia: CIS override is too big\n"); 748 + dev_err(&dev->dev, "pcmcia: CIS override is too big\n"); 749 749 goto release; 750 750 } 751 751 752 752 if (!pcmcia_replace_cis(s, fw->data, fw->size)) 753 753 ret = 0; 754 754 else { 755 - dev_printk(KERN_ERR, &dev->dev, 756 - "pcmcia: CIS override failed\n"); 755 + dev_err(&dev->dev, "pcmcia: CIS override failed\n"); 757 756 goto release; 758 757 } 759 758 ··· 1146 1149 if (p_drv->suspend) { 1147 1150 ret = p_drv->suspend(p_dev); 1148 1151 if (ret) { 1149 - dev_printk(KERN_ERR, dev, 1150 - "pcmcia: device %s (driver %s) did " 1151 - "not want to go to sleep (%d)\n", 1152 - p_dev->devname, p_drv->name, ret); 1152 + dev_err(dev, 1153 + "pcmcia: device %s (driver %s) did not want to go to sleep (%d)\n", 1154 + p_dev->devname, p_drv->name, ret); 1153 1155 mutex_lock(&p_dev->socket->ops_mutex); 1154 1156 p_dev->suspended = 0; 1155 1157 mutex_unlock(&p_dev->socket->ops_mutex); ··· 1339 1343 1340 1344 socket = pcmcia_get_socket(socket); 1341 1345 if (!socket) { 1342 - dev_printk(KERN_ERR, dev, 1343 - "PCMCIA obtaining reference to socket failed\n"); 1346 + dev_err(dev, "PCMCIA obtaining reference to socket failed\n"); 1344 1347 return -ENODEV; 1345 1348 } 1346 1349 1347 1350 ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr); 1348 1351 if (ret) { 1349 - dev_printk(KERN_ERR, dev, "PCMCIA registration failed\n"); 1352 + dev_err(dev, "PCMCIA registration failed\n"); 1350 1353 pcmcia_put_socket(socket); 1351 1354 return ret; 1352 1355 } ··· 1357 1362 1358 1363 ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback); 1359 1364 if (ret) { 1360 - dev_printk(KERN_ERR, dev, "PCMCIA registration failed\n"); 1365 + dev_err(dev, "PCMCIA registration failed\n"); 1361 1366 pcmcia_put_socket(socket); 1362 1367 return ret; 1363 1368 }

+2 -2

drivers/pcmcia/pcmcia_cis.c

··· 44 44 45 45 buf = kmalloc(256, GFP_KERNEL); 46 46 if (buf == NULL) { 47 - dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n"); 47 + dev_warn(&s->dev, "no memory to read tuple\n"); 48 48 return -ENOMEM; 49 49 } 50 50 tuple.DesiredTuple = code; ··· 94 94 95 95 buf = kzalloc(256, GFP_KERNEL); 96 96 if (buf == NULL) { 97 - dev_printk(KERN_WARNING, &s->dev, "no memory to read tuple\n"); 97 + dev_warn(&s->dev, "no memory to read tuple\n"); 98 98 return -ENOMEM; 99 99 } 100 100

+4 -7

drivers/pcmcia/pcmcia_resource.c

··· 508 508 s->socket.Vpp = p_dev->vpp; 509 509 if (s->ops->set_socket(s, &s->socket)) { 510 510 mutex_unlock(&s->ops_mutex); 511 - dev_printk(KERN_WARNING, &p_dev->dev, 512 - "Unable to set socket state\n"); 511 + dev_warn(&p_dev->dev, "Unable to set socket state\n"); 513 512 return -EINVAL; 514 513 } 515 514 ··· 735 736 ret = request_irq(p_dev->irq, handler, 0, p_dev->devname, p_dev->priv); 736 737 if (ret) { 737 738 ret = pcmcia_request_irq(p_dev, handler); 738 - dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: " 739 - "request for exclusive IRQ could not be fulfilled.\n"); 740 - dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: the driver " 741 - "needs updating to supported shared IRQ lines.\n"); 739 + dev_warn(&p_dev->dev, "pcmcia: request for exclusive IRQ could not be fulfilled\n"); 740 + dev_warn(&p_dev->dev, "pcmcia: the driver needs updating to supported shared IRQ lines\n"); 742 741 } 743 742 if (ret) 744 - dev_printk(KERN_INFO, &p_dev->dev, "request_irq() failed\n"); 743 + dev_info(&p_dev->dev, "request_irq() failed\n"); 745 744 else 746 745 p_dev->_irq = 1; 747 746

+21 -23

drivers/pcmcia/rsrc_nonstatic.c

··· 191 191 int any; 192 192 u_char *b, hole, most; 193 193 194 - dev_printk(KERN_INFO, &s->dev, "cs: IO port probe %#x-%#x:", 195 - base, base+num-1); 194 + dev_info(&s->dev, "cs: IO port probe %#x-%#x:", base, base+num-1); 196 195 197 196 /* First, what does a floating port look like? */ 198 197 b = kzalloc(256, GFP_KERNEL); 199 198 if (!b) { 200 - printk("\n"); 201 - dev_printk(KERN_ERR, &s->dev, 202 - "do_io_probe: unable to kmalloc 256 bytes"); 199 + pr_cont("\n"); 200 + dev_err(&s->dev, "do_io_probe: unable to kmalloc 256 bytes\n"); 203 201 return; 204 202 } 205 203 for (i = base, most = 0; i < base+num; i += 8) { ··· 221 223 res = claim_region(s, i, 8, IORESOURCE_IO, "PCMCIA ioprobe"); 222 224 if (!res) { 223 225 if (!any) 224 - printk(" excluding"); 226 + pr_cont(" excluding"); 225 227 if (!bad) 226 228 bad = any = i; 227 229 continue; ··· 232 234 free_region(res); 233 235 if (j < 8) { 234 236 if (!any) 235 - printk(" excluding"); 237 + pr_cont(" excluding"); 236 238 if (!bad) 237 239 bad = any = i; 238 240 } else { 239 241 if (bad) { 240 242 sub_interval(&s_data->io_db, bad, i-bad); 241 - printk(" %#x-%#x", bad, i-1); 243 + pr_cont(" %#x-%#x", bad, i-1); 242 244 bad = 0; 243 245 } 244 246 } ··· 246 248 if (bad) { 247 249 if ((num > 16) && (bad == base) && (i == base+num)) { 248 250 sub_interval(&s_data->io_db, bad, i-bad); 249 - printk(" nothing: probe failed.\n"); 251 + pr_cont(" nothing: probe failed.\n"); 250 252 return; 251 253 } else { 252 254 sub_interval(&s_data->io_db, bad, i-bad); 253 - printk(" %#x-%#x", bad, i-1); 255 + pr_cont(" %#x-%#x", bad, i-1); 254 256 } 255 257 } 256 258 257 - printk(any ? "\n" : " clean.\n"); 259 + pr_cont("%s\n", !any ? " clean" : ""); 258 260 } 259 261 #endif 260 262 ··· 411 413 struct socket_data *s_data = s->resource_data; 412 414 u_long i, j, bad, fail, step; 413 415 414 - dev_printk(KERN_INFO, &s->dev, "cs: memory probe 0x%06lx-0x%06lx:", 415 - base, base+num-1); 416 + dev_info(&s->dev, "cs: memory probe 0x%06lx-0x%06lx:", 417 + base, base+num-1); 416 418 bad = fail = 0; 417 419 step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff); 418 420 /* don't allow too large steps */ ··· 436 438 } 437 439 if (i != j) { 438 440 if (!bad) 439 - printk(" excluding"); 440 - printk(" %#05lx-%#05lx", i, j-1); 441 + pr_cont(" excluding"); 442 + pr_cont(" %#05lx-%#05lx", i, j-1); 441 443 sub_interval(&s_data->mem_db, i, j-i); 442 444 bad += j-i; 443 445 } 444 446 } 445 - printk(bad ? "\n" : " clean.\n"); 447 + pr_cont("%s\n", !bad ? " clean" : ""); 446 448 return num - bad; 447 449 } 448 450 ··· 493 495 return 0; 494 496 if (s_data->mem_db_valid.next != &s_data->mem_db_valid) 495 497 return 0; 496 - dev_printk(KERN_NOTICE, &s->dev, 498 + dev_notice(&s->dev, 497 499 "cs: warning: no high memory space available!\n"); 498 500 return -ENODEV; 499 501 } ··· 973 975 if (res == &ioport_resource) 974 976 continue; 975 977 976 - dev_printk(KERN_INFO, &s->cb_dev->dev, 977 - "pcmcia: parent PCI bridge window: %pR\n", 978 - res); 978 + dev_info(&s->cb_dev->dev, 979 + "pcmcia: parent PCI bridge window: %pR\n", 980 + res); 979 981 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end)) 980 982 done |= IORESOURCE_IO; 981 983 ··· 988 990 if (res == &iomem_resource) 989 991 continue; 990 992 991 - dev_printk(KERN_INFO, &s->cb_dev->dev, 992 - "pcmcia: parent PCI bridge window: %pR\n", 993 - res); 993 + dev_info(&s->cb_dev->dev, 994 + "pcmcia: parent PCI bridge window: %pR\n", 995 + res); 994 996 if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end)) 995 997 done |= IORESOURCE_MEM; 996 998 }

+36 -42

drivers/pcmcia/ti113x.h

··· 372 372 373 373 mfunc = mfunc_old = config_readl(socket, TI122X_MFUNC); 374 374 devctl = config_readb(socket, TI113X_DEVICE_CONTROL); 375 - dev_printk(KERN_INFO, &socket->dev->dev, 376 - "TI: mfunc 0x%08x, devctl 0x%02x\n", mfunc, devctl); 375 + dev_info(&socket->dev->dev, "TI: mfunc 0x%08x, devctl 0x%02x\n", 376 + mfunc, devctl); 377 377 378 378 /* make sure PCI interrupts are enabled before probing */ 379 379 ti_init(socket); ··· 387 387 * We're here which means PCI interrupts are _not_ delivered. try to 388 388 * find the right setting (all serial or parallel) 389 389 */ 390 - dev_printk(KERN_INFO, &socket->dev->dev, 391 - "TI: probing PCI interrupt failed, trying to fix\n"); 390 + dev_info(&socket->dev->dev, 391 + "TI: probing PCI interrupt failed, trying to fix\n"); 392 392 393 393 /* for serial PCI make sure MFUNC3 is set to IRQSER */ 394 394 if ((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_ALL_SERIAL) { ··· 412 412 413 413 pci_irq_status = yenta_probe_cb_irq(socket); 414 414 if (pci_irq_status == 1) { 415 - dev_printk(KERN_INFO, &socket->dev->dev, 416 - "TI: all-serial interrupts ok\n"); 415 + dev_info(&socket->dev->dev, 416 + "TI: all-serial interrupts ok\n"); 417 417 mfunc_old = mfunc; 418 418 goto out; 419 419 } ··· 428 428 } 429 429 430 430 /* serial PCI interrupts not working fall back to parallel */ 431 - dev_printk(KERN_INFO, &socket->dev->dev, 432 - "TI: falling back to parallel PCI interrupts\n"); 431 + dev_info(&socket->dev->dev, 432 + "TI: falling back to parallel PCI interrupts\n"); 433 433 devctl &= ~TI113X_DCR_IMODE_MASK; 434 434 devctl |= TI113X_DCR_IMODE_SERIAL; /* serial ISA could be right */ 435 435 config_writeb(socket, TI113X_DEVICE_CONTROL, devctl); ··· 460 460 pci_irq_status = yenta_probe_cb_irq(socket); 461 461 if (pci_irq_status == 1) { 462 462 mfunc_old = mfunc; 463 - dev_printk(KERN_INFO, &socket->dev->dev, 464 - "TI: parallel PCI interrupts ok\n"); 463 + dev_info(&socket->dev->dev, "TI: parallel PCI interrupts ok\n"); 465 464 } else { 466 465 /* not working, back to old value */ 467 466 mfunc = mfunc_old; ··· 472 473 out: 473 474 if (pci_irq_status < 1) { 474 475 socket->cb_irq = 0; 475 - dev_printk(KERN_INFO, &socket->dev->dev, 476 - "Yenta TI: no PCI interrupts. Fish. " 477 - "Please report.\n"); 476 + dev_info(&socket->dev->dev, 477 + "Yenta TI: no PCI interrupts. Fish. Please report.\n"); 478 478 } 479 479 } 480 480 ··· 545 547 546 548 mfunc = mfunc_old = config_readl(socket, TI122X_MFUNC); 547 549 devctl = config_readb(socket, TI113X_DEVICE_CONTROL); 548 - dev_printk(KERN_INFO, &socket->dev->dev, 549 - "TI: mfunc 0x%08x, devctl 0x%02x\n", 550 - mfunc, devctl); 550 + dev_info(&socket->dev->dev, "TI: mfunc 0x%08x, devctl 0x%02x\n", 551 + mfunc, devctl); 551 552 552 553 /* if IRQs are configured as tied, align irq of func1 with func0 */ 553 554 sysctl = config_readl(socket, TI113X_SYSTEM_CONTROL); ··· 565 568 * We're here which means PCI interrupts are _not_ delivered. try to 566 569 * find the right setting 567 570 */ 568 - dev_printk(KERN_INFO, &socket->dev->dev, 569 - "TI: probing PCI interrupt failed, trying to fix\n"); 571 + dev_info(&socket->dev->dev, 572 + "TI: probing PCI interrupt failed, trying to fix\n"); 570 573 571 574 /* if all serial: set INTRTIE, probe again */ 572 575 if ((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_ALL_SERIAL) { ··· 575 578 if (ti12xx_tie_interrupts(socket, &old_irq)) { 576 579 pci_irq_status = yenta_probe_cb_irq(socket); 577 580 if (pci_irq_status == 1) { 578 - dev_printk(KERN_INFO, &socket->dev->dev, 579 - "TI: all-serial interrupts, tied ok\n"); 581 + dev_info(&socket->dev->dev, 582 + "TI: all-serial interrupts, tied ok\n"); 580 583 goto out; 581 584 } 582 585 ··· 613 616 614 617 pci_irq_status = yenta_probe_cb_irq(socket); 615 618 if (pci_irq_status == 1) { 616 - dev_printk(KERN_INFO, &socket->dev->dev, 617 - "TI: parallel PCI interrupts ok\n"); 619 + dev_info(&socket->dev->dev, 620 + "TI: parallel PCI interrupts ok\n"); 618 621 goto out; 619 622 } 620 623 ··· 629 632 if (ti12xx_tie_interrupts(socket, &old_irq)) { 630 633 pci_irq_status = yenta_probe_cb_irq(socket); 631 634 if (pci_irq_status == 1) { 632 - dev_printk(KERN_INFO, &socket->dev->dev, 633 - "TI: parallel PCI interrupts, tied ok\n"); 635 + dev_info(&socket->dev->dev, 636 + "TI: parallel PCI interrupts, tied ok\n"); 634 637 goto out; 635 638 } 636 639 ··· 641 644 out: 642 645 if (pci_irq_status < 1) { 643 646 socket->cb_irq = 0; 644 - dev_printk(KERN_INFO, &socket->dev->dev, 645 - "TI: no PCI interrupts. Fish. Please report.\n"); 647 + dev_info(&socket->dev->dev, 648 + "TI: no PCI interrupts. Fish. Please report.\n"); 646 649 } 647 650 } 648 651 ··· 846 849 /* make sure that memory burst is active */ 847 850 val_orig = val = config_readl(socket, TI113X_SYSTEM_CONTROL); 848 851 if (disable_clkrun && PCI_FUNC(socket->dev->devfn) == 0) { 849 - dev_printk(KERN_INFO, &socket->dev->dev, 850 - "Disabling CLKRUN feature\n"); 852 + dev_info(&socket->dev->dev, "Disabling CLKRUN feature\n"); 851 853 val |= TI113X_SCR_KEEPCLK; 852 854 } 853 855 if (!(val & TI122X_SCR_MRBURSTUP)) { 854 - dev_printk(KERN_INFO, &socket->dev->dev, 855 - "Enabling burst memory read transactions\n"); 856 + dev_info(&socket->dev->dev, 857 + "Enabling burst memory read transactions\n"); 856 858 val |= TI122X_SCR_MRBURSTUP; 857 859 } 858 860 if (val_orig != val) ··· 862 866 * CSC interrupts to PCI rather than INTVAL. 863 867 */ 864 868 val = config_readb(socket, TI1250_DIAGNOSTIC); 865 - dev_printk(KERN_INFO, &socket->dev->dev, 866 - "Using %s to route CSC interrupts to PCI\n", 867 - (val & TI1250_DIAG_PCI_CSC) ? "CSCINT" : "INTVAL"); 868 - dev_printk(KERN_INFO, &socket->dev->dev, 869 - "Routing CardBus interrupts to %s\n", 870 - (val & TI1250_DIAG_PCI_IREQ) ? "PCI" : "ISA"); 869 + dev_info(&socket->dev->dev, "Using %s to route CSC interrupts to PCI\n", 870 + (val & TI1250_DIAG_PCI_CSC) ? "CSCINT" : "INTVAL"); 871 + dev_info(&socket->dev->dev, "Routing CardBus interrupts to %s\n", 872 + (val & TI1250_DIAG_PCI_IREQ) ? "PCI" : "ISA"); 871 873 872 874 /* do irqrouting, depending on function */ 873 875 if (PCI_FUNC(socket->dev->devfn) == 0) ··· 890 896 diag |= TI1250_DIAG_PCI_CSC | TI1250_DIAG_PCI_IREQ; 891 897 892 898 if (diag != old) { 893 - dev_printk(KERN_INFO, &socket->dev->dev, 894 - "adjusting diagnostic: %02x -> %02x\n", 895 - old, diag); 899 + dev_info(&socket->dev->dev, 900 + "adjusting diagnostic: %02x -> %02x\n", 901 + old, diag); 896 902 config_writeb(socket, TI1250_DIAGNOSTIC, diag); 897 903 } 898 904 ··· 957 963 /* default to clear TLTEnable bit, old behaviour */ 958 964 test_c9 &= ~ENE_TEST_C9_TLTENABLE; 959 965 960 - dev_printk(KERN_INFO, &socket->dev->dev, 961 - "EnE: chaning testregister 0xC9, %02x -> %02x\n", 962 - old_c9, test_c9); 966 + dev_info(&socket->dev->dev, 967 + "EnE: changing testregister 0xC9, %02x -> %02x\n", 968 + old_c9, test_c9); 963 969 config_writeb(socket, ENE_TEST_C9, test_c9); 964 970 } 965 971

+28 -33

drivers/pcmcia/yenta_socket.c

··· 712 712 pcibios_bus_to_resource(dev->bus, res, &region); 713 713 if (pci_claim_resource(dev, PCI_BRIDGE_RESOURCES + nr) == 0) 714 714 return 0; 715 - dev_printk(KERN_INFO, &dev->dev, 716 - "Preassigned resource %d busy or not available, " 717 - "reconfiguring...\n", 718 - nr); 715 + dev_info(&dev->dev, 716 + "Preassigned resource %d busy or not available, reconfiguring...\n", 717 + nr); 719 718 } 720 719 721 720 if (type & IORESOURCE_IO) { ··· 737 738 return 1; 738 739 } 739 740 740 - dev_printk(KERN_INFO, &dev->dev, 741 - "no resource of type %x available, trying to continue...\n", 742 - type); 741 + dev_info(&dev->dev, 742 + "no resource of type %x available, trying to continue...\n", 743 + type); 743 744 res->start = res->end = res->flags = 0; 744 745 return 0; 745 746 } ··· 978 979 socket->probe_status = 0; 979 980 980 981 if (request_irq(socket->cb_irq, yenta_probe_handler, IRQF_SHARED, "yenta", socket)) { 981 - dev_printk(KERN_WARNING, &socket->dev->dev, 982 - "request_irq() in yenta_probe_cb_irq() failed!\n"); 982 + dev_warn(&socket->dev->dev, 983 + "request_irq() in yenta_probe_cb_irq() failed!\n"); 983 984 return -1; 984 985 } 985 986 ··· 1018 1019 else 1019 1020 socket->socket.irq_mask = 0; 1020 1021 1021 - dev_printk(KERN_INFO, &socket->dev->dev, 1022 - "ISA IRQ mask 0x%04x, PCI irq %d\n", 1023 - socket->socket.irq_mask, socket->cb_irq); 1022 + dev_info(&socket->dev->dev, "ISA IRQ mask 0x%04x, PCI irq %d\n", 1023 + socket->socket.irq_mask, socket->cb_irq); 1024 1024 } 1025 1025 1026 1026 /* ··· 1109 1111 1110 1112 /* Show that the wanted subordinate number is not possible: */ 1111 1113 if (cardbus_bridge->busn_res.end > upper_limit) 1112 - dev_printk(KERN_WARNING, &cardbus_bridge->dev, 1113 - "Upper limit for fixing this " 1114 - "bridge's parent bridge: #%02x\n", upper_limit); 1114 + dev_warn(&cardbus_bridge->dev, 1115 + "Upper limit for fixing this bridge's parent bridge: #%02x\n", 1116 + upper_limit); 1115 1117 1116 1118 /* If we have room to increase the bridge's subordinate number, */ 1117 1119 if (bridge_to_fix->busn_res.end < upper_limit) { ··· 1120 1122 unsigned char subordinate_to_assign = 1121 1123 min_t(int, cardbus_bridge->busn_res.end, upper_limit); 1122 1124 1123 - dev_printk(KERN_INFO, &bridge_to_fix->dev, 1124 - "Raising subordinate bus# of parent " 1125 - "bus (#%02x) from #%02x to #%02x\n", 1126 - bridge_to_fix->number, 1127 - (int)bridge_to_fix->busn_res.end, subordinate_to_assign); 1125 + dev_info(&bridge_to_fix->dev, 1126 + "Raising subordinate bus# of parent bus (#%02x) from #%02x to #%02x\n", 1127 + bridge_to_fix->number, 1128 + (int)bridge_to_fix->busn_res.end, 1129 + subordinate_to_assign); 1128 1130 1129 1131 /* Save the new subordinate in the bus struct of the bridge */ 1130 1132 bridge_to_fix->busn_res.end = subordinate_to_assign; ··· 1151 1153 * Bail out if so. 1152 1154 */ 1153 1155 if (!dev->subordinate) { 1154 - dev_printk(KERN_ERR, &dev->dev, "no bus associated! " 1155 - "(try 'pci=assign-busses')\n"); 1156 + dev_err(&dev->dev, "no bus associated! (try 'pci=assign-busses')\n"); 1156 1157 return -ENODEV; 1157 1158 } 1158 1159 ··· 1186 1189 goto disable; 1187 1190 1188 1191 if (!pci_resource_start(dev, 0)) { 1189 - dev_printk(KERN_ERR, &dev->dev, "No cardbus resource!\n"); 1192 + dev_err(&dev->dev, "No cardbus resource!\n"); 1190 1193 ret = -ENODEV; 1191 1194 goto release; 1192 1195 } ··· 1205 1208 * report the subsystem vendor and device for help debugging 1206 1209 * the irq stuff... 1207 1210 */ 1208 - dev_printk(KERN_INFO, &dev->dev, "CardBus bridge found [%04x:%04x]\n", 1209 - dev->subsystem_vendor, dev->subsystem_device); 1211 + dev_info(&dev->dev, "CardBus bridge found [%04x:%04x]\n", 1212 + dev->subsystem_vendor, dev->subsystem_device); 1210 1213 1211 1214 yenta_config_init(socket); 1212 1215 ··· 1236 1239 setup_timer(&socket->poll_timer, yenta_interrupt_wrapper, 1237 1240 (unsigned long)socket); 1238 1241 mod_timer(&socket->poll_timer, jiffies + HZ); 1239 - dev_printk(KERN_INFO, &dev->dev, 1240 - "no PCI IRQ, CardBus support disabled for this " 1241 - "socket.\n"); 1242 - dev_printk(KERN_INFO, &dev->dev, 1243 - "check your BIOS CardBus, BIOS IRQ or ACPI " 1244 - "settings.\n"); 1242 + dev_info(&dev->dev, 1243 + "no PCI IRQ, CardBus support disabled for this socket.\n"); 1244 + dev_info(&dev->dev, 1245 + "check your BIOS CardBus, BIOS IRQ or ACPI settings.\n"); 1245 1246 } else { 1246 1247 socket->socket.features |= SS_CAP_CARDBUS; 1247 1248 } ··· 1247 1252 /* Figure out what the dang thing can do for the PCMCIA layer... */ 1248 1253 yenta_interrogate(socket); 1249 1254 yenta_get_socket_capabilities(socket, isa_interrupts); 1250 - dev_printk(KERN_INFO, &dev->dev, 1251 - "Socket status: %08x\n", cb_readl(socket, CB_SOCKET_STATE)); 1255 + dev_info(&dev->dev, "Socket status: %08x\n", 1256 + cb_readl(socket, CB_SOCKET_STATE)); 1252 1257 1253 1258 yenta_fixup_parent_bridge(dev->subordinate); 1254 1259