ALSA: 6fire: Use standard printk helpers

+4 -4

sound/usb/6fire/chip.c

··· 106 106 } 107 107 if (regidx < 0) { 108 108 mutex_unlock(&register_mutex); 109 - snd_printk(KERN_ERR PREFIX "too many cards registered.\n"); 109 + dev_err(&intf->dev, "too many cards registered.\n"); 110 110 return -ENODEV; 111 111 } 112 112 devices[regidx] = device; ··· 121 121 122 122 /* if we are here, card can be registered in alsa. */ 123 123 if (usb_set_interface(device, 0, 0) != 0) { 124 - snd_printk(KERN_ERR PREFIX "can't set first interface.\n"); 124 + dev_err(&intf->dev, "can't set first interface.\n"); 125 125 return -EIO; 126 126 } 127 127 ret = snd_card_new(&intf->dev, index[regidx], id[regidx], 128 128 THIS_MODULE, sizeof(struct sfire_chip), &card); 129 129 if (ret < 0) { 130 - snd_printk(KERN_ERR PREFIX "cannot create alsa card.\n"); 130 + dev_err(&intf->dev, "cannot create alsa card.\n"); 131 131 return ret; 132 132 } 133 133 strcpy(card->driver, "6FireUSB"); ··· 168 168 169 169 ret = snd_card_register(card); 170 170 if (ret < 0) { 171 - snd_printk(KERN_ERR PREFIX "cannot register card."); 171 + dev_err(&intf->dev, "cannot register card."); 172 172 usb6fire_chip_destroy(chip); 173 173 return ret; 174 174 }

+2 -2

sound/usb/6fire/comm.c

··· 51 51 urb->status = 0; 52 52 urb->actual_length = 0; 53 53 if (usb_submit_urb(urb, GFP_ATOMIC) < 0) 54 - snd_printk(KERN_WARNING PREFIX 54 + dev_warn(&urb->dev->dev, 55 55 "comm data receiver aborted.\n"); 56 56 } 57 57 } ··· 179 179 if (ret < 0) { 180 180 kfree(rt->receiver_buffer); 181 181 kfree(rt); 182 - snd_printk(KERN_ERR PREFIX "cannot create comm data receiver."); 182 + dev_err(&chip->dev->dev, "cannot create comm data receiver."); 183 183 return ret; 184 184 } 185 185 chip->comm = rt;

+11 -7

sound/usb/6fire/control.c

··· 194 194 int changed = 0; 195 195 196 196 if (ch > 4) { 197 - snd_printk(KERN_ERR PREFIX "Invalid channel in volume control."); 197 + dev_err(&rt->chip->dev->dev, 198 + "Invalid channel in volume control."); 198 199 return -EINVAL; 199 200 } 200 201 ··· 223 222 unsigned int ch = kcontrol->private_value; 224 223 225 224 if (ch > 4) { 226 - snd_printk(KERN_ERR PREFIX "Invalid channel in volume control."); 225 + dev_err(&rt->chip->dev->dev, 226 + "Invalid channel in volume control."); 227 227 return -EINVAL; 228 228 } 229 229 ··· 242 240 u8 value = 0; 243 241 244 242 if (ch > 4) { 245 - snd_printk(KERN_ERR PREFIX "Invalid channel in volume control."); 243 + dev_err(&rt->chip->dev->dev, 244 + "Invalid channel in volume control."); 246 245 return -EINVAL; 247 246 } 248 247 ··· 268 265 u8 value = rt->output_mute >> ch; 269 266 270 267 if (ch > 4) { 271 - snd_printk(KERN_ERR PREFIX "Invalid channel in volume control."); 268 + dev_err(&rt->chip->dev->dev, 269 + "Invalid channel in volume control."); 272 270 return -EINVAL; 273 271 } 274 272 ··· 598 594 ret = usb6fire_control_add_virtual(rt, chip->card, 599 595 "Master Playback Volume", vol_elements); 600 596 if (ret) { 601 - snd_printk(KERN_ERR PREFIX "cannot add control.\n"); 597 + dev_err(&chip->dev->dev, "cannot add control.\n"); 602 598 kfree(rt); 603 599 return ret; 604 600 } 605 601 ret = usb6fire_control_add_virtual(rt, chip->card, 606 602 "Master Playback Switch", mute_elements); 607 603 if (ret) { 608 - snd_printk(KERN_ERR PREFIX "cannot add control.\n"); 604 + dev_err(&chip->dev->dev, "cannot add control.\n"); 609 605 kfree(rt); 610 606 return ret; 611 607 } ··· 615 611 ret = snd_ctl_add(chip->card, snd_ctl_new1(&elements[i], rt)); 616 612 if (ret < 0) { 617 613 kfree(rt); 618 - snd_printk(KERN_ERR PREFIX "cannot add control.\n"); 614 + dev_err(&chip->dev->dev, "cannot add control.\n"); 619 615 return ret; 620 616 } 621 617 i++;

+37 -33

sound/usb/6fire/firmware.c

··· 219 219 ret = request_firmware(&fw, fwname, &device->dev); 220 220 if (ret < 0) { 221 221 kfree(rec); 222 - snd_printk(KERN_ERR PREFIX "error requesting ezusb " 223 - "firmware %s.\n", fwname); 222 + dev_err(&intf->dev, 223 + "error requesting ezusb firmware %s.\n", fwname); 224 224 return ret; 225 225 } 226 226 ret = usb6fire_fw_ihex_init(fw, rec); 227 227 if (ret < 0) { 228 228 kfree(rec); 229 229 release_firmware(fw); 230 - snd_printk(KERN_ERR PREFIX "error validating ezusb " 231 - "firmware %s.\n", fwname); 230 + dev_err(&intf->dev, 231 + "error validating ezusb firmware %s.\n", fwname); 232 232 return ret; 233 233 } 234 234 /* upload firmware image */ ··· 237 237 if (ret < 0) { 238 238 kfree(rec); 239 239 release_firmware(fw); 240 - snd_printk(KERN_ERR PREFIX "unable to upload ezusb " 241 - "firmware %s: begin message.\n", fwname); 240 + dev_err(&intf->dev, 241 + "unable to upload ezusb firmware %s: begin message.\n", 242 + fwname); 242 243 return ret; 243 244 } 244 245 ··· 249 248 if (ret < 0) { 250 249 kfree(rec); 251 250 release_firmware(fw); 252 - snd_printk(KERN_ERR PREFIX "unable to upload ezusb " 253 - "firmware %s: data urb.\n", fwname); 251 + dev_err(&intf->dev, 252 + "unable to upload ezusb firmware %s: data urb.\n", 253 + fwname); 254 254 return ret; 255 255 } 256 256 } ··· 262 260 ret = usb6fire_fw_ezusb_write(device, 0xa0, postaddr, 263 261 postdata, postlen); 264 262 if (ret < 0) { 265 - snd_printk(KERN_ERR PREFIX "unable to upload ezusb " 266 - "firmware %s: post urb.\n", fwname); 263 + dev_err(&intf->dev, 264 + "unable to upload ezusb firmware %s: post urb.\n", 265 + fwname); 267 266 return ret; 268 267 } 269 268 } ··· 272 269 data = 0x00; /* resume ezusb cpu */ 273 270 ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1); 274 271 if (ret < 0) { 275 - snd_printk(KERN_ERR PREFIX "unable to upload ezusb " 276 - "firmware %s: end message.\n", fwname); 272 + dev_err(&intf->dev, 273 + "unable to upload ezusb firmware %s: end message.\n", 274 + fwname); 277 275 return ret; 278 276 } 279 277 return 0; ··· 296 292 297 293 ret = request_firmware(&fw, fwname, &device->dev); 298 294 if (ret < 0) { 299 - snd_printk(KERN_ERR PREFIX "unable to get fpga firmware %s.\n", 295 + dev_err(&intf->dev, "unable to get fpga firmware %s.\n", 300 296 fwname); 301 297 kfree(buffer); 302 298 return -EIO; ··· 309 305 if (ret < 0) { 310 306 kfree(buffer); 311 307 release_firmware(fw); 312 - snd_printk(KERN_ERR PREFIX "unable to upload fpga firmware: " 313 - "begin urb.\n"); 308 + dev_err(&intf->dev, 309 + "unable to upload fpga firmware: begin urb.\n"); 314 310 return ret; 315 311 } 316 312 ··· 322 318 if (ret < 0) { 323 319 release_firmware(fw); 324 320 kfree(buffer); 325 - snd_printk(KERN_ERR PREFIX "unable to upload fpga " 326 - "firmware: fw urb.\n"); 321 + dev_err(&intf->dev, 322 + "unable to upload fpga firmware: fw urb.\n"); 327 323 return ret; 328 324 } 329 325 } ··· 332 328 333 329 ret = usb6fire_fw_ezusb_write(device, 9, 0, NULL, 0); 334 330 if (ret < 0) { 335 - snd_printk(KERN_ERR PREFIX "unable to upload fpga firmware: " 336 - "end urb.\n"); 331 + dev_err(&intf->dev, 332 + "unable to upload fpga firmware: end urb.\n"); 337 333 return ret; 338 334 } 339 335 return 0; ··· 342 338 /* check, if the firmware version the devices has currently loaded 343 339 * is known by this driver. 'version' needs to have 4 bytes version 344 340 * info data. */ 345 - static int usb6fire_fw_check(u8 *version) 341 + static int usb6fire_fw_check(struct usb_interface *intf, const u8 *version) 346 342 { 347 343 int i; 348 344 ··· 350 346 if (!memcmp(version, known_fw_versions + i, 2)) 351 347 return 0; 352 348 353 - snd_printk(KERN_ERR PREFIX "invalid fimware version in device: %4ph. " 349 + dev_err(&intf->dev, "invalid fimware version in device: %4ph. " 354 350 "please reconnect to power. if this failure " 355 351 "still happens, check your firmware installation.", 356 352 version); ··· 368 364 369 365 ret = usb6fire_fw_ezusb_read(device, 1, 0, buffer, 8); 370 366 if (ret < 0) { 371 - snd_printk(KERN_ERR PREFIX "unable to receive device " 372 - "firmware state.\n"); 367 + dev_err(&intf->dev, 368 + "unable to receive device firmware state.\n"); 373 369 return ret; 374 370 } 375 371 if (buffer[0] != 0xeb || buffer[1] != 0xaa || buffer[2] != 0x55) { 376 - snd_printk(KERN_ERR PREFIX "unknown device firmware state " 377 - "received from device: "); 372 + dev_err(&intf->dev, 373 + "unknown device firmware state received from device:"); 378 374 for (i = 0; i < 8; i++) 379 - snd_printk("%02x ", buffer[i]); 380 - snd_printk("\n"); 375 + printk(KERN_CONT "%02x ", buffer[i]); 376 + printk(KERN_CONT "\n"); 381 377 return -EIO; 382 378 } 383 379 /* do we need fpga loader ezusb firmware? */ ··· 390 386 } 391 387 /* do we need fpga firmware and application ezusb firmware? */ 392 388 else if (buffer[3] == 0x02) { 393 - ret = usb6fire_fw_check(buffer + 4); 389 + ret = usb6fire_fw_check(intf, buffer + 4); 394 390 if (ret < 0) 395 391 return ret; 396 392 ret = usb6fire_fw_fpga_upload(intf, "6fire/dmx6firecf.bin"); ··· 406 402 } 407 403 /* all fw loaded? */ 408 404 else if (buffer[3] == 0x03) 409 - return usb6fire_fw_check(buffer + 4); 405 + return usb6fire_fw_check(intf, buffer + 4); 410 406 /* unknown data? */ 411 407 else { 412 - snd_printk(KERN_ERR PREFIX "unknown device firmware state " 413 - "received from device: "); 408 + dev_err(&intf->dev, 409 + "unknown device firmware state received from device: "); 414 410 for (i = 0; i < 8; i++) 415 - snd_printk("%02x ", buffer[i]); 416 - snd_printk("\n"); 411 + printk(KERN_CONT "%02x ", buffer[i]); 412 + printk(KERN_CONT "\n"); 417 413 return -EIO; 418 414 } 419 415 return 0;

+7 -5

sound/usb/6fire/midi.c

··· 41 41 42 42 ret = usb_submit_urb(urb, GFP_ATOMIC); 43 43 if (ret < 0) 44 - snd_printk(KERN_ERR PREFIX "midi out urb " 45 - "submit failed: %d\n", ret); 44 + dev_err(&urb->dev->dev, 45 + "midi out urb submit failed: %d\n", 46 + ret); 46 47 } else /* no more data to transmit */ 47 48 rt->out = NULL; 48 49 } ··· 95 94 96 95 ret = usb_submit_urb(urb, GFP_ATOMIC); 97 96 if (ret < 0) 98 - snd_printk(KERN_ERR PREFIX "midi out urb " 99 - "submit failed: %d\n", ret); 97 + dev_err(&urb->dev->dev, 98 + "midi out urb submit failed: %d\n", 99 + ret); 100 100 else 101 101 rt->out = alsa_sub; 102 102 } ··· 183 181 if (ret < 0) { 184 182 kfree(rt->out_buffer); 185 183 kfree(rt); 186 - snd_printk(KERN_ERR PREFIX "unable to create midi.\n"); 184 + dev_err(&chip->dev->dev, "unable to create midi.\n"); 187 185 return ret; 188 186 } 189 187 rt->instance->private_data = rt;

+25 -21

sound/usb/6fire/pcm.c

··· 79 79 ctrl_rt->usb_streaming = false; 80 80 ret = ctrl_rt->update_streaming(ctrl_rt); 81 81 if (ret < 0) { 82 - snd_printk(KERN_ERR PREFIX "error stopping streaming while " 83 - "setting samplerate %d.\n", rates[rt->rate]); 82 + dev_err(&rt->chip->dev->dev, 83 + "error stopping streaming while setting samplerate %d.\n", 84 + rates[rt->rate]); 84 85 return ret; 85 86 } 86 87 87 88 ret = ctrl_rt->set_rate(ctrl_rt, rt->rate); 88 89 if (ret < 0) { 89 - snd_printk(KERN_ERR PREFIX "error setting samplerate %d.\n", 90 - rates[rt->rate]); 90 + dev_err(&rt->chip->dev->dev, 91 + "error setting samplerate %d.\n", 92 + rates[rt->rate]); 91 93 return ret; 92 94 } 93 95 94 96 ret = ctrl_rt->set_channels(ctrl_rt, OUT_N_CHANNELS, IN_N_CHANNELS, 95 97 false, false); 96 98 if (ret < 0) { 97 - snd_printk(KERN_ERR PREFIX "error initializing channels " 98 - "while setting samplerate %d.\n", 99 - rates[rt->rate]); 99 + dev_err(&rt->chip->dev->dev, 100 + "error initializing channels while setting samplerate %d.\n", 101 + rates[rt->rate]); 100 102 return ret; 101 103 } 102 104 103 105 ctrl_rt->usb_streaming = true; 104 106 ret = ctrl_rt->update_streaming(ctrl_rt); 105 107 if (ret < 0) { 106 - snd_printk(KERN_ERR PREFIX "error starting streaming while " 107 - "setting samplerate %d.\n", rates[rt->rate]); 108 + dev_err(&rt->chip->dev->dev, 109 + "error starting streaming while setting samplerate %d.\n", 110 + rates[rt->rate]); 108 111 return ret; 109 112 } 110 113 ··· 127 124 return &rt->playback; 128 125 else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE) 129 126 return &rt->capture; 130 - snd_printk(KERN_ERR PREFIX "error getting pcm substream slot.\n"); 127 + dev_err(&rt->chip->dev->dev, "error getting pcm substream slot.\n"); 131 128 return NULL; 132 129 } 133 130 ··· 260 257 else if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE) 261 258 dest = (u32 *) (urb->buffer); 262 259 else { 263 - snd_printk(KERN_ERR PREFIX "Unknown sample format."); 260 + dev_err(&rt->chip->dev->dev, "Unknown sample format."); 264 261 return; 265 262 } 266 263 ··· 310 307 } 311 308 312 309 if (rt->stream_state == STREAM_DISABLED) { 313 - snd_printk(KERN_ERR PREFIX "internal error: " 314 - "stream disabled in in-urb handler.\n"); 310 + dev_err(&rt->chip->dev->dev, 311 + "internal error: stream disabled in in-urb handler.\n"); 315 312 return; 316 313 } 317 314 ··· 413 410 414 411 if (!sub) { 415 412 mutex_unlock(&rt->stream_mutex); 416 - snd_printk(KERN_ERR PREFIX "invalid stream type.\n"); 413 + dev_err(&rt->chip->dev->dev, "invalid stream type.\n"); 417 414 return -EINVAL; 418 415 } 419 416 ··· 484 481 break; 485 482 if (rt->rate == ARRAY_SIZE(rates)) { 486 483 mutex_unlock(&rt->stream_mutex); 487 - snd_printk("invalid rate %d in prepare.\n", 488 - alsa_rt->rate); 484 + dev_err(&rt->chip->dev->dev, 485 + "invalid rate %d in prepare.\n", 486 + alsa_rt->rate); 489 487 return -EINVAL; 490 488 } 491 489 ··· 498 494 ret = usb6fire_pcm_stream_start(rt); 499 495 if (ret) { 500 496 mutex_unlock(&rt->stream_mutex); 501 - snd_printk(KERN_ERR PREFIX 502 - "could not start pcm stream.\n"); 497 + dev_err(&rt->chip->dev->dev, 498 + "could not start pcm stream.\n"); 503 499 return ret; 504 500 } 505 501 } ··· 654 650 if (ret < 0) { 655 651 usb6fire_pcm_buffers_destroy(rt); 656 652 kfree(rt); 657 - snd_printk(KERN_ERR PREFIX "cannot create pcm instance.\n"); 653 + dev_err(&chip->dev->dev, "cannot create pcm instance.\n"); 658 654 return ret; 659 655 } 660 656 ··· 666 662 if (ret) { 667 663 usb6fire_pcm_buffers_destroy(rt); 668 664 kfree(rt); 669 - snd_printk(KERN_ERR PREFIX 670 - "error preallocating pcm buffers.\n"); 665 + dev_err(&chip->dev->dev, 666 + "error preallocating pcm buffers.\n"); 671 667 return ret; 672 668 } 673 669 rt->instance = pcm;