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

ALSA: sc6000: Use standard print API

Use the standard print API with dev_*() instead of the old house-baked
one. It gives better information and allows dynamically control of
debug prints.

Some functions are changed to receive a device pointer to be passed to
dev_*() calls.

Reviewed-by: Jaroslav Kysela <perex@perex.cz>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Link: https://patch.msgid.link/20240807133452.9424-34-tiwai@suse.de

Takashi Iwai e7c475b9 55c531bd

+90 -87
+90 -87
sound/isa/sc6000.c
··· 204 204 205 205 } 206 206 207 - static int sc6000_write(char __iomem *vport, int cmd) 207 + static int sc6000_write(struct device *devptr, char __iomem *vport, int cmd) 208 208 { 209 209 unsigned char val; 210 210 int loop = 500000; ··· 221 221 cpu_relax(); 222 222 } while (loop--); 223 223 224 - snd_printk(KERN_ERR "DSP Command (0x%x) timeout.\n", cmd); 224 + dev_err(devptr, "DSP Command (0x%x) timeout.\n", cmd); 225 225 226 226 return -EIO; 227 227 } 228 228 229 - static int sc6000_dsp_get_answer(char __iomem *vport, int command, 229 + static int sc6000_dsp_get_answer(struct device *devptr, 230 + char __iomem *vport, int command, 230 231 char *data, int data_len) 231 232 { 232 233 int len = 0; 233 234 234 - if (sc6000_write(vport, command)) { 235 - snd_printk(KERN_ERR "CMD 0x%x: failed!\n", command); 235 + if (sc6000_write(devptr, vport, command)) { 236 + dev_err(devptr, "CMD 0x%x: failed!\n", command); 236 237 return -EIO; 237 238 } 238 239 ··· 266 265 } 267 266 268 267 /* detection and initialization */ 269 - static int sc6000_hw_cfg_write(char __iomem *vport, const int *cfg) 268 + static int sc6000_hw_cfg_write(struct device *devptr, 269 + char __iomem *vport, const int *cfg) 270 270 { 271 - if (sc6000_write(vport, COMMAND_6C) < 0) { 272 - snd_printk(KERN_WARNING "CMD 0x%x: failed!\n", COMMAND_6C); 271 + if (sc6000_write(devptr, vport, COMMAND_6C) < 0) { 272 + dev_warn(devptr, "CMD 0x%x: failed!\n", COMMAND_6C); 273 273 return -EIO; 274 274 } 275 - if (sc6000_write(vport, COMMAND_5C) < 0) { 276 - snd_printk(KERN_ERR "CMD 0x%x: failed!\n", COMMAND_5C); 275 + if (sc6000_write(devptr, vport, COMMAND_5C) < 0) { 276 + dev_err(devptr, "CMD 0x%x: failed!\n", COMMAND_5C); 277 277 return -EIO; 278 278 } 279 - if (sc6000_write(vport, cfg[0]) < 0) { 280 - snd_printk(KERN_ERR "DATA 0x%x: failed!\n", cfg[0]); 279 + if (sc6000_write(devptr, vport, cfg[0]) < 0) { 280 + dev_err(devptr, "DATA 0x%x: failed!\n", cfg[0]); 281 281 return -EIO; 282 282 } 283 - if (sc6000_write(vport, cfg[1]) < 0) { 284 - snd_printk(KERN_ERR "DATA 0x%x: failed!\n", cfg[1]); 283 + if (sc6000_write(devptr, vport, cfg[1]) < 0) { 284 + dev_err(devptr, "DATA 0x%x: failed!\n", cfg[1]); 285 285 return -EIO; 286 286 } 287 - if (sc6000_write(vport, COMMAND_C5) < 0) { 288 - snd_printk(KERN_ERR "CMD 0x%x: failed!\n", COMMAND_C5); 287 + if (sc6000_write(devptr, vport, COMMAND_C5) < 0) { 288 + dev_err(devptr, "CMD 0x%x: failed!\n", COMMAND_C5); 289 289 return -EIO; 290 290 } 291 291 292 292 return 0; 293 293 } 294 294 295 - static int sc6000_cfg_write(char __iomem *vport, unsigned char softcfg) 295 + static int sc6000_cfg_write(struct device *devptr, 296 + char __iomem *vport, unsigned char softcfg) 296 297 { 297 298 298 - if (sc6000_write(vport, WRITE_MDIRQ_CFG)) { 299 - snd_printk(KERN_ERR "CMD 0x%x: failed!\n", WRITE_MDIRQ_CFG); 299 + if (sc6000_write(devptr, vport, WRITE_MDIRQ_CFG)) { 300 + dev_err(devptr, "CMD 0x%x: failed!\n", WRITE_MDIRQ_CFG); 300 301 return -EIO; 301 302 } 302 - if (sc6000_write(vport, softcfg)) { 303 - snd_printk(KERN_ERR "sc6000_cfg_write: failed!\n"); 303 + if (sc6000_write(devptr, vport, softcfg)) { 304 + dev_err(devptr, "%s: failed!\n", __func__); 304 305 return -EIO; 305 306 } 306 307 return 0; 307 308 } 308 309 309 - static int sc6000_setup_board(char __iomem *vport, int config) 310 + static int sc6000_setup_board(struct device *devptr, 311 + char __iomem *vport, int config) 310 312 { 311 313 int loop = 10; 312 314 313 315 do { 314 - if (sc6000_write(vport, COMMAND_88)) { 315 - snd_printk(KERN_ERR "CMD 0x%x: failed!\n", 316 - COMMAND_88); 316 + if (sc6000_write(devptr, vport, COMMAND_88)) { 317 + dev_err(devptr, "CMD 0x%x: failed!\n", 318 + COMMAND_88); 317 319 return -EIO; 318 320 } 319 321 } while ((sc6000_wait_data(vport) < 0) && loop--); 320 322 321 323 if (sc6000_read(vport) < 0) { 322 - snd_printk(KERN_ERR "sc6000_read after CMD 0x%x: failed\n", 323 - COMMAND_88); 324 + dev_err(devptr, "sc6000_read after CMD 0x%x: failed\n", 325 + COMMAND_88); 324 326 return -EIO; 325 327 } 326 328 327 - if (sc6000_cfg_write(vport, config)) 329 + if (sc6000_cfg_write(devptr, vport, config)) 328 330 return -ENODEV; 329 331 330 332 return 0; 331 333 } 332 334 333 - static int sc6000_init_mss(char __iomem *vport, int config, 335 + static int sc6000_init_mss(struct device *devptr, 336 + char __iomem *vport, int config, 334 337 char __iomem *vmss_port, int mss_config) 335 338 { 336 - if (sc6000_write(vport, DSP_INIT_MSS)) { 337 - snd_printk(KERN_ERR "sc6000_init_mss [0x%x]: failed!\n", 338 - DSP_INIT_MSS); 339 + if (sc6000_write(devptr, vport, DSP_INIT_MSS)) { 340 + dev_err(devptr, "%s [0x%x]: failed!\n", __func__, 341 + DSP_INIT_MSS); 339 342 return -EIO; 340 343 } 341 344 342 345 msleep(10); 343 346 344 - if (sc6000_cfg_write(vport, config)) 347 + if (sc6000_cfg_write(devptr, vport, config)) 345 348 return -EIO; 346 349 347 350 iowrite8(mss_config, vmss_port); ··· 353 348 return 0; 354 349 } 355 350 356 - static void sc6000_hw_cfg_encode(char __iomem *vport, int *cfg, 351 + static void sc6000_hw_cfg_encode(struct device *devptr, 352 + char __iomem *vport, int *cfg, 357 353 long xport, long xmpu, 358 354 long xmss_port, int joystick) 359 355 { ··· 373 367 cfg[0] |= 0x02; 374 368 cfg[1] |= 0x80; /* enable WSS system */ 375 369 cfg[1] &= ~0x40; /* disable IDE */ 376 - snd_printd("hw cfg %x, %x\n", cfg[0], cfg[1]); 370 + dev_dbg(devptr, "hw cfg %x, %x\n", cfg[0], cfg[1]); 377 371 } 378 372 379 - static int sc6000_init_board(char __iomem *vport, 373 + static int sc6000_init_board(struct device *devptr, 374 + char __iomem *vport, 380 375 char __iomem *vmss_port, int dev) 381 376 { 382 377 char answer[15]; ··· 391 384 392 385 err = sc6000_dsp_reset(vport); 393 386 if (err < 0) { 394 - snd_printk(KERN_ERR "sc6000_dsp_reset: failed!\n"); 387 + dev_err(devptr, "sc6000_dsp_reset: failed!\n"); 395 388 return err; 396 389 } 397 390 398 391 memset(answer, 0, sizeof(answer)); 399 - err = sc6000_dsp_get_answer(vport, GET_DSP_COPYRIGHT, answer, 15); 392 + err = sc6000_dsp_get_answer(devptr, vport, GET_DSP_COPYRIGHT, answer, 15); 400 393 if (err <= 0) { 401 - snd_printk(KERN_ERR "sc6000_dsp_copyright: failed!\n"); 394 + dev_err(devptr, "sc6000_dsp_copyright: failed!\n"); 402 395 return -ENODEV; 403 396 } 404 397 /* ··· 406 399 * if we have something different, we have to be warned. 407 400 */ 408 401 if (strncmp("SC-6000", answer, 7)) 409 - snd_printk(KERN_WARNING "Warning: non SC-6000 audio card!\n"); 402 + dev_warn(devptr, "Warning: non SC-6000 audio card!\n"); 410 403 411 - if (sc6000_dsp_get_answer(vport, GET_DSP_VERSION, version, 2) < 2) { 412 - snd_printk(KERN_ERR "sc6000_dsp_version: failed!\n"); 404 + if (sc6000_dsp_get_answer(devptr, vport, GET_DSP_VERSION, version, 2) < 2) { 405 + dev_err(devptr, "sc6000_dsp_version: failed!\n"); 413 406 return -ENODEV; 414 407 } 415 - printk(KERN_INFO PFX "Detected model: %s, DSP version %d.%d\n", 408 + dev_info(devptr, "Detected model: %s, DSP version %d.%d\n", 416 409 answer, version[0], version[1]); 417 410 418 411 /* set configuration */ 419 - sc6000_write(vport, COMMAND_5C); 412 + sc6000_write(devptr, vport, COMMAND_5C); 420 413 if (sc6000_read(vport) < 0) 421 414 old = 1; 422 415 423 416 if (!old) { 424 417 int cfg[2]; 425 - sc6000_hw_cfg_encode(vport, &cfg[0], port[dev], mpu_port[dev], 418 + sc6000_hw_cfg_encode(devptr, 419 + vport, &cfg[0], port[dev], mpu_port[dev], 426 420 mss_port[dev], joystick[dev]); 427 - if (sc6000_hw_cfg_write(vport, cfg) < 0) { 428 - snd_printk(KERN_ERR "sc6000_hw_cfg_write: failed!\n"); 421 + if (sc6000_hw_cfg_write(devptr, vport, cfg) < 0) { 422 + dev_err(devptr, "sc6000_hw_cfg_write: failed!\n"); 429 423 return -EIO; 430 424 } 431 425 } 432 - err = sc6000_setup_board(vport, config); 426 + err = sc6000_setup_board(devptr, vport, config); 433 427 if (err < 0) { 434 - snd_printk(KERN_ERR "sc6000_setup_board: failed!\n"); 428 + dev_err(devptr, "sc6000_setup_board: failed!\n"); 435 429 return -ENODEV; 436 430 } 437 431 438 432 sc6000_dsp_reset(vport); 439 433 440 434 if (!old) { 441 - sc6000_write(vport, COMMAND_60); 442 - sc6000_write(vport, 0x02); 435 + sc6000_write(devptr, vport, COMMAND_60); 436 + sc6000_write(devptr, vport, 0x02); 443 437 sc6000_dsp_reset(vport); 444 438 } 445 439 446 - err = sc6000_setup_board(vport, config); 440 + err = sc6000_setup_board(devptr, vport, config); 447 441 if (err < 0) { 448 - snd_printk(KERN_ERR "sc6000_setup_board: failed!\n"); 442 + dev_err(devptr, "sc6000_setup_board: failed!\n"); 449 443 return -ENODEV; 450 444 } 451 - err = sc6000_init_mss(vport, config, vmss_port, mss_config); 445 + err = sc6000_init_mss(devptr, vport, config, vmss_port, mss_config); 452 446 if (err < 0) { 453 - snd_printk(KERN_ERR "Cannot initialize " 454 - "Microsoft Sound System mode.\n"); 447 + dev_err(devptr, "Cannot initialize Microsoft Sound System mode.\n"); 455 448 return -ENODEV; 456 449 } 457 450 ··· 498 491 if (!enable[dev]) 499 492 return 0; 500 493 if (port[dev] == SNDRV_AUTO_PORT) { 501 - printk(KERN_ERR PFX "specify IO port\n"); 494 + dev_err(devptr, "specify IO port\n"); 502 495 return 0; 503 496 } 504 497 if (mss_port[dev] == SNDRV_AUTO_PORT) { 505 - printk(KERN_ERR PFX "specify MSS port\n"); 498 + dev_err(devptr, "specify MSS port\n"); 506 499 return 0; 507 500 } 508 501 if (port[dev] != 0x220 && port[dev] != 0x240) { 509 - printk(KERN_ERR PFX "Port must be 0x220 or 0x240\n"); 502 + dev_err(devptr, "Port must be 0x220 or 0x240\n"); 510 503 return 0; 511 504 } 512 505 if (mss_port[dev] != 0x530 && mss_port[dev] != 0xe80) { 513 - printk(KERN_ERR PFX "MSS port must be 0x530 or 0xe80\n"); 506 + dev_err(devptr, "MSS port must be 0x530 or 0xe80\n"); 514 507 return 0; 515 508 } 516 509 if (irq[dev] != SNDRV_AUTO_IRQ && !sc6000_irq_to_softcfg(irq[dev])) { 517 - printk(KERN_ERR PFX "invalid IRQ %d\n", irq[dev]); 510 + dev_err(devptr, "invalid IRQ %d\n", irq[dev]); 518 511 return 0; 519 512 } 520 513 if (dma[dev] != SNDRV_AUTO_DMA && !sc6000_dma_to_softcfg(dma[dev])) { 521 - printk(KERN_ERR PFX "invalid DMA %d\n", dma[dev]); 514 + dev_err(devptr, "invalid DMA %d\n", dma[dev]); 522 515 return 0; 523 516 } 524 517 if (mpu_port[dev] != SNDRV_AUTO_PORT && 525 518 (mpu_port[dev] & ~0x30L) != 0x300) { 526 - printk(KERN_ERR PFX "invalid MPU-401 port %lx\n", 519 + dev_err(devptr, "invalid MPU-401 port %lx\n", 527 520 mpu_port[dev]); 528 521 return 0; 529 522 } 530 523 if (mpu_port[dev] != SNDRV_AUTO_PORT && 531 524 mpu_irq[dev] != SNDRV_AUTO_IRQ && mpu_irq[dev] != 0 && 532 525 !sc6000_mpu_irq_to_softcfg(mpu_irq[dev])) { 533 - printk(KERN_ERR PFX "invalid MPU-401 IRQ %d\n", mpu_irq[dev]); 526 + dev_err(devptr, "invalid MPU-401 IRQ %d\n", mpu_irq[dev]); 534 527 return 0; 535 528 } 536 529 return 1; ··· 541 534 char __iomem *vport = (char __force __iomem *)card->private_data; 542 535 543 536 if (vport) 544 - sc6000_setup_board(vport, 0); 537 + sc6000_setup_board(card->dev, vport, 0); 545 538 } 546 539 547 540 static int __snd_sc6000_probe(struct device *devptr, unsigned int dev) ··· 565 558 if (xirq == SNDRV_AUTO_IRQ) { 566 559 xirq = snd_legacy_find_free_irq(possible_irqs); 567 560 if (xirq < 0) { 568 - snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); 561 + dev_err(devptr, "unable to find a free IRQ\n"); 569 562 return -EBUSY; 570 563 } 571 564 } ··· 573 566 if (xdma == SNDRV_AUTO_DMA) { 574 567 xdma = snd_legacy_find_free_dma(possible_dmas); 575 568 if (xdma < 0) { 576 - snd_printk(KERN_ERR PFX "unable to find a free DMA\n"); 569 + dev_err(devptr, "unable to find a free DMA\n"); 577 570 return -EBUSY; 578 571 } 579 572 } 580 573 581 574 if (!devm_request_region(devptr, port[dev], 0x10, DRV_NAME)) { 582 - snd_printk(KERN_ERR PFX 583 - "I/O port region is already in use.\n"); 575 + dev_err(devptr, "I/O port region is already in use.\n"); 584 576 return -EBUSY; 585 577 } 586 578 vport = devm_ioport_map(devptr, port[dev], 0x10); 587 579 if (!vport) { 588 - snd_printk(KERN_ERR PFX 589 - "I/O port cannot be iomapped.\n"); 580 + dev_err(devptr, "I/O port cannot be iomapped.\n"); 590 581 return -EBUSY; 591 582 } 592 583 card->private_data = (void __force *)vport; 593 584 594 585 /* to make it marked as used */ 595 586 if (!devm_request_region(devptr, mss_port[dev], 4, DRV_NAME)) { 596 - snd_printk(KERN_ERR PFX 597 - "SC-6000 port I/O port region is already in use.\n"); 587 + dev_err(devptr, 588 + "SC-6000 port I/O port region is already in use.\n"); 598 589 return -EBUSY; 599 590 } 600 591 vmss_port = devm_ioport_map(devptr, mss_port[dev], 4); 601 592 if (!vmss_port) { 602 - snd_printk(KERN_ERR PFX 603 - "MSS port I/O cannot be iomapped.\n"); 593 + dev_err(devptr, "MSS port I/O cannot be iomapped.\n"); 604 594 return -EBUSY; 605 595 } 606 596 607 - snd_printd("Initializing BASE[0x%lx] IRQ[%d] DMA[%d] MIRQ[%d]\n", 608 - port[dev], xirq, xdma, 609 - mpu_irq[dev] == SNDRV_AUTO_IRQ ? 0 : mpu_irq[dev]); 597 + dev_dbg(devptr, "Initializing BASE[0x%lx] IRQ[%d] DMA[%d] MIRQ[%d]\n", 598 + port[dev], xirq, xdma, 599 + mpu_irq[dev] == SNDRV_AUTO_IRQ ? 0 : mpu_irq[dev]); 610 600 611 - err = sc6000_init_board(vport, vmss_port, dev); 601 + err = sc6000_init_board(devptr, vport, vmss_port, dev); 612 602 if (err < 0) 613 603 return err; 614 604 card->private_free = snd_sc6000_free; ··· 617 613 618 614 err = snd_wss_pcm(chip, 0); 619 615 if (err < 0) { 620 - snd_printk(KERN_ERR PFX 621 - "error creating new WSS PCM device\n"); 616 + dev_err(devptr, "error creating new WSS PCM device\n"); 622 617 return err; 623 618 } 624 619 err = snd_wss_mixer(chip); 625 620 if (err < 0) { 626 - snd_printk(KERN_ERR PFX "error creating new WSS mixer\n"); 621 + dev_err(devptr, "error creating new WSS mixer\n"); 627 622 return err; 628 623 } 629 624 err = snd_sc6000_mixer(chip); 630 625 if (err < 0) { 631 - snd_printk(KERN_ERR PFX "the mixer rewrite failed\n"); 626 + dev_err(devptr, "the mixer rewrite failed\n"); 632 627 return err; 633 628 } 634 629 if (snd_opl3_create(card, 635 630 0x388, 0x388 + 2, 636 631 OPL3_HW_AUTO, 0, &opl3) < 0) { 637 - snd_printk(KERN_ERR PFX "no OPL device at 0x%x-0x%x ?\n", 638 - 0x388, 0x388 + 2); 632 + dev_err(devptr, "no OPL device at 0x%x-0x%x ?\n", 633 + 0x388, 0x388 + 2); 639 634 } else { 640 635 err = snd_opl3_hwdep_new(opl3, 0, 1, NULL); 641 636 if (err < 0) ··· 648 645 MPU401_HW_MPU401, 649 646 mpu_port[dev], 0, 650 647 mpu_irq[dev], NULL) < 0) 651 - snd_printk(KERN_ERR "no MPU-401 device at 0x%lx ?\n", 652 - mpu_port[dev]); 648 + dev_err(devptr, "no MPU-401 device at 0x%lx ?\n", 649 + mpu_port[dev]); 653 650 } 654 651 655 652 strcpy(card->driver, DRV_NAME);