sound/firewire/oxfw/oxfw.c

   1 /*
   2  * oxfw.c - a part of driver for OXFW970/971 based devices
   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 "oxfw.h"
   9
  10 #define OXFORD_FIRMWARE_ID_ADDRESS      (CSR_REGISTER_BASE + 0x50000)
  11 /* 0x970?vvvv or 0x971?vvvv, where vvvv = firmware version */
  12
  13 #define OXFORD_HARDWARE_ID_ADDRESS      (CSR_REGISTER_BASE + 0x90020)
  14 #define OXFORD_HARDWARE_ID_OXFW970      0x39443841
  15 #define OXFORD_HARDWARE_ID_OXFW971      0x39373100
  16
  17 #define VENDOR_GRIFFIN          0x001292
  18 #define VENDOR_LACIE            0x00d04b
  19
  20 #define SPECIFIER_1394TA        0x00a02d
  21 #define VERSION_AVC             0x010001
  22
  23 MODULE_DESCRIPTION("Oxford Semiconductor FW970/971 driver");
  24 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
  25 MODULE_LICENSE("GPL v2");
  26 MODULE_ALIAS("snd-firewire-speakers");
  27
  28 enum control_action { CTL_READ, CTL_WRITE };
  29 enum control_attribute {
  30         CTL_MIN         = 0x02,
  31         CTL_MAX         = 0x03,
  32         CTL_CURRENT     = 0x10,
  33 };
  34
  35 static int oxfw_mute_command(struct snd_oxfw *oxfw, bool *value,
  36                               enum control_action action)
  37 {
  38         u8 *buf;
  39         u8 response_ok;
  40         int err;
  41
  42         buf = kmalloc(11, GFP_KERNEL);
  43         if (!buf)
  44                 return -ENOMEM;
  45
  46         if (action == CTL_READ) {
  47                 buf[0] = 0x01;          /* AV/C, STATUS */
  48                 response_ok = 0x0c;     /*       STABLE */
  49         } else {
  50                 buf[0] = 0x00;          /* AV/C, CONTROL */
  51                 response_ok = 0x09;     /*       ACCEPTED */
  52         }
  53         buf[1] = 0x08;                  /* audio unit 0 */
  54         buf[2] = 0xb8;                  /* FUNCTION BLOCK */
  55         buf[3] = 0x81;                  /* function block type: feature */
  56         buf[4] = oxfw->device_info->mute_fb_id; /* function block ID */
  57         buf[5] = 0x10;                  /* control attribute: current */
  58         buf[6] = 0x02;                  /* selector length */
  59         buf[7] = 0x00;                  /* audio channel number */
  60         buf[8] = 0x01;                  /* control selector: mute */
  61         buf[9] = 0x01;                  /* control data length */
  62         if (action == CTL_READ)
  63                 buf[10] = 0xff;
  64         else
  65                 buf[10] = *value ? 0x70 : 0x60;
  66
  67         err = fcp_avc_transaction(oxfw->unit, buf, 11, buf, 11, 0x3fe);
  68         if (err < 0)
  69                 goto error;
  70         if (err < 11) {
  71                 dev_err(&oxfw->unit->device, "short FCP response\n");
  72                 err = -EIO;
  73                 goto error;
  74         }
  75         if (buf[0] != response_ok) {
  76                 dev_err(&oxfw->unit->device, "mute command failed\n");
  77                 err = -EIO;
  78                 goto error;
  79         }
  80         if (action == CTL_READ)
  81                 *value = buf[10] == 0x70;
  82
  83         err = 0;
  84
  85 error:
  86         kfree(buf);
  87
  88         return err;
  89 }
  90
  91 static int oxfw_volume_command(struct snd_oxfw *oxfw, s16 *value,
  92                                 unsigned int channel,
  93                                 enum control_attribute attribute,
  94                                 enum control_action action)
  95 {
  96         u8 *buf;
  97         u8 response_ok;
  98         int err;
  99
 100         buf = kmalloc(12, GFP_KERNEL);
 101         if (!buf)
 102                 return -ENOMEM;
 103
 104         if (action == CTL_READ) {
 105                 buf[0] = 0x01;          /* AV/C, STATUS */
 106                 response_ok = 0x0c;     /*       STABLE */
 107         } else {
 108                 buf[0] = 0x00;          /* AV/C, CONTROL */
 109                 response_ok = 0x09;     /*       ACCEPTED */
 110         }
 111         buf[1] = 0x08;                  /* audio unit 0 */
 112         buf[2] = 0xb8;                  /* FUNCTION BLOCK */
 113         buf[3] = 0x81;                  /* function block type: feature */
 114         buf[4] = oxfw->device_info->volume_fb_id; /* function block ID */
 115         buf[5] = attribute;             /* control attribute */
 116         buf[6] = 0x02;                  /* selector length */
 117         buf[7] = channel;               /* audio channel number */
 118         buf[8] = 0x02;                  /* control selector: volume */
 119         buf[9] = 0x02;                  /* control data length */
 120         if (action == CTL_READ) {
 121                 buf[10] = 0xff;
 122                 buf[11] = 0xff;
 123         } else {
 124                 buf[10] = *value >> 8;
 125                 buf[11] = *value;
 126         }
 127
 128         err = fcp_avc_transaction(oxfw->unit, buf, 12, buf, 12, 0x3fe);
 129         if (err < 0)
 130                 goto error;
 131         if (err < 12) {
 132                 dev_err(&oxfw->unit->device, "short FCP response\n");
 133                 err = -EIO;
 134                 goto error;
 135         }
 136         if (buf[0] != response_ok) {
 137                 dev_err(&oxfw->unit->device, "volume command failed\n");
 138                 err = -EIO;
 139                 goto error;
 140         }
 141         if (action == CTL_READ)
 142                 *value = (buf[10] << 8) | buf[11];
 143
 144         err = 0;
 145
 146 error:
 147         kfree(buf);
 148
 149         return err;
 150 }
 151
 152 static int oxfw_mute_get(struct snd_kcontrol *control,
 153                           struct snd_ctl_elem_value *value)
 154 {
 155         struct snd_oxfw *oxfw = control->private_data;
 156
 157         value->value.integer.value[0] = !oxfw->mute;
 158
 159         return 0;
 160 }
 161
 162 static int oxfw_mute_put(struct snd_kcontrol *control,
 163                           struct snd_ctl_elem_value *value)
 164 {
 165         struct snd_oxfw *oxfw = control->private_data;
 166         bool mute;
 167         int err;
 168
 169         mute = !value->value.integer.value[0];
 170
 171         if (mute == oxfw->mute)
 172                 return 0;
 173
 174         err = oxfw_mute_command(oxfw, &mute, CTL_WRITE);
 175         if (err < 0)
 176                 return err;
 177         oxfw->mute = mute;
 178
 179         return 1;
 180 }
 181
 182 static int oxfw_volume_info(struct snd_kcontrol *control,
 183                              struct snd_ctl_elem_info *info)
 184 {
 185         struct snd_oxfw *oxfw = control->private_data;
 186
 187         info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 188         info->count = oxfw->device_info->mixer_channels;
 189         info->value.integer.min = oxfw->volume_min;
 190         info->value.integer.max = oxfw->volume_max;
 191
 192         return 0;
 193 }
 194
 195 static const u8 channel_map[6] = { 0, 1, 4, 5, 2, 3 };
 196
 197 static int oxfw_volume_get(struct snd_kcontrol *control,
 198                             struct snd_ctl_elem_value *value)
 199 {
 200         struct snd_oxfw *oxfw = control->private_data;
 201         unsigned int i;
 202
 203         for (i = 0; i < oxfw->device_info->mixer_channels; ++i)
 204                 value->value.integer.value[channel_map[i]] = oxfw->volume[i];
 205
 206         return 0;
 207 }
 208
 209 static int oxfw_volume_put(struct snd_kcontrol *control,
 210                           struct snd_ctl_elem_value *value)
 211 {
 212         struct snd_oxfw *oxfw = control->private_data;
 213         unsigned int i, changed_channels;
 214         bool equal_values = true;
 215         s16 volume;
 216         int err;
 217
 218         for (i = 0; i < oxfw->device_info->mixer_channels; ++i) {
 219                 if (value->value.integer.value[i] < oxfw->volume_min ||
 220                     value->value.integer.value[i] > oxfw->volume_max)
 221                         return -EINVAL;
 222                 if (value->value.integer.value[i] !=
 223                     value->value.integer.value[0])
 224                         equal_values = false;
 225         }
 226
 227         changed_channels = 0;
 228         for (i = 0; i < oxfw->device_info->mixer_channels; ++i)
 229                 if (value->value.integer.value[channel_map[i]] !=
 230                                                         oxfw->volume[i])
 231                         changed_channels |= 1 << (i + 1);
 232
 233         if (equal_values && changed_channels != 0)
 234                 changed_channels = 1 << 0;
 235
 236         for (i = 0; i <= oxfw->device_info->mixer_channels; ++i) {
 237                 volume = value->value.integer.value[channel_map[i ? i - 1 : 0]];
 238                 if (changed_channels & (1 << i)) {
 239                         err = oxfw_volume_command(oxfw, &volume, i,
 240                                                    CTL_CURRENT, CTL_WRITE);
 241                         if (err < 0)
 242                                 return err;
 243                 }
 244                 if (i > 0)
 245                         oxfw->volume[i - 1] = volume;
 246         }
 247
 248         return changed_channels != 0;
 249 }
 250
 251 static int oxfw_create_mixer(struct snd_oxfw *oxfw)
 252 {
 253         static const struct snd_kcontrol_new controls[] = {
 254                 {
 255                         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 256                         .name = "PCM Playback Switch",
 257                         .info = snd_ctl_boolean_mono_info,
 258                         .get = oxfw_mute_get,
 259                         .put = oxfw_mute_put,
 260                 },
 261                 {
 262                         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 263                         .name = "PCM Playback Volume",
 264                         .info = oxfw_volume_info,
 265                         .get = oxfw_volume_get,
 266                         .put = oxfw_volume_put,
 267                 },
 268         };
 269         unsigned int i, first_ch;
 270         int err;
 271
 272         err = oxfw_volume_command(oxfw, &oxfw->volume_min,
 273                                    0, CTL_MIN, CTL_READ);
 274         if (err < 0)
 275                 return err;
 276         err = oxfw_volume_command(oxfw, &oxfw->volume_max,
 277                                    0, CTL_MAX, CTL_READ);
 278         if (err < 0)
 279                 return err;
 280
 281         err = oxfw_mute_command(oxfw, &oxfw->mute, CTL_READ);
 282         if (err < 0)
 283                 return err;
 284
 285         first_ch = oxfw->device_info->mixer_channels == 1 ? 0 : 1;
 286         for (i = 0; i < oxfw->device_info->mixer_channels; ++i) {
 287                 err = oxfw_volume_command(oxfw, &oxfw->volume[i],
 288                                            first_ch + i, CTL_CURRENT, CTL_READ);
 289                 if (err < 0)
 290                         return err;
 291         }
 292
 293         for (i = 0; i < ARRAY_SIZE(controls); ++i) {
 294                 err = snd_ctl_add(oxfw->card,
 295                                   snd_ctl_new1(&controls[i], oxfw));
 296                 if (err < 0)
 297                         return err;
 298         }
 299
 300         return 0;
 301 }
 302
 303 static u32 oxfw_read_firmware_version(struct fw_unit *unit)
 304 {
 305         __be32 data;
 306         int err;
 307
 308         err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST,
 309                                  OXFORD_FIRMWARE_ID_ADDRESS, &data, 4, 0);
 310         return err >= 0 ? be32_to_cpu(data) : 0;
 311 }
 312
 313 static void oxfw_card_free(struct snd_card *card)
 314 {
 315         struct snd_oxfw *oxfw = card->private_data;
 316
 317         mutex_destroy(&oxfw->mutex);
 318 }
 319
 320 static int oxfw_probe(struct fw_unit *unit,
 321                        const struct ieee1394_device_id *id)
 322 {
 323         struct fw_device *fw_dev = fw_parent_device(unit);
 324         struct snd_card *card;
 325         struct snd_oxfw *oxfw;
 326         u32 firmware;
 327         int err;
 328
 329         err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE,
 330                            sizeof(*oxfw), &card);
 331         if (err < 0)
 332                 return err;
 333
 334         card->private_free = oxfw_card_free;
 335         oxfw = card->private_data;
 336         oxfw->card = card;
 337         mutex_init(&oxfw->mutex);
 338         oxfw->unit = unit;
 339         oxfw->device_info = (const struct device_info *)id->driver_data;
 340
 341         strcpy(card->driver, oxfw->device_info->driver_name);
 342         strcpy(card->shortname, oxfw->device_info->short_name);
 343         firmware = oxfw_read_firmware_version(unit);
 344         snprintf(card->longname, sizeof(card->longname),
 345                  "%s (OXFW%x %04x), GUID %08x%08x at %s, S%d",
 346                  oxfw->device_info->long_name,
 347                  firmware >> 20, firmware & 0xffff,
 348                  fw_dev->config_rom[3], fw_dev->config_rom[4],
 349                  dev_name(&unit->device), 100 << fw_dev->max_speed);
 350         strcpy(card->mixername, "OXFW");
 351
 352         err = snd_oxfw_create_pcm(oxfw);
 353         if (err < 0)
 354                 goto error;
 355
 356         err = oxfw_create_mixer(oxfw);
 357         if (err < 0)
 358                 goto error;
 359
 360         err = snd_oxfw_stream_init_simplex(oxfw);
 361         if (err < 0)
 362                 goto error;
 363
 364         err = snd_card_register(card);
 365         if (err < 0) {
 366                 snd_oxfw_stream_destroy_simplex(oxfw);
 367                 goto error;
 368         }
 369         dev_set_drvdata(&unit->device, oxfw);
 370
 371         return 0;
 372 error:
 373         snd_card_free(card);
 374         return err;
 375 }
 376
 377 static void oxfw_bus_reset(struct fw_unit *unit)
 378 {
 379         struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
 380
 381         fcp_bus_reset(oxfw->unit);
 382
 383         mutex_lock(&oxfw->mutex);
 384         snd_oxfw_stream_update_simplex(oxfw);
 385         mutex_unlock(&oxfw->mutex);
 386 }
 387
 388 static void oxfw_remove(struct fw_unit *unit)
 389 {
 390         struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
 391
 392         snd_card_disconnect(oxfw->card);
 393
 394         snd_oxfw_stream_destroy_simplex(oxfw);
 395
 396         snd_card_free_when_closed(oxfw->card);
 397 }
 398
 399 static const struct device_info griffin_firewave = {
 400         .driver_name = "FireWave",
 401         .short_name  = "FireWave",
 402         .long_name   = "Griffin FireWave Surround",
 403         .pcm_constraints = firewave_constraints,
 404         .mixer_channels = 6,
 405         .mute_fb_id   = 0x01,
 406         .volume_fb_id = 0x02,
 407 };
 408
 409 static const struct device_info lacie_speakers = {
 410         .driver_name = "FWSpeakers",
 411         .short_name  = "FireWire Speakers",
 412         .long_name   = "LaCie FireWire Speakers",
 413         .pcm_constraints = lacie_speakers_constraints,
 414         .mixer_channels = 1,
 415         .mute_fb_id   = 0x01,
 416         .volume_fb_id = 0x01,
 417 };
 418
 419 static const struct ieee1394_device_id oxfw_id_table[] = {
 420         {
 421                 .match_flags  = IEEE1394_MATCH_VENDOR_ID |
 422                                 IEEE1394_MATCH_MODEL_ID |
 423                                 IEEE1394_MATCH_SPECIFIER_ID |
 424                                 IEEE1394_MATCH_VERSION,
 425                 .vendor_id    = VENDOR_GRIFFIN,
 426                 .model_id     = 0x00f970,
 427                 .specifier_id = SPECIFIER_1394TA,
 428                 .version      = VERSION_AVC,
 429                 .driver_data  = (kernel_ulong_t)&griffin_firewave,
 430         },
 431         {
 432                 .match_flags  = IEEE1394_MATCH_VENDOR_ID |
 433                                 IEEE1394_MATCH_MODEL_ID |
 434                                 IEEE1394_MATCH_SPECIFIER_ID |
 435                                 IEEE1394_MATCH_VERSION,
 436                 .vendor_id    = VENDOR_LACIE,
 437                 .model_id     = 0x00f970,
 438                 .specifier_id = SPECIFIER_1394TA,
 439                 .version      = VERSION_AVC,
 440                 .driver_data  = (kernel_ulong_t)&lacie_speakers,
 441         },
 442         { }
 443 };
 444 MODULE_DEVICE_TABLE(ieee1394, oxfw_id_table);
 445
 446 static struct fw_driver oxfw_driver = {
 447         .driver   = {
 448                 .owner  = THIS_MODULE,
 449                 .name   = KBUILD_MODNAME,
 450                 .bus    = &fw_bus_type,
 451         },
 452         .probe    = oxfw_probe,
 453         .update   = oxfw_bus_reset,
 454         .remove   = oxfw_remove,
 455         .id_table = oxfw_id_table,
 456 };
 457
 458 static int __init snd_oxfw_init(void)
 459 {
 460         return driver_register(&oxfw_driver.driver);
 461 }
 462
 463 static void __exit snd_oxfw_exit(void)
 464 {
 465         driver_unregister(&oxfw_driver.driver);
 466 }
 467
 468 module_init(snd_oxfw_init);
 469 module_exit(snd_oxfw_exit);