/* * Generic driver for serial MIDI adapters * Copyright (c) by Jaroslav Kysela <perex@perex.cz> * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ /* * The adaptor module parameter allows you to select: * 0 - Roland SoundCanvas (use outs paratemer to specify count of output ports) */ #include "adriver.h" #include <linux/init.h> #include <linux/slab.h> #include <linux/tty.h> #include <linux/moduleparam.h> #include <linux/platform_device.h> #include <asm/uaccess.h> #include <sound/core.h> #include <sound/rawmidi.h> #include <sound/initval.h> #include <linux/delay.h> #define SNDRV_SERIAL_MAX_OUTS 16 /* min 16 */ #define TX_BUF_SIZE 256 #define SERIAL_ADAPTOR_SOUNDCANVAS 0 /* Roland Soundcanvas; F5 NN selects part */ #define SERIAL_ADAPTOR_MS124T 1 /* Midiator MS-124T */ #define SERIAL_ADAPTOR_MS124W_SA 2 /* Midiator MS-124W in S/A mode */ #define SERIAL_ADAPTOR_MS124W_MB 3 /* Midiator MS-124W in M/B mode */ #define SERIAL_ADAPTOR_MAX SERIAL_ADAPTOR_MS124W_MB EXPORT_NO_SYMBOLS; MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); MODULE_DESCRIPTION("Serial MIDI"); MODULE_LICENSE("GPL"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */ static char *sdev[SNDRV_CARDS] = {"/dev/ttyS0", [1 ... (SNDRV_CARDS - 1)] = ""}; /* serial device */ static int speed[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 38400}; /* 9600,19200,38400,57600,115200 */ static int adaptor[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = SERIAL_ADAPTOR_SOUNDCANVAS}; static int outs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; /* 1 to 16 */ static int devices[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; /* 1 to 8 */ static int handshake[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; /* bool */ module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for serial device."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for serial device."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable serial device."); module_param_array(sdev, charp, NULL, 0444); MODULE_PARM_DESC(sdev, "Device file string for serial device."); module_param_array(speed, int, NULL, 0444); MODULE_PARM_DESC(speed, "Speed in bauds."); module_param_array(adaptor, int, NULL, 0444); MODULE_PARM_DESC(adaptor, "Type of adaptor."); module_param_array(outs, int, NULL, 0444); MODULE_PARM_DESC(outs, "Number of MIDI outputs."); module_param_array(devices, int, NULL, 0444); MODULE_PARM_DESC(devices, "Number of devices to attach to the card."); module_param_array(handshake, int, NULL, 0444); MODULE_PARM_DESC(handshake, "Do handshaking."); #define SERIAL_MODE_NOT_OPENED (0) #define SERIAL_MODE_BIT_INPUT (0) #define SERIAL_MODE_BIT_OUTPUT (1) #define SERIAL_MODE_BIT_INPUT_TRIGGERED (2) #define SERIAL_MODE_BIT_OUTPUT_TRIGGERED (3) typedef struct _snd_serialmidi { struct snd_card *card; char *sdev; /* serial device name (e.g. /dev/ttyS0) */ int dev_idx; unsigned int speed; /* speed in bauds */ unsigned int adaptor; /* see SERIAL_ADAPTOR_ */ unsigned long mode; /* see SERIAL_MODE_* */ unsigned int outs; /* count of outputs */ unsigned char prev_status[SNDRV_SERIAL_MAX_OUTS]; struct snd_rawmidi *rmidi; /* rawmidi device */ struct snd_rawmidi_substream *substream_input; struct snd_rawmidi_substream *substream_output; struct file *file; struct tty_struct *tty; struct mutex open_lock; void (*old_receive_buf)(struct tty_struct *, const unsigned char *cp, char *fp, int count); void (*old_write_wakeup)(struct tty_struct *); int old_exclusive; int old_low_latency; int handshake; unsigned char tx_buf[TX_BUF_SIZE]; } serialmidi_t; static struct platform_device *devptrs[SNDRV_CARDS]; static void ldisc_receive_buf(struct tty_struct *, const unsigned char *cp, char *fp, int count); static void ldisc_write_wakeup(struct tty_struct *); static int tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct inode * inode = file->f_dentry->d_inode; mm_segment_t fs; int retval; if (file->f_op == NULL) return -ENXIO; fs = get_fs(); set_fs(get_ds()); retval = file->f_op->ioctl(inode, file, cmd, arg); set_fs(fs); return retval; } static int open_tty(serialmidi_t *serial, unsigned int mode) { int retval = 0; struct tty_struct *tty; struct termios old_termios, *ntermios; struct tty_driver *driver; int ldisc, speed, cflag; mutex_lock(&serial->open_lock); if (serial->tty) { set_bit(mode, &serial->mode); goto __end; } if (IS_ERR(serial->file = filp_open(serial->sdev, O_RDWR|O_NONBLOCK, 0))) { retval = PTR_ERR(serial->file); serial->file = NULL; goto __end; } tty = (struct tty_struct *)serial->file->private_data; if (tty == NULL || tty->magic != TTY_MAGIC) { snd_printk(KERN_ERR "device %s has not valid tty", serial->sdev); retval = -EIO; goto __end; } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0) /* correct version? */ driver = tty->driver; #else driver = &tty->driver; #endif if (driver == NULL || driver->set_termios == NULL) { snd_printk(KERN_ERR "tty %s has not set_termios", serial->sdev); retval = -EIO; goto __end; } #ifdef CONFIG_HAVE_TTY_COUNT_ATOMIC if (atomic_read(&tty->count) > 1) { #else if (tty->count > 1) { #endif snd_printk(KERN_ERR "tty %s is already used", serial->sdev); retval = -EBUSY; goto __end; } /* select N_TTY line discipline (for sure) */ ldisc = N_TTY; if ((retval = tty_ioctl(serial->file, TIOCSETD, (unsigned long)&ldisc)) < 0) { snd_printk(KERN_ERR "TIOCSETD (N_TTY) failed for tty %s", serial->sdev); goto __end; } /* sanity check, we use disc_data for own purposes */ if (tty->disc_data != NULL) { snd_printk(KERN_ERR "disc_data are used for tty %s", serial->sdev); goto __end; } switch (serial->speed) { case 9600: speed = B9600; break; case 19200: speed = B19200; break; case 38400: speed = B38400; break; case 57600: speed = B57600; break; case 115200: default: speed = B115200; break; } if (serial->handshake) cflag = speed | CREAD | CSIZE | CS8 | CRTSCTS | HUPCL; else cflag = speed | CREAD | CSIZE | CS8 | HUPCL; switch (serial->adaptor) { case SERIAL_ADAPTOR_MS124W_SA: case SERIAL_ADAPTOR_MS124W_MB: case SERIAL_ADAPTOR_MS124T: /* TODO */ break; } old_termios = *tty->termios; ntermios = tty->termios; ntermios->c_lflag = NOFLSH; ntermios->c_iflag = IGNBRK | IGNPAR; ntermios->c_oflag = 0; ntermios->c_cflag = cflag; ntermios->c_cc[VEOL] = 0; /* '\r'; */ ntermios->c_cc[VERASE] = 0; ntermios->c_cc[VKILL] = 0; ntermios->c_cc[VMIN] = 0; ntermios->c_cc[VTIME] = 0; (*driver->set_termios)(tty, &old_termios); serial->tty = tty; /* some magic here, we need own receive_buf */ /* it would be probably better to create own line discipline */ /* but this solution is sufficient at the time */ tty->disc_data = serial; serial->old_receive_buf = tty->ldisc.receive_buf; tty->ldisc.receive_buf = ldisc_receive_buf; serial->old_write_wakeup = tty->ldisc.write_wakeup; tty->ldisc.write_wakeup = ldisc_write_wakeup; serial->old_low_latency = tty->low_latency; tty->low_latency = 1; serial->old_exclusive = test_bit(TTY_EXCLUSIVE, &tty->flags); set_bit(TTY_EXCLUSIVE, &tty->flags); set_bit(mode, &serial->mode); retval = 0; __end: if (retval < 0) { if (serial->file) { filp_close(serial->file, NULL); serial->file = NULL; } } mutex_unlock(&serial->open_lock); return retval; } static int close_tty(serialmidi_t *serial, unsigned int mode) { unsigned int imode = mode == SERIAL_MODE_BIT_INPUT ? SERIAL_MODE_BIT_OUTPUT : SERIAL_MODE_BIT_INPUT; struct tty_struct *tty; mutex_lock(&serial->open_lock); clear_bit(mode, &serial->mode); if (test_bit(imode, &serial->mode)) goto __end; tty = serial->tty; if (tty->disc_data == serial) tty->disc_data = NULL; if (tty && tty->ldisc.receive_buf == ldisc_receive_buf) { tty->low_latency = serial->old_low_latency; tty->ldisc.receive_buf = serial->old_receive_buf; if (serial->old_exclusive) set_bit(TTY_EXCLUSIVE, &tty->flags); else clear_bit(TTY_EXCLUSIVE, &tty->flags); } filp_close(serial->file, NULL); serial->tty = NULL; serial->file = NULL; __end: mutex_unlock(&serial->open_lock); return 0; } static void ldisc_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count) { serialmidi_t *serial = tty->disc_data; if (serial == NULL) return; if (!test_bit(SERIAL_MODE_BIT_INPUT_TRIGGERED, &serial->mode)) return; snd_rawmidi_receive(serial->substream_input, cp, count); } static void tx_loop(serialmidi_t *serial) { struct tty_struct *tty; char *buf = serial->tx_buf; int count; struct tty_driver *driver; tty = serial->tty; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0) /* correct version? */ driver = tty->driver; #else driver = &tty->driver; #endif if (driver == NULL) return; if (down_trylock(&tty->atomic_write)) return; while (1) { count = driver->write_room(tty); if (count <= 0) { up(&tty->atomic_write); return; } count = count > TX_BUF_SIZE ? TX_BUF_SIZE : count; count = snd_rawmidi_transmit_peek(serial->substream_output, buf, count); if (count > 0) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 10) driver->write(tty, buf, count); #else count = driver->write(tty, 0, buf, count); #endif snd_rawmidi_transmit_ack(serial->substream_output, count); } else { clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); break; } } up(&tty->atomic_write); } static void ldisc_write_wakeup(struct tty_struct *tty) { serialmidi_t *serial = tty->disc_data; tx_loop(serial); } static void snd_serialmidi_output_trigger(struct snd_rawmidi_substream *substream, int up) { serialmidi_t *serial = substream->rmidi->private_data; if (up) { set_bit(SERIAL_MODE_BIT_OUTPUT_TRIGGERED, &serial->mode); set_bit(TTY_DO_WRITE_WAKEUP, &serial->tty->flags); tx_loop(serial); } else { clear_bit(TTY_DO_WRITE_WAKEUP, &serial->tty->flags); clear_bit(SERIAL_MODE_BIT_OUTPUT_TRIGGERED, &serial->mode); } } static void snd_serialmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) { serialmidi_t *serial = substream->rmidi->private_data; if (up) { set_bit(SERIAL_MODE_BIT_INPUT_TRIGGERED, &serial->mode); } else { clear_bit(SERIAL_MODE_BIT_INPUT_TRIGGERED, &serial->mode); } } static int snd_serialmidi_output_open(struct snd_rawmidi_substream *substream) { serialmidi_t *serial = substream->rmidi->private_data; int err; if ((err = open_tty(serial, SERIAL_MODE_BIT_OUTPUT)) < 0) return err; serial->substream_output = substream; return 0; } static int snd_serialmidi_output_close(struct snd_rawmidi_substream *substream) { serialmidi_t *serial = substream->rmidi->private_data; serial->substream_output = NULL; return close_tty(serial, SERIAL_MODE_BIT_OUTPUT); } static int snd_serialmidi_input_open(struct snd_rawmidi_substream *substream) { serialmidi_t *serial = substream->rmidi->private_data; int err; if ((err = open_tty(serial, SERIAL_MODE_BIT_INPUT)) < 0) return err; serial->substream_input = substream; return 0; } static int snd_serialmidi_input_close(struct snd_rawmidi_substream *substream) { serialmidi_t *serial = substream->rmidi->private_data; serial->substream_input = NULL; return close_tty(serial, SERIAL_MODE_BIT_INPUT); } static struct snd_rawmidi_ops snd_serialmidi_output = { .open = snd_serialmidi_output_open, .close = snd_serialmidi_output_close, .trigger = snd_serialmidi_output_trigger, }; static struct snd_rawmidi_ops snd_serialmidi_input = { .open = snd_serialmidi_input_open, .close = snd_serialmidi_input_close, .trigger = snd_serialmidi_input_trigger, }; static int snd_serialmidi_free(serialmidi_t *serial) { if (serial->sdev); kfree(serial->sdev); kfree(serial); return 0; } static int snd_serialmidi_dev_free(struct snd_device *device) { serialmidi_t *serial = device->device_data; return snd_serialmidi_free(serial); } static int __init snd_serialmidi_rmidi(serialmidi_t *serial) { struct snd_rawmidi *rrawmidi; int err; if ((err = snd_rawmidi_new(serial->card, "UART Serial MIDI", serial->dev_idx, serial->outs, 1, &rrawmidi)) < 0) return err; snd_rawmidi_set_ops(rrawmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_serialmidi_input); snd_rawmidi_set_ops(rrawmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_serialmidi_output); snprintf(rrawmidi->name, sizeof(rrawmidi->name), "%s %d", serial->card->shortname, serial->dev_idx); rrawmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; rrawmidi->private_data = serial; serial->rmidi = rrawmidi; return 0; } static int __init snd_serialmidi_create(struct snd_card *card, const char *sdev, unsigned int speed, unsigned int adaptor, unsigned int outs, int idx, int hshake) { static struct snd_device_ops ops = { .dev_free = snd_serialmidi_dev_free, }; serialmidi_t *serial; int err; switch (adaptor) { case SERIAL_ADAPTOR_SOUNDCANVAS: break; case SERIAL_ADAPTOR_MS124T: case SERIAL_ADAPTOR_MS124W_SA: outs = 1; break; case SERIAL_ADAPTOR_MS124W_MB: outs = 16; break; default: snd_printk(KERN_ERR "Adaptor type is out of range 0-%d (%d)\n", SERIAL_ADAPTOR_MAX, adaptor); return -ENODEV; } if (outs < 1) outs = 1; else if (outs > 16) outs = 16; if ((serial = kzalloc(sizeof(*serial), GFP_KERNEL)) == NULL) return -ENOMEM; mutex_init(&serial->open_lock); serial->card = card; serial->dev_idx = idx; serial->sdev = kstrdup(sdev, GFP_KERNEL); if (serial->sdev == NULL) { snd_serialmidi_free(serial); return -ENOMEM; } serial->adaptor = adaptor; serial->speed = speed; serial->outs = outs; serial->handshake = hshake; memset(serial->prev_status, 0x80, sizeof(unsigned char) * SNDRV_SERIAL_MAX_OUTS); /* Register device */ if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, serial, &ops)) < 0) { snd_serialmidi_free(serial); return err; } if ((err = snd_serialmidi_rmidi(serial)) < 0) { snd_device_free(card, serial); return err; } return 0; } static int __init snd_serial_probe(struct platform_device *devptr) { struct snd_card *card; int err; int dev = devptr->id; card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); if (card == NULL) return -ENOMEM; strcpy(card->driver, "Serial MIDI"); if (id[dev] && *id[dev]) snprintf(card->shortname, sizeof(card->shortname), "%s", id[dev]); else strcpy(card->shortname, card->driver); if (devices[dev] > 1) { int i, start_dev; char devname[32]; /* assign multiple devices to a single card */ if (devices[dev] > 8) { printk(KERN_ERR "serialmidi: invalid devices %d\n", devices[dev]); snd_card_free(card); return -EINVAL; } /* device name mangling */ strncpy(devname, sdev[dev], sizeof(devname)); devname[31] = 0; i = strlen(devname); if (i > 0) i--; if (devname[i] >= '0' && devname[i] <= '9') { for (; i > 0; i--) if (devname[i] < '0' || devname[i] > '9') { i++; break; } start_dev = simple_strtoul(devname + i, NULL, 0); devname[i] = 0; } else start_dev = 0; for (i = 0; i < devices[dev]; i++) { char devname2[33]; sprintf(devname2, "%s%d", devname, start_dev + i); if ((err = snd_serialmidi_create(card, devname2, speed[dev], adaptor[dev], outs[dev], i, handshake[dev])) < 0) { snd_card_free(card); return err; } } } else { if ((err = snd_serialmidi_create(card, sdev[dev], speed[dev], adaptor[dev], outs[dev], 0, handshake[dev])) < 0) { snd_card_free(card); return err; } } sprintf(card->longname, "%s at %s", card->shortname, sdev[dev]); snd_card_set_dev(card, &devptr->dev); if ((err = snd_card_register(card)) < 0) { snd_card_free(card); return err; } platform_set_drvdata(devptr, card); return 0; } static int snd_serial_remove(struct platform_device *devptr) { snd_card_free(platform_get_drvdata(devptr)); platform_set_drvdata(devptr, NULL); return 0; } #define SND_SERIAL_DRIVER "snd_serial" static struct platform_driver snd_serial_driver = { .probe = snd_serial_probe, .remove = snd_serial_remove, .driver = { .name = SND_SERIAL_DRIVER }, }; static void __init_or_module snd_serial_unregister_all(void) { int i; for (i = 0; i < ARRAY_SIZE(devices); ++i) platform_device_unregister(devptrs[i]); platform_driver_unregister(&snd_serial_driver); } static int __init alsa_card_serialmidi_init(void) { int i, cards, err; if ((err = platform_driver_register(&snd_serial_driver)) < 0) return err; cards = 0; for (i = 0; i < SNDRV_CARDS; i++) { struct platform_device *device; if (! enable[i]) continue; device = platform_device_register_simple(SND_SERIAL_DRIVER, i, NULL, 0); if (IS_ERR(device)) { err = PTR_ERR(device); goto errout; } devptrs[i] = device; cards++; } if (!cards) { #ifdef MODULE printk(KERN_ERR "serial MIDI device not found or device busy\n"); #endif err = -ENODEV; goto errout; } return 0; errout: snd_serial_unregister_all(); return err; } static void __exit alsa_card_serialmidi_exit(void) { snd_serial_unregister_all(); } module_init(alsa_card_serialmidi_init) module_exit(alsa_card_serialmidi_exit)