1/* 2 * OXFW970-based speakers driver 3 * 4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de> 5 * Licensed under the terms of the GNU General Public License, version 2. 6 */ 7 8#include <linux/device.h> 9#include <linux/firewire.h> 10#include <linux/firewire-constants.h> 11#include <linux/module.h> 12#include <linux/mod_devicetable.h> 13#include <linux/mutex.h> 14#include <linux/slab.h> 15#include <sound/control.h> 16#include <sound/core.h> 17#include <sound/initval.h> 18#include <sound/pcm.h> 19#include <sound/pcm_params.h> 20#include "cmp.h" 21#include "fcp.h" 22#include "amdtp.h" 23#include "lib.h" 24 25#define OXFORD_FIRMWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x50000) 26/* 0x970?vvvv or 0x971?vvvv, where vvvv = firmware version */ 27 28#define OXFORD_HARDWARE_ID_ADDRESS (CSR_REGISTER_BASE + 0x90020) 29#define OXFORD_HARDWARE_ID_OXFW970 0x39443841 30#define OXFORD_HARDWARE_ID_OXFW971 0x39373100 31 32#define VENDOR_GRIFFIN 0x001292 33#define VENDOR_LACIE 0x00d04b 34 35#define SPECIFIER_1394TA 0x00a02d 36#define VERSION_AVC 0x010001 37 38struct device_info { 39 const char *driver_name; 40 const char *short_name; 41 const char *long_name; 42 int (*pcm_constraints)(struct snd_pcm_runtime *runtime); 43 unsigned int mixer_channels; 44 u8 mute_fb_id; 45 u8 volume_fb_id; 46}; 47 48struct fwspk { 49 struct snd_card *card; 50 struct fw_unit *unit; 51 const struct device_info *device_info; 52 struct snd_pcm_substream *pcm; 53 struct mutex mutex; 54 struct cmp_connection connection; 55 struct amdtp_out_stream stream; 56 bool stream_running; 57 bool mute; 58 s16 volume[6]; 59 s16 volume_min; 60 s16 volume_max; 61}; 62 63MODULE_DESCRIPTION("FireWire speakers driver"); 64MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); 65MODULE_LICENSE("GPL v2"); 66 67static int firewave_rate_constraint(struct snd_pcm_hw_params *params, 68 struct snd_pcm_hw_rule *rule) 69{ 70 static unsigned int stereo_rates[] = { 48000, 96000 }; 71 struct snd_interval *channels = 72 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 73 struct snd_interval *rate = 74 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 75 76 /* two channels work only at 48/96 kHz */ 77 if (snd_interval_max(channels) < 6) 78 return snd_interval_list(rate, 2, stereo_rates, 0); 79 return 0; 80} 81 82static int firewave_channels_constraint(struct snd_pcm_hw_params *params, 83 struct snd_pcm_hw_rule *rule) 84{ 85 static const struct snd_interval all_channels = { .min = 6, .max = 6 }; 86 struct snd_interval *rate = 87 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 88 struct snd_interval *channels = 89 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 90 91 /* 32/44.1 kHz work only with all six channels */ 92 if (snd_interval_max(rate) < 48000) 93 return snd_interval_refine(channels, &all_channels); 94 return 0; 95} 96 97static int firewave_constraints(struct snd_pcm_runtime *runtime) 98{ 99 static unsigned int channels_list[] = { 2, 6 }; 100 static struct snd_pcm_hw_constraint_list channels_list_constraint = { 101 .count = 2, 102 .list = channels_list, 103 }; 104 int err; 105 106 runtime->hw.rates = SNDRV_PCM_RATE_32000 | 107 SNDRV_PCM_RATE_44100 | 108 SNDRV_PCM_RATE_48000 | 109 SNDRV_PCM_RATE_96000; 110 runtime->hw.channels_max = 6; 111 112 err = snd_pcm_hw_constraint_list(runtime, 0, 113 SNDRV_PCM_HW_PARAM_CHANNELS, 114 &channels_list_constraint); 115 if (err < 0) 116 return err; 117 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 118 firewave_rate_constraint, NULL, 119 SNDRV_PCM_HW_PARAM_CHANNELS, -1); 120 if (err < 0) 121 return err; 122 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 123 firewave_channels_constraint, NULL, 124 SNDRV_PCM_HW_PARAM_RATE, -1); 125 if (err < 0) 126 return err; 127 128 return 0; 129} 130 131static int lacie_speakers_constraints(struct snd_pcm_runtime *runtime) 132{ 133 runtime->hw.rates = SNDRV_PCM_RATE_32000 | 134 SNDRV_PCM_RATE_44100 | 135 SNDRV_PCM_RATE_48000 | 136 SNDRV_PCM_RATE_88200 | 137 SNDRV_PCM_RATE_96000; 138 139 return 0; 140} 141 142static int fwspk_open(struct snd_pcm_substream *substream) 143{ 144 static const struct snd_pcm_hardware hardware = { 145 .info = SNDRV_PCM_INFO_MMAP | 146 SNDRV_PCM_INFO_MMAP_VALID | 147 SNDRV_PCM_INFO_BATCH | 148 SNDRV_PCM_INFO_INTERLEAVED | 149 SNDRV_PCM_INFO_BLOCK_TRANSFER, 150 .formats = AMDTP_OUT_PCM_FORMAT_BITS, 151 .channels_min = 2, 152 .channels_max = 2, 153 .buffer_bytes_max = 4 * 1024 * 1024, 154 .period_bytes_min = 1, 155 .period_bytes_max = UINT_MAX, 156 .periods_min = 1, 157 .periods_max = UINT_MAX, 158 }; 159 struct fwspk *fwspk = substream->private_data; 160 struct snd_pcm_runtime *runtime = substream->runtime; 161 int err; 162 163 runtime->hw = hardware; 164 165 err = fwspk->device_info->pcm_constraints(runtime); 166 if (err < 0) 167 return err; 168 err = snd_pcm_limit_hw_rates(runtime); 169 if (err < 0) 170 return err; 171 172 err = snd_pcm_hw_constraint_minmax(runtime, 173 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 174 5000, 8192000); 175 if (err < 0) 176 return err; 177 178 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); 179 if (err < 0) 180 return err; 181 182 return 0; 183} 184 185static int fwspk_close(struct snd_pcm_substream *substream) 186{ 187 return 0; 188} 189 190static void fwspk_stop_stream(struct fwspk *fwspk) 191{ 192 if (fwspk->stream_running) { 193 amdtp_out_stream_stop(&fwspk->stream); 194 cmp_connection_break(&fwspk->connection); 195 fwspk->stream_running = false; 196 } 197} 198 199static int fwspk_set_rate(struct fwspk *fwspk, unsigned int sfc) 200{ 201 u8 *buf; 202 int err; 203 204 buf = kmalloc(8, GFP_KERNEL); 205 if (!buf) 206 return -ENOMEM; 207 208 buf[0] = 0x00; /* AV/C, CONTROL */ 209 buf[1] = 0xff; /* unit */ 210 buf[2] = 0x19; /* INPUT PLUG SIGNAL FORMAT */ 211 buf[3] = 0x00; /* plug 0 */ 212 buf[4] = 0x90; /* format: audio */ 213 buf[5] = 0x00 | sfc; /* AM824, frequency */ 214 buf[6] = 0xff; /* SYT (not used) */ 215 buf[7] = 0xff; 216 217 err = fcp_avc_transaction(fwspk->unit, buf, 8, buf, 8, 218 BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(5)); 219 if (err < 0) 220 goto error; 221 if (err < 6 || buf[0] != 0x09 /* ACCEPTED */) { 222 dev_err(&fwspk->unit->device, "failed to set sample rate\n"); 223 err = -EIO; 224 goto error; 225 } 226 227 err = 0; 228 229error: 230 kfree(buf); 231 232 return err; 233} 234 235static int fwspk_hw_params(struct snd_pcm_substream *substream, 236 struct snd_pcm_hw_params *hw_params) 237{ 238 struct fwspk *fwspk = substream->private_data; 239 int err; 240 241 mutex_lock(&fwspk->mutex); 242 fwspk_stop_stream(fwspk); 243 mutex_unlock(&fwspk->mutex); 244 245 err = snd_pcm_lib_alloc_vmalloc_buffer(substream, 246 params_buffer_bytes(hw_params)); 247 if (err < 0) 248 goto error; 249 250 amdtp_out_stream_set_rate(&fwspk->stream, params_rate(hw_params)); 251 amdtp_out_stream_set_pcm(&fwspk->stream, params_channels(hw_params)); 252 253 amdtp_out_stream_set_pcm_format(&fwspk->stream, 254 params_format(hw_params)); 255 256 err = fwspk_set_rate(fwspk, fwspk->stream.sfc); 257 if (err < 0) 258 goto err_buffer; 259 260 return 0; 261 262err_buffer: 263 snd_pcm_lib_free_vmalloc_buffer(substream); 264error: 265 return err; 266} 267 268static int fwspk_hw_free(struct snd_pcm_substream *substream) 269{ 270 struct fwspk *fwspk = substream->private_data; 271 272 mutex_lock(&fwspk->mutex); 273 fwspk_stop_stream(fwspk); 274 mutex_unlock(&fwspk->mutex); 275 276 return snd_pcm_lib_free_vmalloc_buffer(substream); 277} 278 279static int fwspk_prepare(struct snd_pcm_substream *substream) 280{ 281 struct fwspk *fwspk = substream->private_data; 282 int err; 283 284 mutex_lock(&fwspk->mutex); 285 286 if (amdtp_out_streaming_error(&fwspk->stream)) 287 fwspk_stop_stream(fwspk); 288 289 if (!fwspk->stream_running) { 290 err = cmp_connection_establish(&fwspk->connection, 291 amdtp_out_stream_get_max_payload(&fwspk->stream)); 292 if (err < 0) 293 goto err_mutex; 294 295 err = amdtp_out_stream_start(&fwspk->stream, 296 fwspk->connection.resources.channel, 297 fwspk->connection.speed); 298 if (err < 0) 299 goto err_connection; 300 301 fwspk->stream_running = true; 302 } 303 304 mutex_unlock(&fwspk->mutex); 305 306 amdtp_out_stream_pcm_prepare(&fwspk->stream); 307 308 return 0; 309 310err_connection: 311 cmp_connection_break(&fwspk->connection); 312err_mutex: 313 mutex_unlock(&fwspk->mutex); 314 315 return err; 316} 317 318static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd) 319{ 320 struct fwspk *fwspk = substream->private_data; 321 struct snd_pcm_substream *pcm; 322 323 switch (cmd) { 324 case SNDRV_PCM_TRIGGER_START: 325 pcm = substream; 326 break; 327 case SNDRV_PCM_TRIGGER_STOP: 328 pcm = NULL; 329 break; 330 default: 331 return -EINVAL; 332 } 333 amdtp_out_stream_pcm_trigger(&fwspk->stream, pcm); 334 return 0; 335} 336 337static snd_pcm_uframes_t fwspk_pointer(struct snd_pcm_substream *substream) 338{ 339 struct fwspk *fwspk = substream->private_data; 340 341 return amdtp_out_stream_pcm_pointer(&fwspk->stream); 342} 343 344static int fwspk_create_pcm(struct fwspk *fwspk) 345{ 346 static struct snd_pcm_ops ops = { 347 .open = fwspk_open, 348 .close = fwspk_close, 349 .ioctl = snd_pcm_lib_ioctl, 350 .hw_params = fwspk_hw_params, 351 .hw_free = fwspk_hw_free, 352 .prepare = fwspk_prepare, 353 .trigger = fwspk_trigger, 354 .pointer = fwspk_pointer, 355 .page = snd_pcm_lib_get_vmalloc_page, 356 .mmap = snd_pcm_lib_mmap_vmalloc, 357 }; 358 struct snd_pcm *pcm; 359 int err; 360 361 err = snd_pcm_new(fwspk->card, "OXFW970", 0, 1, 0, &pcm); 362 if (err < 0) 363 return err; 364 pcm->private_data = fwspk; 365 strcpy(pcm->name, fwspk->device_info->short_name); 366 fwspk->pcm = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; 367 fwspk->pcm->ops = &ops; 368 return 0; 369} 370 371enum control_action { CTL_READ, CTL_WRITE }; 372enum control_attribute { 373 CTL_MIN = 0x02, 374 CTL_MAX = 0x03, 375 CTL_CURRENT = 0x10, 376}; 377 378static int fwspk_mute_command(struct fwspk *fwspk, bool *value, 379 enum control_action action) 380{ 381 u8 *buf; 382 u8 response_ok; 383 int err; 384 385 buf = kmalloc(11, GFP_KERNEL); 386 if (!buf) 387 return -ENOMEM; 388 389 if (action == CTL_READ) { 390 buf[0] = 0x01; /* AV/C, STATUS */ 391 response_ok = 0x0c; /* STABLE */ 392 } else { 393 buf[0] = 0x00; /* AV/C, CONTROL */ 394 response_ok = 0x09; /* ACCEPTED */ 395 } 396 buf[1] = 0x08; /* audio unit 0 */ 397 buf[2] = 0xb8; /* FUNCTION BLOCK */ 398 buf[3] = 0x81; /* function block type: feature */ 399 buf[4] = fwspk->device_info->mute_fb_id; /* function block ID */ 400 buf[5] = 0x10; /* control attribute: current */ 401 buf[6] = 0x02; /* selector length */ 402 buf[7] = 0x00; /* audio channel number */ 403 buf[8] = 0x01; /* control selector: mute */ 404 buf[9] = 0x01; /* control data length */ 405 if (action == CTL_READ) 406 buf[10] = 0xff; 407 else 408 buf[10] = *value ? 0x70 : 0x60; 409 410 err = fcp_avc_transaction(fwspk->unit, buf, 11, buf, 11, 0x3fe); 411 if (err < 0) 412 goto error; 413 if (err < 11) { 414 dev_err(&fwspk->unit->device, "short FCP response\n"); 415 err = -EIO; 416 goto error; 417 } 418 if (buf[0] != response_ok) { 419 dev_err(&fwspk->unit->device, "mute command failed\n"); 420 err = -EIO; 421 goto error; 422 } 423 if (action == CTL_READ) 424 *value = buf[10] == 0x70; 425 426 err = 0; 427 428error: 429 kfree(buf); 430 431 return err; 432} 433 434static int fwspk_volume_command(struct fwspk *fwspk, s16 *value, 435 unsigned int channel, 436 enum control_attribute attribute, 437 enum control_action action) 438{ 439 u8 *buf; 440 u8 response_ok; 441 int err; 442 443 buf = kmalloc(12, GFP_KERNEL); 444 if (!buf) 445 return -ENOMEM; 446 447 if (action == CTL_READ) { 448 buf[0] = 0x01; /* AV/C, STATUS */ 449 response_ok = 0x0c; /* STABLE */ 450 } else { 451 buf[0] = 0x00; /* AV/C, CONTROL */ 452 response_ok = 0x09; /* ACCEPTED */ 453 } 454 buf[1] = 0x08; /* audio unit 0 */ 455 buf[2] = 0xb8; /* FUNCTION BLOCK */ 456 buf[3] = 0x81; /* function block type: feature */ 457 buf[4] = fwspk->device_info->volume_fb_id; /* function block ID */ 458 buf[5] = attribute; /* control attribute */ 459 buf[6] = 0x02; /* selector length */ 460 buf[7] = channel; /* audio channel number */ 461 buf[8] = 0x02; /* control selector: volume */ 462 buf[9] = 0x02; /* control data length */ 463 if (action == CTL_READ) { 464 buf[10] = 0xff; 465 buf[11] = 0xff; 466 } else { 467 buf[10] = *value >> 8; 468 buf[11] = *value; 469 } 470 471 err = fcp_avc_transaction(fwspk->unit, buf, 12, buf, 12, 0x3fe); 472 if (err < 0) 473 goto error; 474 if (err < 12) { 475 dev_err(&fwspk->unit->device, "short FCP response\n"); 476 err = -EIO; 477 goto error; 478 } 479 if (buf[0] != response_ok) { 480 dev_err(&fwspk->unit->device, "volume command failed\n"); 481 err = -EIO; 482 goto error; 483 } 484 if (action == CTL_READ) 485 *value = (buf[10] << 8) | buf[11]; 486 487 err = 0; 488 489error: 490 kfree(buf); 491 492 return err; 493} 494 495static int fwspk_mute_get(struct snd_kcontrol *control, 496 struct snd_ctl_elem_value *value) 497{ 498 struct fwspk *fwspk = control->private_data; 499 500 value->value.integer.value[0] = !fwspk->mute; 501 502 return 0; 503} 504 505static int fwspk_mute_put(struct snd_kcontrol *control, 506 struct snd_ctl_elem_value *value) 507{ 508 struct fwspk *fwspk = control->private_data; 509 bool mute; 510 int err; 511 512 mute = !value->value.integer.value[0]; 513 514 if (mute == fwspk->mute) 515 return 0; 516 517 err = fwspk_mute_command(fwspk, &mute, CTL_WRITE); 518 if (err < 0) 519 return err; 520 fwspk->mute = mute; 521 522 return 1; 523} 524 525static int fwspk_volume_info(struct snd_kcontrol *control, 526 struct snd_ctl_elem_info *info) 527{ 528 struct fwspk *fwspk = control->private_data; 529 530 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 531 info->count = fwspk->device_info->mixer_channels; 532 info->value.integer.min = fwspk->volume_min; 533 info->value.integer.max = fwspk->volume_max; 534 535 return 0; 536} 537 538static const u8 channel_map[6] = { 0, 1, 4, 5, 2, 3 }; 539 540static int fwspk_volume_get(struct snd_kcontrol *control, 541 struct snd_ctl_elem_value *value) 542{ 543 struct fwspk *fwspk = control->private_data; 544 unsigned int i; 545 546 for (i = 0; i < fwspk->device_info->mixer_channels; ++i) 547 value->value.integer.value[channel_map[i]] = fwspk->volume[i]; 548 549 return 0; 550} 551 552static int fwspk_volume_put(struct snd_kcontrol *control, 553 struct snd_ctl_elem_value *value) 554{ 555 struct fwspk *fwspk = control->private_data; 556 unsigned int i, changed_channels; 557 bool equal_values = true; 558 s16 volume; 559 int err; 560 561 for (i = 0; i < fwspk->device_info->mixer_channels; ++i) { 562 if (value->value.integer.value[i] < fwspk->volume_min || 563 value->value.integer.value[i] > fwspk->volume_max) 564 return -EINVAL; 565 if (value->value.integer.value[i] != 566 value->value.integer.value[0]) 567 equal_values = false; 568 } 569 570 changed_channels = 0; 571 for (i = 0; i < fwspk->device_info->mixer_channels; ++i) 572 if (value->value.integer.value[channel_map[i]] != 573 fwspk->volume[i]) 574 changed_channels |= 1 << (i + 1); 575 576 if (equal_values && changed_channels != 0) 577 changed_channels = 1 << 0; 578 579 for (i = 0; i <= fwspk->device_info->mixer_channels; ++i) { 580 volume = value->value.integer.value[channel_map[i ? i - 1 : 0]]; 581 if (changed_channels & (1 << i)) { 582 err = fwspk_volume_command(fwspk, &volume, i, 583 CTL_CURRENT, CTL_WRITE); 584 if (err < 0) 585 return err; 586 } 587 if (i > 0) 588 fwspk->volume[i - 1] = volume; 589 } 590 591 return changed_channels != 0; 592} 593 594static int fwspk_create_mixer(struct fwspk *fwspk) 595{ 596 static const struct snd_kcontrol_new controls[] = { 597 { 598 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 599 .name = "PCM Playback Switch", 600 .info = snd_ctl_boolean_mono_info, 601 .get = fwspk_mute_get, 602 .put = fwspk_mute_put, 603 }, 604 { 605 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 606 .name = "PCM Playback Volume", 607 .info = fwspk_volume_info, 608 .get = fwspk_volume_get, 609 .put = fwspk_volume_put, 610 }, 611 }; 612 unsigned int i, first_ch; 613 int err; 614 615 err = fwspk_volume_command(fwspk, &fwspk->volume_min, 616 0, CTL_MIN, CTL_READ); 617 if (err < 0) 618 return err; 619 err = fwspk_volume_command(fwspk, &fwspk->volume_max, 620 0, CTL_MAX, CTL_READ); 621 if (err < 0) 622 return err; 623 624 err = fwspk_mute_command(fwspk, &fwspk->mute, CTL_READ); 625 if (err < 0) 626 return err; 627 628 first_ch = fwspk->device_info->mixer_channels == 1 ? 0 : 1; 629 for (i = 0; i < fwspk->device_info->mixer_channels; ++i) { 630 err = fwspk_volume_command(fwspk, &fwspk->volume[i], 631 first_ch + i, CTL_CURRENT, CTL_READ); 632 if (err < 0) 633 return err; 634 } 635 636 for (i = 0; i < ARRAY_SIZE(controls); ++i) { 637 err = snd_ctl_add(fwspk->card, 638 snd_ctl_new1(&controls[i], fwspk)); 639 if (err < 0) 640 return err; 641 } 642 643 return 0; 644} 645 646static u32 fwspk_read_firmware_version(struct fw_unit *unit) 647{ 648 __be32 data; 649 int err; 650 651 err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST, 652 OXFORD_FIRMWARE_ID_ADDRESS, &data, 4); 653 return err >= 0 ? be32_to_cpu(data) : 0; 654} 655 656static void fwspk_card_free(struct snd_card *card) 657{ 658 struct fwspk *fwspk = card->private_data; 659 struct fw_device *dev = fw_parent_device(fwspk->unit); 660 661 amdtp_out_stream_destroy(&fwspk->stream); 662 cmp_connection_destroy(&fwspk->connection); 663 fw_unit_put(fwspk->unit); 664 fw_device_put(dev); 665 mutex_destroy(&fwspk->mutex); 666} 667 668static const struct device_info *__devinit fwspk_detect(struct fw_device *dev) 669{ 670 static const struct device_info griffin_firewave = { 671 .driver_name = "FireWave", 672 .short_name = "FireWave", 673 .long_name = "Griffin FireWave Surround", 674 .pcm_constraints = firewave_constraints, 675 .mixer_channels = 6, 676 .mute_fb_id = 0x01, 677 .volume_fb_id = 0x02, 678 }; 679 static const struct device_info lacie_speakers = { 680 .driver_name = "FWSpeakers", 681 .short_name = "FireWire Speakers", 682 .long_name = "LaCie FireWire Speakers", 683 .pcm_constraints = lacie_speakers_constraints, 684 .mixer_channels = 1, 685 .mute_fb_id = 0x01, 686 .volume_fb_id = 0x01, 687 }; 688 struct fw_csr_iterator i; 689 int key, value; 690 691 fw_csr_iterator_init(&i, dev->config_rom); 692 while (fw_csr_iterator_next(&i, &key, &value)) 693 if (key == CSR_VENDOR) 694 switch (value) { 695 case VENDOR_GRIFFIN: 696 return &griffin_firewave; 697 case VENDOR_LACIE: 698 return &lacie_speakers; 699 } 700 701 return NULL; 702} 703 704static int __devinit fwspk_probe(struct device *unit_dev) 705{ 706 struct fw_unit *unit = fw_unit(unit_dev); 707 struct fw_device *fw_dev = fw_parent_device(unit); 708 struct snd_card *card; 709 struct fwspk *fwspk; 710 u32 firmware; 711 int err; 712 713 err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*fwspk), &card); 714 if (err < 0) 715 return err; 716 snd_card_set_dev(card, unit_dev); 717 718 fwspk = card->private_data; 719 fwspk->card = card; 720 mutex_init(&fwspk->mutex); 721 fw_device_get(fw_dev); 722 fwspk->unit = fw_unit_get(unit); 723 fwspk->device_info = fwspk_detect(fw_dev); 724 if (!fwspk->device_info) { 725 err = -ENODEV; 726 goto err_unit; 727 } 728 729 err = cmp_connection_init(&fwspk->connection, unit, 0); 730 if (err < 0) 731 goto err_unit; 732 733 err = amdtp_out_stream_init(&fwspk->stream, unit, CIP_NONBLOCKING); 734 if (err < 0) 735 goto err_connection; 736 737 card->private_free = fwspk_card_free; 738 739 strcpy(card->driver, fwspk->device_info->driver_name); 740 strcpy(card->shortname, fwspk->device_info->short_name); 741 firmware = fwspk_read_firmware_version(unit); 742 snprintf(card->longname, sizeof(card->longname), 743 "%s (OXFW%x %04x), GUID %08x%08x at %s, S%d", 744 fwspk->device_info->long_name, 745 firmware >> 20, firmware & 0xffff, 746 fw_dev->config_rom[3], fw_dev->config_rom[4], 747 dev_name(&unit->device), 100 << fw_dev->max_speed); 748 strcpy(card->mixername, "OXFW970"); 749 750 err = fwspk_create_pcm(fwspk); 751 if (err < 0) 752 goto error; 753 754 err = fwspk_create_mixer(fwspk); 755 if (err < 0) 756 goto error; 757 758 err = snd_card_register(card); 759 if (err < 0) 760 goto error; 761 762 dev_set_drvdata(unit_dev, fwspk); 763 764 return 0; 765 766err_connection: 767 cmp_connection_destroy(&fwspk->connection); 768err_unit: 769 fw_unit_put(fwspk->unit); 770 fw_device_put(fw_dev); 771 mutex_destroy(&fwspk->mutex); 772error: 773 snd_card_free(card); 774 return err; 775} 776 777static int __devexit fwspk_remove(struct device *dev) 778{ 779 struct fwspk *fwspk = dev_get_drvdata(dev); 780 781 mutex_lock(&fwspk->mutex); 782 amdtp_out_stream_pcm_abort(&fwspk->stream); 783 snd_card_disconnect(fwspk->card); 784 fwspk_stop_stream(fwspk); 785 mutex_unlock(&fwspk->mutex); 786 787 snd_card_free_when_closed(fwspk->card); 788 789 return 0; 790} 791 792static void fwspk_bus_reset(struct fw_unit *unit) 793{ 794 struct fwspk *fwspk = dev_get_drvdata(&unit->device); 795 796 fcp_bus_reset(fwspk->unit); 797 798 if (cmp_connection_update(&fwspk->connection) < 0) { 799 mutex_lock(&fwspk->mutex); 800 amdtp_out_stream_pcm_abort(&fwspk->stream); 801 fwspk_stop_stream(fwspk); 802 mutex_unlock(&fwspk->mutex); 803 return; 804 } 805 806 amdtp_out_stream_update(&fwspk->stream); 807} 808 809static const struct ieee1394_device_id fwspk_id_table[] = { 810 { 811 .match_flags = IEEE1394_MATCH_VENDOR_ID | 812 IEEE1394_MATCH_MODEL_ID | 813 IEEE1394_MATCH_SPECIFIER_ID | 814 IEEE1394_MATCH_VERSION, 815 .vendor_id = VENDOR_GRIFFIN, 816 .model_id = 0x00f970, 817 .specifier_id = SPECIFIER_1394TA, 818 .version = VERSION_AVC, 819 }, 820 { 821 .match_flags = IEEE1394_MATCH_VENDOR_ID | 822 IEEE1394_MATCH_MODEL_ID | 823 IEEE1394_MATCH_SPECIFIER_ID | 824 IEEE1394_MATCH_VERSION, 825 .vendor_id = VENDOR_LACIE, 826 .model_id = 0x00f970, 827 .specifier_id = SPECIFIER_1394TA, 828 .version = VERSION_AVC, 829 }, 830 { } 831}; 832MODULE_DEVICE_TABLE(ieee1394, fwspk_id_table); 833 834static struct fw_driver fwspk_driver = { 835 .driver = { 836 .owner = THIS_MODULE, 837 .name = KBUILD_MODNAME, 838 .bus = &fw_bus_type, 839 .probe = fwspk_probe, 840 .remove = __devexit_p(fwspk_remove), 841 }, 842 .update = fwspk_bus_reset, 843 .id_table = fwspk_id_table, 844}; 845 846static int __init alsa_fwspk_init(void) 847{ 848 return driver_register(&fwspk_driver.driver); 849} 850 851static void __exit alsa_fwspk_exit(void) 852{ 853 driver_unregister(&fwspk_driver.driver); 854} 855 856module_init(alsa_fwspk_init); 857module_exit(alsa_fwspk_exit); 858