sound/firewire/fireworks/fireworks.c

   1 /*
   2  * fireworks.c - a part of driver for Fireworks based devices
   3  *
   4  * Copyright (c) 2009-2010 Clemens Ladisch
   5  * Copyright (c) 2013-2014 Takashi Sakamoto
   6  *
   7  * Licensed under the terms of the GNU General Public License, version 2.
   8  */
   9
  10 /*
  11  * Fireworks is a board module which Echo Audio produced. This module consists
  12  * of three chipsets:
  13  *  - Communication chipset for IEEE1394 PHY/Link and IEC 61883-1/6
  14  *  - DSP or/and FPGA for signal processing
  15  *  - Flash Memory to store firmwares
  16  */
  17
  18 #include "fireworks.h"
  19
  20 MODULE_DESCRIPTION("Echo Fireworks driver");
  21 MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>");
  22 MODULE_LICENSE("GPL v2");
  23
  24 static int index[SNDRV_CARDS]   = SNDRV_DEFAULT_IDX;
  25 static char *id[SNDRV_CARDS]    = SNDRV_DEFAULT_STR;
  26 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  27
  28 module_param_array(index, int, NULL, 0444);
  29 MODULE_PARM_DESC(index, "card index");
  30 module_param_array(id, charp, NULL, 0444);
  31 MODULE_PARM_DESC(id, "ID string");
  32 module_param_array(enable, bool, NULL, 0444);
  33 MODULE_PARM_DESC(enable, "enable Fireworks sound card");
  34
  35 static DEFINE_MUTEX(devices_mutex);
  36 static DECLARE_BITMAP(devices_used, SNDRV_CARDS);
  37
  38 #define VENDOR_LOUD                     0x000ff2
  39 #define  MODEL_MACKIE_400F              0x00400f
  40 #define  MODEL_MACKIE_1200F             0x01200f
  41
  42 #define VENDOR_ECHO                     0x001486
  43 #define  MODEL_ECHO_AUDIOFIRE_12        0x00af12
  44 #define  MODEL_ECHO_AUDIOFIRE_12HD      0x0af12d
  45 #define  MODEL_ECHO_AUDIOFIRE_12_APPLE  0x0af12a
  46 /* This is applied for AudioFire8 (until 2009 July) */
  47 #define  MODEL_ECHO_AUDIOFIRE_8         0x000af8
  48 #define  MODEL_ECHO_AUDIOFIRE_2         0x000af2
  49 #define  MODEL_ECHO_AUDIOFIRE_4         0x000af4
  50 /* AudioFire9 is applied for AudioFire8(since 2009 July) and AudioFirePre8 */
  51 #define  MODEL_ECHO_AUDIOFIRE_9         0x000af9
  52 /* unknown as product */
  53 #define  MODEL_ECHO_FIREWORKS_8         0x0000f8
  54 #define  MODEL_ECHO_FIREWORKS_HDMI      0x00afd1
  55
  56 #define VENDOR_GIBSON                   0x00075b
  57 /* for Robot Interface Pack of Dark Fire, Dusk Tiger, Les Paul Standard 2010 */
  58 #define  MODEL_GIBSON_RIP               0x00afb2
  59 /* unknown as product */
  60 #define  MODEL_GIBSON_GOLDTOP           0x00afb9
  61
  62 /* part of hardware capability flags */
  63 #define FLAG_RESP_ADDR_CHANGABLE        0
  64
  65 static int
  66 get_hardware_info(struct snd_efw *efw)
  67 {
  68         struct fw_device *fw_dev = fw_parent_device(efw->unit);
  69         struct snd_efw_hwinfo *hwinfo;
  70         char version[12] = {0};
  71         int err;
  72
  73         hwinfo = kzalloc(sizeof(struct snd_efw_hwinfo), GFP_KERNEL);
  74         if (hwinfo == NULL)
  75                 return -ENOMEM;
  76
  77         err = snd_efw_command_get_hwinfo(efw, hwinfo);
  78         if (err < 0)
  79                 goto end;
  80
  81         /* firmware version for communication chipset */
  82         snprintf(version, sizeof(version), "%u.%u",
  83                  (hwinfo->arm_version >> 24) & 0xff,
  84                  (hwinfo->arm_version >> 16) & 0xff);
  85         if (err < 0)
  86                 goto end;
  87         efw->firmware_version = hwinfo->arm_version;
  88
  89         strcpy(efw->card->driver, "Fireworks");
  90         strcpy(efw->card->shortname, hwinfo->model_name);
  91         strcpy(efw->card->mixername, hwinfo->model_name);
  92         snprintf(efw->card->longname, sizeof(efw->card->longname),
  93                  "%s %s v%s, GUID %08x%08x at %s, S%d",
  94                  hwinfo->vendor_name, hwinfo->model_name, version,
  95                  hwinfo->guid_hi, hwinfo->guid_lo,
  96                  dev_name(&efw->unit->device), 100 << fw_dev->max_speed);
  97         if (err < 0)
  98                 goto end;
  99
 100         if (hwinfo->flags & BIT(FLAG_RESP_ADDR_CHANGABLE))
 101                 efw->resp_addr_changable = true;
 102
 103         efw->supported_sampling_rate = 0;
 104         if ((hwinfo->min_sample_rate <= 22050)
 105          && (22050 <= hwinfo->max_sample_rate))
 106                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_22050;
 107         if ((hwinfo->min_sample_rate <= 32000)
 108          && (32000 <= hwinfo->max_sample_rate))
 109                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_32000;
 110         if ((hwinfo->min_sample_rate <= 44100)
 111          && (44100 <= hwinfo->max_sample_rate))
 112                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_44100;
 113         if ((hwinfo->min_sample_rate <= 48000)
 114          && (48000 <= hwinfo->max_sample_rate))
 115                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_48000;
 116         if ((hwinfo->min_sample_rate <= 88200)
 117          && (88200 <= hwinfo->max_sample_rate))
 118                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_88200;
 119         if ((hwinfo->min_sample_rate <= 96000)
 120          && (96000 <= hwinfo->max_sample_rate))
 121                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_96000;
 122         if ((hwinfo->min_sample_rate <= 176400)
 123          && (176400 <= hwinfo->max_sample_rate))
 124                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_176400;
 125         if ((hwinfo->min_sample_rate <= 192000)
 126          && (192000 <= hwinfo->max_sample_rate))
 127                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_192000;
 128
 129         /* the number of MIDI ports, not of MIDI conformant data channels */
 130         if (hwinfo->midi_out_ports > SND_EFW_MAX_MIDI_OUT_PORTS ||
 131             hwinfo->midi_in_ports > SND_EFW_MAX_MIDI_IN_PORTS) {
 132                 err = -EIO;
 133                 goto end;
 134         }
 135         efw->midi_out_ports = hwinfo->midi_out_ports;
 136         efw->midi_in_ports = hwinfo->midi_in_ports;
 137
 138         if (hwinfo->amdtp_tx_pcm_channels    > AMDTP_MAX_CHANNELS_FOR_PCM ||
 139             hwinfo->amdtp_tx_pcm_channels_2x > AMDTP_MAX_CHANNELS_FOR_PCM ||
 140             hwinfo->amdtp_tx_pcm_channels_4x > AMDTP_MAX_CHANNELS_FOR_PCM ||
 141             hwinfo->amdtp_rx_pcm_channels    > AMDTP_MAX_CHANNELS_FOR_PCM ||
 142             hwinfo->amdtp_rx_pcm_channels_2x > AMDTP_MAX_CHANNELS_FOR_PCM ||
 143             hwinfo->amdtp_rx_pcm_channels_4x > AMDTP_MAX_CHANNELS_FOR_PCM) {
 144                 err = -ENOSYS;
 145                 goto end;
 146         }
 147         efw->pcm_capture_channels[0] = hwinfo->amdtp_tx_pcm_channels;
 148         efw->pcm_capture_channels[1] = hwinfo->amdtp_tx_pcm_channels_2x;
 149         efw->pcm_capture_channels[2] = hwinfo->amdtp_tx_pcm_channels_4x;
 150         efw->pcm_playback_channels[0] = hwinfo->amdtp_rx_pcm_channels;
 151         efw->pcm_playback_channels[1] = hwinfo->amdtp_rx_pcm_channels_2x;
 152         efw->pcm_playback_channels[2] = hwinfo->amdtp_rx_pcm_channels_4x;
 153
 154         /* Hardware metering. */
 155         if (hwinfo->phys_in_grp_count  > HWINFO_MAX_CAPS_GROUPS ||
 156             hwinfo->phys_out_grp_count > HWINFO_MAX_CAPS_GROUPS) {
 157                 return -EIO;
 158                 goto end;
 159         }
 160         efw->phys_in = hwinfo->phys_in;
 161         efw->phys_out = hwinfo->phys_out;
 162         efw->phys_in_grp_count = hwinfo->phys_in_grp_count;
 163         efw->phys_out_grp_count = hwinfo->phys_out_grp_count;
 164         memcpy(&efw->phys_in_grps, hwinfo->phys_in_grps,
 165                sizeof(struct snd_efw_phys_grp) * hwinfo->phys_in_grp_count);
 166         memcpy(&efw->phys_out_grps, hwinfo->phys_out_grps,
 167                sizeof(struct snd_efw_phys_grp) * hwinfo->phys_out_grp_count);
 168 end:
 169         kfree(hwinfo);
 170         return err;
 171 }
 172
 173 static void
 174 efw_card_free(struct snd_card *card)
 175 {
 176         struct snd_efw *efw = card->private_data;
 177
 178         if (efw->card_index >= 0) {
 179                 mutex_lock(&devices_mutex);
 180                 clear_bit(efw->card_index, devices_used);
 181                 mutex_unlock(&devices_mutex);
 182         }
 183
 184         mutex_destroy(&efw->mutex);
 185 }
 186
 187 static int
 188 efw_probe(struct fw_unit *unit,
 189           const struct ieee1394_device_id *entry)
 190 {
 191         struct snd_card *card;
 192         struct snd_efw *efw;
 193         int card_index, err;
 194
 195         mutex_lock(&devices_mutex);
 196
 197         /* check registered cards */
 198         for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) {
 199                 if (!test_bit(card_index, devices_used) && enable[card_index])
 200                         break;
 201         }
 202         if (card_index >= SNDRV_CARDS) {
 203                 err = -ENOENT;
 204                 goto end;
 205         }
 206
 207         err = snd_card_new(&unit->device, index[card_index], id[card_index],
 208                            THIS_MODULE, sizeof(struct snd_efw), &card);
 209         if (err < 0)
 210                 goto end;
 211         efw = card->private_data;
 212         efw->card_index = card_index;
 213         set_bit(card_index, devices_used);
 214         card->private_free = efw_card_free;
 215
 216         efw->card = card;
 217         efw->unit = unit;
 218         mutex_init(&efw->mutex);
 219         spin_lock_init(&efw->lock);
 220
 221         err = get_hardware_info(efw);
 222         if (err < 0)
 223                 goto error;
 224         if (entry->model_id == MODEL_ECHO_AUDIOFIRE_9)
 225                 efw->is_af9 = true;
 226
 227         snd_efw_proc_init(efw);
 228
 229         if (efw->midi_out_ports || efw->midi_in_ports) {
 230                 err = snd_efw_create_midi_devices(efw);
 231                 if (err < 0)
 232                         goto error;
 233         }
 234
 235         err = snd_efw_create_pcm_devices(efw);
 236         if (err < 0)
 237                 goto error;
 238
 239         err = snd_efw_stream_init_duplex(efw);
 240         if (err < 0)
 241                 goto error;
 242
 243         err = snd_card_register(card);
 244         if (err < 0) {
 245                 snd_efw_stream_destroy_duplex(efw);
 246                 goto error;
 247         }
 248
 249         dev_set_drvdata(&unit->device, efw);
 250 end:
 251         mutex_unlock(&devices_mutex);
 252         return err;
 253 error:
 254         mutex_unlock(&devices_mutex);
 255         snd_card_free(card);
 256         return err;
 257 }
 258
 259 static void efw_update(struct fw_unit *unit)
 260 {
 261         struct snd_efw *efw = dev_get_drvdata(&unit->device);
 262
 263         snd_efw_transaction_bus_reset(efw->unit);
 264         snd_efw_stream_update_duplex(efw);
 265 }
 266
 267 static void efw_remove(struct fw_unit *unit)
 268 {
 269         struct snd_efw *efw = dev_get_drvdata(&unit->device);
 270
 271         snd_efw_stream_destroy_duplex(efw);
 272
 273         snd_card_disconnect(efw->card);
 274         snd_card_free_when_closed(efw->card);
 275 }
 276
 277 static const struct ieee1394_device_id efw_id_table[] = {
 278         SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F),
 279         SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F),
 280         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8),
 281         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12),
 282         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD),
 283         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE),
 284         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2),
 285         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4),
 286         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9),
 287         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8),
 288         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI),
 289         SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP),
 290         SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP),
 291         {}
 292 };
 293 MODULE_DEVICE_TABLE(ieee1394, efw_id_table);
 294
 295 static struct fw_driver efw_driver = {
 296         .driver = {
 297                 .owner = THIS_MODULE,
 298                 .name = "snd-fireworks",
 299                 .bus = &fw_bus_type,
 300         },
 301         .probe    = efw_probe,
 302         .update   = efw_update,
 303         .remove   = efw_remove,
 304         .id_table = efw_id_table,
 305 };
 306
 307 static int __init snd_efw_init(void)
 308 {
 309         int err;
 310
 311         err = snd_efw_transaction_register();
 312         if (err < 0)
 313                 goto end;
 314
 315         err = driver_register(&efw_driver.driver);
 316         if (err < 0)
 317                 snd_efw_transaction_unregister();
 318
 319 end:
 320         return err;
 321 }
 322
 323 static void __exit snd_efw_exit(void)
 324 {
 325         snd_efw_transaction_unregister();
 326         driver_unregister(&efw_driver.driver);
 327         mutex_destroy(&devices_mutex);
 328 }
 329
 330 module_init(snd_efw_init);
 331 module_exit(snd_efw_exit);