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 static void
  63 efw_card_free(struct snd_card *card)
  64 {
  65         struct snd_efw *efw = card->private_data;
  66
  67         if (efw->card_index >= 0) {
  68                 mutex_lock(&devices_mutex);
  69                 clear_bit(efw->card_index, devices_used);
  70                 mutex_unlock(&devices_mutex);
  71         }
  72
  73         mutex_destroy(&efw->mutex);
  74 }
  75
  76 static int
  77 efw_probe(struct fw_unit *unit,
  78           const struct ieee1394_device_id *entry)
  79 {
  80         struct snd_card *card;
  81         struct snd_efw *efw;
  82         int card_index, err;
  83
  84         mutex_lock(&devices_mutex);
  85
  86         /* check registered cards */
  87         for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) {
  88                 if (!test_bit(card_index, devices_used) && enable[card_index])
  89                         break;
  90         }
  91         if (card_index >= SNDRV_CARDS) {
  92                 err = -ENOENT;
  93                 goto end;
  94         }
  95
  96         err = snd_card_new(&unit->device, index[card_index], id[card_index],
  97                            THIS_MODULE, sizeof(struct snd_efw), &card);
  98         if (err < 0)
  99                 goto end;
 100         efw = card->private_data;
 101         efw->card_index = card_index;
 102         set_bit(card_index, devices_used);
 103         card->private_free = efw_card_free;
 104
 105         efw->card = card;
 106         efw->unit = unit;
 107         mutex_init(&efw->mutex);
 108         spin_lock_init(&efw->lock);
 109
 110         strcpy(efw->card->driver, "Fireworks");
 111         strcpy(efw->card->shortname, efw->card->driver);
 112         strcpy(efw->card->longname, efw->card->driver);
 113         strcpy(efw->card->mixername, efw->card->driver);
 114
 115         err = snd_card_register(card);
 116         if (err < 0)
 117                 goto error;
 118         dev_set_drvdata(&unit->device, efw);
 119 end:
 120         mutex_unlock(&devices_mutex);
 121         return err;
 122 error:
 123         mutex_unlock(&devices_mutex);
 124         snd_card_free(card);
 125         return err;
 126 }
 127
 128 static void efw_update(struct fw_unit *unit)
 129 {
 130         return;
 131 }
 132
 133 static void efw_remove(struct fw_unit *unit)
 134 {
 135         struct snd_efw *efw = dev_get_drvdata(&unit->device);
 136         snd_card_disconnect(efw->card);
 137         snd_card_free_when_closed(efw->card);
 138 }
 139
 140 static const struct ieee1394_device_id efw_id_table[] = {
 141         SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F),
 142         SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F),
 143         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8),
 144         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12),
 145         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD),
 146         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE),
 147         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2),
 148         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4),
 149         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9),
 150         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8),
 151         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI),
 152         SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP),
 153         SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP),
 154         {}
 155 };
 156 MODULE_DEVICE_TABLE(ieee1394, efw_id_table);
 157
 158 static struct fw_driver efw_driver = {
 159         .driver = {
 160                 .owner = THIS_MODULE,
 161                 .name = "snd-fireworks",
 162                 .bus = &fw_bus_type,
 163         },
 164         .probe    = efw_probe,
 165         .update   = efw_update,
 166         .remove   = efw_remove,
 167         .id_table = efw_id_table,
 168 };
 169
 170 static int __init snd_efw_init(void)
 171 {
 172         return driver_register(&efw_driver.driver);
 173 }
 174
 175 static void __exit snd_efw_exit(void)
 176 {
 177         driver_unregister(&efw_driver.driver);
 178         mutex_destroy(&devices_mutex);
 179 }
 180
 181 module_init(snd_efw_init);
 182 module_exit(snd_efw_exit);