linux/sound/drivers/mpu401/mpu401.c
<<
>>
Prefs
   1/*
   2 *  Driver for generic MPU-401 boards (UART mode only)
   3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4 *  Copyright (c) 2004 by Castet Matthieu <castet.matthieu@free.fr>
   5 *
   6 *
   7 *   This program is free software; you can redistribute it and/or modify
   8 *   it under the terms of the GNU General Public License as published by
   9 *   the Free Software Foundation; either version 2 of the License, or
  10 *   (at your option) any later version.
  11 *
  12 *   This program is distributed in the hope that it will be useful,
  13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 *   GNU General Public License for more details.
  16 *
  17 *   You should have received a copy of the GNU General Public License
  18 *   along with this program; if not, write to the Free Software
  19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 *
  21 */
  22
  23#include <linux/init.h>
  24#include <linux/pnp.h>
  25#include <linux/err.h>
  26#include <linux/platform_device.h>
  27#include <linux/module.h>
  28#include <sound/core.h>
  29#include <sound/mpu401.h>
  30#include <sound/initval.h>
  31
  32MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  33MODULE_DESCRIPTION("MPU-401 UART");
  34MODULE_LICENSE("GPL");
  35
  36static int index[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = -2}; /* exclude the first card */
  37static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
  38static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */
  39#ifdef CONFIG_PNP
  40static bool pnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
  41#endif
  42static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* MPU-401 port number */
  43static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* MPU-401 IRQ */
  44static bool uart_enter[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
  45
  46module_param_array(index, int, NULL, 0444);
  47MODULE_PARM_DESC(index, "Index value for MPU-401 device.");
  48module_param_array(id, charp, NULL, 0444);
  49MODULE_PARM_DESC(id, "ID string for MPU-401 device.");
  50module_param_array(enable, bool, NULL, 0444);
  51MODULE_PARM_DESC(enable, "Enable MPU-401 device.");
  52#ifdef CONFIG_PNP
  53module_param_array(pnp, bool, NULL, 0444);
  54MODULE_PARM_DESC(pnp, "PnP detection for MPU-401 device.");
  55#endif
  56module_param_hw_array(port, long, ioport, NULL, 0444);
  57MODULE_PARM_DESC(port, "Port # for MPU-401 device.");
  58module_param_hw_array(irq, int, irq, NULL, 0444);
  59MODULE_PARM_DESC(irq, "IRQ # for MPU-401 device.");
  60module_param_array(uart_enter, bool, NULL, 0444);
  61MODULE_PARM_DESC(uart_enter, "Issue UART_ENTER command at open.");
  62
  63static struct platform_device *platform_devices[SNDRV_CARDS];
  64static int pnp_registered;
  65static unsigned int snd_mpu401_devices;
  66
  67static int snd_mpu401_create(struct device *devptr, int dev,
  68                             struct snd_card **rcard)
  69{
  70        struct snd_card *card;
  71        int err;
  72
  73        if (!uart_enter[dev])
  74                snd_printk(KERN_ERR "the uart_enter option is obsolete; remove it\n");
  75
  76        *rcard = NULL;
  77        err = snd_card_new(devptr, index[dev], id[dev], THIS_MODULE,
  78                           0, &card);
  79        if (err < 0)
  80                return err;
  81        strcpy(card->driver, "MPU-401 UART");
  82        strcpy(card->shortname, card->driver);
  83        sprintf(card->longname, "%s at %#lx, ", card->shortname, port[dev]);
  84        if (irq[dev] >= 0) {
  85                sprintf(card->longname + strlen(card->longname), "irq %d", irq[dev]);
  86        } else {
  87                strcat(card->longname, "polled");
  88        }
  89
  90        err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, port[dev], 0,
  91                                  irq[dev], NULL);
  92        if (err < 0) {
  93                printk(KERN_ERR "MPU401 not detected at 0x%lx\n", port[dev]);
  94                goto _err;
  95        }
  96
  97        *rcard = card;
  98        return 0;
  99
 100 _err:
 101        snd_card_free(card);
 102        return err;
 103}
 104
 105static int snd_mpu401_probe(struct platform_device *devptr)
 106{
 107        int dev = devptr->id;
 108        int err;
 109        struct snd_card *card;
 110
 111        if (port[dev] == SNDRV_AUTO_PORT) {
 112                snd_printk(KERN_ERR "specify port\n");
 113                return -EINVAL;
 114        }
 115        if (irq[dev] == SNDRV_AUTO_IRQ) {
 116                snd_printk(KERN_ERR "specify or disable IRQ\n");
 117                return -EINVAL;
 118        }
 119        err = snd_mpu401_create(&devptr->dev, dev, &card);
 120        if (err < 0)
 121                return err;
 122        if ((err = snd_card_register(card)) < 0) {
 123                snd_card_free(card);
 124                return err;
 125        }
 126        platform_set_drvdata(devptr, card);
 127        return 0;
 128}
 129
 130static int snd_mpu401_remove(struct platform_device *devptr)
 131{
 132        snd_card_free(platform_get_drvdata(devptr));
 133        return 0;
 134}
 135
 136#define SND_MPU401_DRIVER       "snd_mpu401"
 137
 138static struct platform_driver snd_mpu401_driver = {
 139        .probe          = snd_mpu401_probe,
 140        .remove         = snd_mpu401_remove,
 141        .driver         = {
 142                .name   = SND_MPU401_DRIVER,
 143        },
 144};
 145
 146
 147#ifdef CONFIG_PNP
 148
 149#define IO_EXTENT 2
 150
 151static const struct pnp_device_id snd_mpu401_pnpids[] = {
 152        { .id = "PNPb006" },
 153        { .id = "" }
 154};
 155
 156MODULE_DEVICE_TABLE(pnp, snd_mpu401_pnpids);
 157
 158static int snd_mpu401_pnp(int dev, struct pnp_dev *device,
 159                          const struct pnp_device_id *id)
 160{
 161        if (!pnp_port_valid(device, 0) ||
 162            pnp_port_flags(device, 0) & IORESOURCE_DISABLED) {
 163                snd_printk(KERN_ERR "no PnP port\n");
 164                return -ENODEV;
 165        }
 166        if (pnp_port_len(device, 0) < IO_EXTENT) {
 167                snd_printk(KERN_ERR "PnP port length is %llu, expected %d\n",
 168                           (unsigned long long)pnp_port_len(device, 0),
 169                           IO_EXTENT);
 170                return -ENODEV;
 171        }
 172        port[dev] = pnp_port_start(device, 0);
 173
 174        if (!pnp_irq_valid(device, 0) ||
 175            pnp_irq_flags(device, 0) & IORESOURCE_DISABLED) {
 176                snd_printk(KERN_WARNING "no PnP irq, using polling\n");
 177                irq[dev] = -1;
 178        } else {
 179                irq[dev] = pnp_irq(device, 0);
 180        }
 181        return 0;
 182}
 183
 184static int snd_mpu401_pnp_probe(struct pnp_dev *pnp_dev,
 185                                const struct pnp_device_id *id)
 186{
 187        static int dev;
 188        struct snd_card *card;
 189        int err;
 190
 191        for ( ; dev < SNDRV_CARDS; ++dev) {
 192                if (!enable[dev] || !pnp[dev])
 193                        continue;
 194                err = snd_mpu401_pnp(dev, pnp_dev, id);
 195                if (err < 0)
 196                        return err;
 197                err = snd_mpu401_create(&pnp_dev->dev, dev, &card);
 198                if (err < 0)
 199                        return err;
 200                if ((err = snd_card_register(card)) < 0) {
 201                        snd_card_free(card);
 202                        return err;
 203                }
 204                pnp_set_drvdata(pnp_dev, card);
 205                snd_mpu401_devices++;
 206                ++dev;
 207                return 0;
 208        }
 209        return -ENODEV;
 210}
 211
 212static void snd_mpu401_pnp_remove(struct pnp_dev *dev)
 213{
 214        struct snd_card *card = (struct snd_card *) pnp_get_drvdata(dev);
 215
 216        snd_card_disconnect(card);
 217        snd_card_free_when_closed(card);
 218}
 219
 220static struct pnp_driver snd_mpu401_pnp_driver = {
 221        .name = "mpu401",
 222        .id_table = snd_mpu401_pnpids,
 223        .probe = snd_mpu401_pnp_probe,
 224        .remove = snd_mpu401_pnp_remove,
 225};
 226#else
 227static struct pnp_driver snd_mpu401_pnp_driver;
 228#endif
 229
 230static void snd_mpu401_unregister_all(void)
 231{
 232        int i;
 233
 234        if (pnp_registered)
 235                pnp_unregister_driver(&snd_mpu401_pnp_driver);
 236        for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)
 237                platform_device_unregister(platform_devices[i]);
 238        platform_driver_unregister(&snd_mpu401_driver);
 239}
 240
 241static int __init alsa_card_mpu401_init(void)
 242{
 243        int i, err;
 244
 245        if ((err = platform_driver_register(&snd_mpu401_driver)) < 0)
 246                return err;
 247
 248        for (i = 0; i < SNDRV_CARDS; i++) {
 249                struct platform_device *device;
 250                if (! enable[i])
 251                        continue;
 252#ifdef CONFIG_PNP
 253                if (pnp[i])
 254                        continue;
 255#endif
 256                device = platform_device_register_simple(SND_MPU401_DRIVER,
 257                                                         i, NULL, 0);
 258                if (IS_ERR(device))
 259                        continue;
 260                if (!platform_get_drvdata(device)) {
 261                        platform_device_unregister(device);
 262                        continue;
 263                }
 264                platform_devices[i] = device;
 265                snd_mpu401_devices++;
 266        }
 267        err = pnp_register_driver(&snd_mpu401_pnp_driver);
 268        if (!err)
 269                pnp_registered = 1;
 270
 271        if (!snd_mpu401_devices) {
 272#ifdef MODULE
 273                printk(KERN_ERR "MPU-401 device not found or device busy\n");
 274#endif
 275                snd_mpu401_unregister_all();
 276                return -ENODEV;
 277        }
 278        return 0;
 279}
 280
 281static void __exit alsa_card_mpu401_exit(void)
 282{
 283        snd_mpu401_unregister_all();
 284}
 285
 286module_init(alsa_card_mpu401_init)
 287module_exit(alsa_card_mpu401_exit)
 288