1/*
   2 *  Abstract layer for MIDI v1.0 stream
   3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4 *
   5 *
   6 *   This program is free software; you can redistribute it and/or modify
   7 *   it under the terms of the GNU General Public License as published by
   8 *   the Free Software Foundation; either version 2 of the License, or
   9 *   (at your option) any later version.
  10 *
  11 *   This program is distributed in the hope that it will be useful,
  12 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 *   GNU General Public License for more details.
  15 *
  16 *   You should have received a copy of the GNU General Public License
  17 *   along with this program; if not, write to the Free Software
  18 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 *
  20 */
  21
  22#include <sound/core.h>
  23#include <linux/major.h>
  24#include <linux/init.h>
  25#include <linux/sched.h>
  26#include <linux/slab.h>
  27#include <linux/time.h>
  28#include <linux/wait.h>
  29#include <linux/mutex.h>
  30#include <linux/module.h>
  31#include <linux/delay.h>
 
 
  32#include <sound/rawmidi.h>
  33#include <sound/info.h>
  34#include <sound/control.h>
  35#include <sound/minors.h>
  36#include <sound/initval.h>
 
  37
  38MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  39MODULE_DESCRIPTION("Midlevel RawMidi code for ALSA.");
  40MODULE_LICENSE("GPL");
  41
  42#ifdef CONFIG_SND_OSSEMUL
  43static int midi_map[SNDRV_CARDS];
  44static int amidi_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1};
  45module_param_array(midi_map, int, NULL, 0444);
  46MODULE_PARM_DESC(midi_map, "Raw MIDI device number assigned to 1st OSS device.");
  47module_param_array(amidi_map, int, NULL, 0444);
  48MODULE_PARM_DESC(amidi_map, "Raw MIDI device number assigned to 2nd OSS device.");
  49#endif /* CONFIG_SND_OSSEMUL */
  50
  51static int snd_rawmidi_free(struct snd_rawmidi *rawmidi);
  52static int snd_rawmidi_dev_free(struct snd_device *device);
  53static int snd_rawmidi_dev_register(struct snd_device *device);
  54static int snd_rawmidi_dev_disconnect(struct snd_device *device);
  55
  56static LIST_HEAD(snd_rawmidi_devices);
  57static DEFINE_MUTEX(register_mutex);
  58
  59#define rmidi_err(rmidi, fmt, args...) \
  60	dev_err((rmidi)->card->dev, fmt, ##args)
  61#define rmidi_warn(rmidi, fmt, args...) \
  62	dev_warn((rmidi)->card->dev, fmt, ##args)
  63#define rmidi_dbg(rmidi, fmt, args...) \
  64	dev_dbg((rmidi)->card->dev, fmt, ##args)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  65
  66static struct snd_rawmidi *snd_rawmidi_search(struct snd_card *card, int device)
  67{
  68	struct snd_rawmidi *rawmidi;
  69
  70	list_for_each_entry(rawmidi, &snd_rawmidi_devices, list)
  71		if (rawmidi->card == card && rawmidi->device == device)
  72			return rawmidi;
  73	return NULL;
  74}
  75
  76static inline unsigned short snd_rawmidi_file_flags(struct file *file)
  77{
  78	switch (file->f_mode & (FMODE_READ | FMODE_WRITE)) {
  79	case FMODE_WRITE:
  80		return SNDRV_RAWMIDI_LFLG_OUTPUT;
  81	case FMODE_READ:
  82		return SNDRV_RAWMIDI_LFLG_INPUT;
  83	default:
  84		return SNDRV_RAWMIDI_LFLG_OPEN;
  85	}
  86}
  87
  88static inline int snd_rawmidi_ready(struct snd_rawmidi_substream *substream)
  89{
  90	struct snd_rawmidi_runtime *runtime = substream->runtime;
  91	return runtime->avail >= runtime->avail_min;
  92}
  93
 
 
 
 
 
 
  94static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream *substream,
  95					   size_t count)
  96{
  97	struct snd_rawmidi_runtime *runtime = substream->runtime;
 
  98	return runtime->avail >= runtime->avail_min &&
  99	       (!substream->append || runtime->avail >= count);
 100}
 101
 102static void snd_rawmidi_input_event_work(struct work_struct *work)
 103{
 104	struct snd_rawmidi_runtime *runtime =
 105		container_of(work, struct snd_rawmidi_runtime, event_work);
 
 106	if (runtime->event)
 107		runtime->event(runtime->substream);
 108}
 109
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 110static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream *substream)
 111{
 112	struct snd_rawmidi_runtime *runtime;
 113
 114	if ((runtime = kzalloc(sizeof(*runtime), GFP_KERNEL)) == NULL)
 
 115		return -ENOMEM;
 116	runtime->substream = substream;
 117	spin_lock_init(&runtime->lock);
 118	init_waitqueue_head(&runtime->sleep);
 119	INIT_WORK(&runtime->event_work, snd_rawmidi_input_event_work);
 120	runtime->event = NULL;
 121	runtime->buffer_size = PAGE_SIZE;
 122	runtime->avail_min = 1;
 123	if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT)
 124		runtime->avail = 0;
 125	else
 126		runtime->avail = runtime->buffer_size;
 127	if ((runtime->buffer = kmalloc(runtime->buffer_size, GFP_KERNEL)) == NULL) {
 
 128		kfree(runtime);
 129		return -ENOMEM;
 130	}
 131	runtime->appl_ptr = runtime->hw_ptr = 0;
 132	substream->runtime = runtime;
 
 
 133	return 0;
 134}
 135
 
 
 
 
 
 
 
 
 
 
 
 
 136static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream *substream)
 137{
 138	struct snd_rawmidi_runtime *runtime = substream->runtime;
 139
 140	kfree(runtime->buffer);
 141	kfree(runtime);
 142	substream->runtime = NULL;
 143	return 0;
 144}
 145
 146static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *substream,int up)
 147{
 148	if (!substream->opened)
 149		return;
 150	substream->ops->trigger(substream, up);
 151}
 152
 153static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up)
 154{
 155	if (!substream->opened)
 156		return;
 157	substream->ops->trigger(substream, up);
 158	if (!up)
 159		cancel_work_sync(&substream->runtime->event_work);
 160}
 161
 162int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream)
 
 163{
 164	unsigned long flags;
 165	struct snd_rawmidi_runtime *runtime = substream->runtime;
 166
 167	snd_rawmidi_output_trigger(substream, 0);
 168	runtime->drain = 0;
 169	spin_lock_irqsave(&runtime->lock, flags);
 170	runtime->appl_ptr = runtime->hw_ptr = 0;
 171	runtime->avail = runtime->buffer_size;
 172	spin_unlock_irqrestore(&runtime->lock, flags);
 
 
 
 
 
 
 
 
 
 
 
 
 
 173	return 0;
 174}
 175EXPORT_SYMBOL(snd_rawmidi_drop_output);
 176
 177int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream)
 178{
 179	int err;
 180	long timeout;
 181	struct snd_rawmidi_runtime *runtime = substream->runtime;
 
 
 
 
 
 
 
 
 182
 183	err = 0;
 184	runtime->drain = 1;
 185	timeout = wait_event_interruptible_timeout(runtime->sleep,
 186				(runtime->avail >= runtime->buffer_size),
 187				10*HZ);
 188	if (signal_pending(current))
 189		err = -ERESTARTSYS;
 190	if (runtime->avail < runtime->buffer_size && !timeout) {
 191		rmidi_warn(substream->rmidi,
 192			   "rawmidi drain error (avail = %li, buffer_size = %li)\n",
 193			   (long)runtime->avail, (long)runtime->buffer_size);
 194		err = -EIO;
 
 
 
 
 195	}
 196	runtime->drain = 0;
 197	if (err != -ERESTARTSYS) {
 198		/* we need wait a while to make sure that Tx FIFOs are empty */
 199		if (substream->ops->drain)
 200			substream->ops->drain(substream);
 201		else
 202			msleep(50);
 203		snd_rawmidi_drop_output(substream);
 204	}
 
 
 
 
 205	return err;
 206}
 207EXPORT_SYMBOL(snd_rawmidi_drain_output);
 208
 209int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream)
 210{
 211	unsigned long flags;
 212	struct snd_rawmidi_runtime *runtime = substream->runtime;
 213
 214	snd_rawmidi_input_trigger(substream, 0);
 215	runtime->drain = 0;
 216	spin_lock_irqsave(&runtime->lock, flags);
 217	runtime->appl_ptr = runtime->hw_ptr = 0;
 218	runtime->avail = 0;
 219	spin_unlock_irqrestore(&runtime->lock, flags);
 220	return 0;
 221}
 222EXPORT_SYMBOL(snd_rawmidi_drain_input);
 223
 224/* look for an available substream for the given stream direction;
 225 * if a specific subdevice is given, try to assign it
 226 */
 227static int assign_substream(struct snd_rawmidi *rmidi, int subdevice,
 228			    int stream, int mode,
 229			    struct snd_rawmidi_substream **sub_ret)
 230{
 231	struct snd_rawmidi_substream *substream;
 232	struct snd_rawmidi_str *s = &rmidi->streams[stream];
 233	static unsigned int info_flags[2] = {
 234		[SNDRV_RAWMIDI_STREAM_OUTPUT] = SNDRV_RAWMIDI_INFO_OUTPUT,
 235		[SNDRV_RAWMIDI_STREAM_INPUT] = SNDRV_RAWMIDI_INFO_INPUT,
 236	};
 237
 238	if (!(rmidi->info_flags & info_flags[stream]))
 239		return -ENXIO;
 240	if (subdevice >= 0 && subdevice >= s->substream_count)
 241		return -ENODEV;
 242
 243	list_for_each_entry(substream, &s->substreams, list) {
 244		if (substream->opened) {
 245			if (stream == SNDRV_RAWMIDI_STREAM_INPUT ||
 246			    !(mode & SNDRV_RAWMIDI_LFLG_APPEND) ||
 247			    !substream->append)
 248				continue;
 249		}
 250		if (subdevice < 0 || subdevice == substream->number) {
 251			*sub_ret = substream;
 252			return 0;
 253		}
 254	}
 255	return -EAGAIN;
 256}
 257
 258/* open and do ref-counting for the given substream */
 259static int open_substream(struct snd_rawmidi *rmidi,
 260			  struct snd_rawmidi_substream *substream,
 261			  int mode)
 262{
 263	int err;
 264
 265	if (substream->use_count == 0) {
 266		err = snd_rawmidi_runtime_create(substream);
 267		if (err < 0)
 268			return err;
 269		err = substream->ops->open(substream);
 270		if (err < 0) {
 271			snd_rawmidi_runtime_free(substream);
 272			return err;
 273		}
 
 274		substream->opened = 1;
 275		substream->active_sensing = 0;
 276		if (mode & SNDRV_RAWMIDI_LFLG_APPEND)
 277			substream->append = 1;
 278		substream->pid = get_pid(task_pid(current));
 279		rmidi->streams[substream->stream].substream_opened++;
 280	}
 281	substream->use_count++;
 282	return 0;
 283}
 284
 285static void close_substream(struct snd_rawmidi *rmidi,
 286			    struct snd_rawmidi_substream *substream,
 287			    int cleanup);
 288
 289static int rawmidi_open_priv(struct snd_rawmidi *rmidi, int subdevice, int mode,
 290			     struct snd_rawmidi_file *rfile)
 291{
 292	struct snd_rawmidi_substream *sinput = NULL, *soutput = NULL;
 293	int err;
 294
 295	rfile->input = rfile->output = NULL;
 296	if (mode & SNDRV_RAWMIDI_LFLG_INPUT) {
 297		err = assign_substream(rmidi, subdevice,
 298				       SNDRV_RAWMIDI_STREAM_INPUT,
 299				       mode, &sinput);
 300		if (err < 0)
 301			return err;
 302	}
 303	if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) {
 304		err = assign_substream(rmidi, subdevice,
 305				       SNDRV_RAWMIDI_STREAM_OUTPUT,
 306				       mode, &soutput);
 307		if (err < 0)
 308			return err;
 309	}
 310
 311	if (sinput) {
 312		err = open_substream(rmidi, sinput, mode);
 313		if (err < 0)
 314			return err;
 315	}
 316	if (soutput) {
 317		err = open_substream(rmidi, soutput, mode);
 318		if (err < 0) {
 319			if (sinput)
 320				close_substream(rmidi, sinput, 0);
 321			return err;
 322		}
 323	}
 324
 325	rfile->rmidi = rmidi;
 326	rfile->input = sinput;
 327	rfile->output = soutput;
 328	return 0;
 329}
 330
 331/* called from sound/core/seq/seq_midi.c */
 332int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice,
 333			    int mode, struct snd_rawmidi_file * rfile)
 334{
 335	struct snd_rawmidi *rmidi;
 336	int err;
 337
 338	if (snd_BUG_ON(!rfile))
 339		return -EINVAL;
 340
 341	mutex_lock(&register_mutex);
 342	rmidi = snd_rawmidi_search(card, device);
 343	if (rmidi == NULL) {
 344		mutex_unlock(&register_mutex);
 345		return -ENODEV;
 346	}
 347	if (!try_module_get(rmidi->card->module)) {
 348		mutex_unlock(&register_mutex);
 349		return -ENXIO;
 350	}
 351	mutex_unlock(&register_mutex);
 352
 353	mutex_lock(&rmidi->open_mutex);
 354	err = rawmidi_open_priv(rmidi, subdevice, mode, rfile);
 355	mutex_unlock(&rmidi->open_mutex);
 356	if (err < 0)
 357		module_put(rmidi->card->module);
 358	return err;
 359}
 360EXPORT_SYMBOL(snd_rawmidi_kernel_open);
 361
 362static int snd_rawmidi_open(struct inode *inode, struct file *file)
 363{
 364	int maj = imajor(inode);
 365	struct snd_card *card;
 366	int subdevice;
 367	unsigned short fflags;
 368	int err;
 369	struct snd_rawmidi *rmidi;
 370	struct snd_rawmidi_file *rawmidi_file = NULL;
 371	wait_queue_t wait;
 372	struct snd_ctl_file *kctl;
 373
 374	if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) 
 375		return -EINVAL;		/* invalid combination */
 376
 377	err = nonseekable_open(inode, file);
 378	if (err < 0)
 379		return err;
 380
 381	if (maj == snd_major) {
 382		rmidi = snd_lookup_minor_data(iminor(inode),
 383					      SNDRV_DEVICE_TYPE_RAWMIDI);
 384#ifdef CONFIG_SND_OSSEMUL
 385	} else if (maj == SOUND_MAJOR) {
 386		rmidi = snd_lookup_oss_minor_data(iminor(inode),
 387						  SNDRV_OSS_DEVICE_TYPE_MIDI);
 388#endif
 389	} else
 390		return -ENXIO;
 391
 392	if (rmidi == NULL)
 393		return -ENODEV;
 394
 395	if (!try_module_get(rmidi->card->module)) {
 396		snd_card_unref(rmidi->card);
 397		return -ENXIO;
 398	}
 399
 400	mutex_lock(&rmidi->open_mutex);
 401	card = rmidi->card;
 402	err = snd_card_file_add(card, file);
 403	if (err < 0)
 404		goto __error_card;
 405	fflags = snd_rawmidi_file_flags(file);
 406	if ((file->f_flags & O_APPEND) || maj == SOUND_MAJOR) /* OSS emul? */
 407		fflags |= SNDRV_RAWMIDI_LFLG_APPEND;
 408	rawmidi_file = kmalloc(sizeof(*rawmidi_file), GFP_KERNEL);
 409	if (rawmidi_file == NULL) {
 410		err = -ENOMEM;
 411		goto __error;
 412	}
 
 413	init_waitqueue_entry(&wait, current);
 414	add_wait_queue(&rmidi->open_wait, &wait);
 415	while (1) {
 416		subdevice = -1;
 417		read_lock(&card->ctl_files_rwlock);
 418		list_for_each_entry(kctl, &card->ctl_files, list) {
 419			if (kctl->pid == task_pid(current)) {
 420				subdevice = kctl->prefer_rawmidi_subdevice;
 421				if (subdevice != -1)
 422					break;
 423			}
 424		}
 425		read_unlock(&card->ctl_files_rwlock);
 426		err = rawmidi_open_priv(rmidi, subdevice, fflags, rawmidi_file);
 427		if (err >= 0)
 428			break;
 429		if (err == -EAGAIN) {
 430			if (file->f_flags & O_NONBLOCK) {
 431				err = -EBUSY;
 432				break;
 433			}
 434		} else
 435			break;
 436		set_current_state(TASK_INTERRUPTIBLE);
 437		mutex_unlock(&rmidi->open_mutex);
 438		schedule();
 439		mutex_lock(&rmidi->open_mutex);
 440		if (rmidi->card->shutdown) {
 441			err = -ENODEV;
 442			break;
 443		}
 444		if (signal_pending(current)) {
 445			err = -ERESTARTSYS;
 446			break;
 447		}
 448	}
 449	remove_wait_queue(&rmidi->open_wait, &wait);
 450	if (err < 0) {
 451		kfree(rawmidi_file);
 452		goto __error;
 453	}
 454#ifdef CONFIG_SND_OSSEMUL
 455	if (rawmidi_file->input && rawmidi_file->input->runtime)
 456		rawmidi_file->input->runtime->oss = (maj == SOUND_MAJOR);
 457	if (rawmidi_file->output && rawmidi_file->output->runtime)
 458		rawmidi_file->output->runtime->oss = (maj == SOUND_MAJOR);
 459#endif
 460	file->private_data = rawmidi_file;
 461	mutex_unlock(&rmidi->open_mutex);
 462	snd_card_unref(rmidi->card);
 463	return 0;
 464
 465 __error:
 466	snd_card_file_remove(card, file);
 467 __error_card:
 468	mutex_unlock(&rmidi->open_mutex);
 469	module_put(rmidi->card->module);
 470	snd_card_unref(rmidi->card);
 471	return err;
 472}
 473
 474static void close_substream(struct snd_rawmidi *rmidi,
 475			    struct snd_rawmidi_substream *substream,
 476			    int cleanup)
 477{
 478	if (--substream->use_count)
 479		return;
 480
 481	if (cleanup) {
 482		if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT)
 483			snd_rawmidi_input_trigger(substream, 0);
 484		else {
 485			if (substream->active_sensing) {
 486				unsigned char buf = 0xfe;
 487				/* sending single active sensing message
 488				 * to shut the device up
 489				 */
 490				snd_rawmidi_kernel_write(substream, &buf, 1);
 491			}
 492			if (snd_rawmidi_drain_output(substream) == -ERESTARTSYS)
 493				snd_rawmidi_output_trigger(substream, 0);
 494		}
 
 
 
 
 
 495	}
 496	substream->ops->close(substream);
 497	if (substream->runtime->private_free)
 498		substream->runtime->private_free(substream);
 499	snd_rawmidi_runtime_free(substream);
 500	substream->opened = 0;
 501	substream->append = 0;
 502	put_pid(substream->pid);
 503	substream->pid = NULL;
 504	rmidi->streams[substream->stream].substream_opened--;
 505}
 506
 507static void rawmidi_release_priv(struct snd_rawmidi_file *rfile)
 508{
 509	struct snd_rawmidi *rmidi;
 510
 511	rmidi = rfile->rmidi;
 512	mutex_lock(&rmidi->open_mutex);
 513	if (rfile->input) {
 514		close_substream(rmidi, rfile->input, 1);
 515		rfile->input = NULL;
 516	}
 517	if (rfile->output) {
 518		close_substream(rmidi, rfile->output, 1);
 519		rfile->output = NULL;
 520	}
 521	rfile->rmidi = NULL;
 522	mutex_unlock(&rmidi->open_mutex);
 523	wake_up(&rmidi->open_wait);
 524}
 525
 526/* called from sound/core/seq/seq_midi.c */
 527int snd_rawmidi_kernel_release(struct snd_rawmidi_file *rfile)
 528{
 529	struct snd_rawmidi *rmidi;
 530
 531	if (snd_BUG_ON(!rfile))
 532		return -ENXIO;
 533	
 534	rmidi = rfile->rmidi;
 535	rawmidi_release_priv(rfile);
 536	module_put(rmidi->card->module);
 537	return 0;
 538}
 539EXPORT_SYMBOL(snd_rawmidi_kernel_release);
 540
 541static int snd_rawmidi_release(struct inode *inode, struct file *file)
 542{
 543	struct snd_rawmidi_file *rfile;
 544	struct snd_rawmidi *rmidi;
 545	struct module *module;
 546
 547	rfile = file->private_data;
 548	rmidi = rfile->rmidi;
 549	rawmidi_release_priv(rfile);
 550	kfree(rfile);
 551	module = rmidi->card->module;
 552	snd_card_file_remove(rmidi->card, file);
 553	module_put(module);
 554	return 0;
 555}
 556
 557static int snd_rawmidi_info(struct snd_rawmidi_substream *substream,
 558			    struct snd_rawmidi_info *info)
 559{
 560	struct snd_rawmidi *rmidi;
 561	
 562	if (substream == NULL)
 563		return -ENODEV;
 564	rmidi = substream->rmidi;
 565	memset(info, 0, sizeof(*info));
 566	info->card = rmidi->card->number;
 567	info->device = rmidi->device;
 568	info->subdevice = substream->number;
 569	info->stream = substream->stream;
 570	info->flags = rmidi->info_flags;
 571	strcpy(info->id, rmidi->id);
 572	strcpy(info->name, rmidi->name);
 573	strcpy(info->subname, substream->name);
 574	info->subdevices_count = substream->pstr->substream_count;
 575	info->subdevices_avail = (substream->pstr->substream_count -
 576				  substream->pstr->substream_opened);
 577	return 0;
 578}
 579
 580static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream,
 581				 struct snd_rawmidi_info __user * _info)
 582{
 583	struct snd_rawmidi_info info;
 584	int err;
 585	if ((err = snd_rawmidi_info(substream, &info)) < 0)
 
 
 586		return err;
 587	if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info)))
 588		return -EFAULT;
 589	return 0;
 590}
 591
 592int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info)
 
 593{
 594	struct snd_rawmidi *rmidi;
 595	struct snd_rawmidi_str *pstr;
 596	struct snd_rawmidi_substream *substream;
 597
 598	mutex_lock(&register_mutex);
 599	rmidi = snd_rawmidi_search(card, info->device);
 600	mutex_unlock(&register_mutex);
 601	if (!rmidi)
 602		return -ENXIO;
 603	if (info->stream < 0 || info->stream > 1)
 604		return -EINVAL;
 
 605	pstr = &rmidi->streams[info->stream];
 606	if (pstr->substream_count == 0)
 607		return -ENOENT;
 608	if (info->subdevice >= pstr->substream_count)
 609		return -ENXIO;
 610	list_for_each_entry(substream, &pstr->substreams, list) {
 611		if ((unsigned int)substream->number == info->subdevice)
 612			return snd_rawmidi_info(substream, info);
 613	}
 614	return -ENXIO;
 615}
 
 
 
 
 
 
 616EXPORT_SYMBOL(snd_rawmidi_info_select);
 617
 618static int snd_rawmidi_info_select_user(struct snd_card *card,
 619					struct snd_rawmidi_info __user *_info)
 620{
 621	int err;
 622	struct snd_rawmidi_info info;
 
 623	if (get_user(info.device, &_info->device))
 624		return -EFAULT;
 625	if (get_user(info.stream, &_info->stream))
 626		return -EFAULT;
 627	if (get_user(info.subdevice, &_info->subdevice))
 628		return -EFAULT;
 629	if ((err = snd_rawmidi_info_select(card, &info)) < 0)
 
 630		return err;
 631	if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info)))
 632		return -EFAULT;
 633	return 0;
 634}
 635
 636int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream,
 637			      struct snd_rawmidi_params * params)
 
 638{
 639	char *newbuf;
 640	struct snd_rawmidi_runtime *runtime = substream->runtime;
 641	
 642	if (substream->append && substream->use_count > 1)
 643		return -EBUSY;
 644	snd_rawmidi_drain_output(substream);
 645	if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L) {
 646		return -EINVAL;
 647	}
 648	if (params->avail_min < 1 || params->avail_min > params->buffer_size) {
 
 
 
 649		return -EINVAL;
 650	}
 651	if (params->buffer_size != runtime->buffer_size) {
 652		newbuf = krealloc(runtime->buffer, params->buffer_size,
 653				  GFP_KERNEL);
 654		if (!newbuf)
 655			return -ENOMEM;
 
 
 
 
 
 
 656		runtime->buffer = newbuf;
 657		runtime->buffer_size = params->buffer_size;
 658		runtime->avail = runtime->buffer_size;
 
 659	}
 660	runtime->avail_min = params->avail_min;
 661	substream->active_sensing = !params->no_active_sensing;
 662	return 0;
 663}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 664EXPORT_SYMBOL(snd_rawmidi_output_params);
 665
 666int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream,
 667			     struct snd_rawmidi_params * params)
 668{
 669	char *newbuf;
 670	struct snd_rawmidi_runtime *runtime = substream->runtime;
 
 671
 672	snd_rawmidi_drain_input(substream);
 673	if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L) {
 674		return -EINVAL;
 675	}
 676	if (params->avail_min < 1 || params->avail_min > params->buffer_size) {
 677		return -EINVAL;
 678	}
 679	if (params->buffer_size != runtime->buffer_size) {
 680		newbuf = krealloc(runtime->buffer, params->buffer_size,
 681				  GFP_KERNEL);
 682		if (!newbuf)
 683			return -ENOMEM;
 684		runtime->buffer = newbuf;
 685		runtime->buffer_size = params->buffer_size;
 686	}
 687	runtime->avail_min = params->avail_min;
 688	return 0;
 689}
 690EXPORT_SYMBOL(snd_rawmidi_input_params);
 691
 692static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream,
 693				     struct snd_rawmidi_status * status)
 694{
 695	struct snd_rawmidi_runtime *runtime = substream->runtime;
 696
 697	memset(status, 0, sizeof(*status));
 698	status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT;
 699	spin_lock_irq(&runtime->lock);
 700	status->avail = runtime->avail;
 701	spin_unlock_irq(&runtime->lock);
 702	return 0;
 703}
 704
 705static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream,
 706				    struct snd_rawmidi_status * status)
 707{
 708	struct snd_rawmidi_runtime *runtime = substream->runtime;
 709
 710	memset(status, 0, sizeof(*status));
 711	status->stream = SNDRV_RAWMIDI_STREAM_INPUT;
 712	spin_lock_irq(&runtime->lock);
 713	status->avail = runtime->avail;
 714	status->xruns = runtime->xruns;
 715	runtime->xruns = 0;
 716	spin_unlock_irq(&runtime->lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 717	return 0;
 718}
 719
 720static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 721{
 722	struct snd_rawmidi_file *rfile;
 
 723	void __user *argp = (void __user *)arg;
 724
 725	rfile = file->private_data;
 726	if (((cmd >> 8) & 0xff) != 'W')
 727		return -ENOTTY;
 728	switch (cmd) {
 729	case SNDRV_RAWMIDI_IOCTL_PVERSION:
 730		return put_user(SNDRV_RAWMIDI_VERSION, (int __user *)argp) ? -EFAULT : 0;
 731	case SNDRV_RAWMIDI_IOCTL_INFO:
 732	{
 733		int stream;
 734		struct snd_rawmidi_info __user *info = argp;
 
 735		if (get_user(stream, &info->stream))
 736			return -EFAULT;
 737		switch (stream) {
 738		case SNDRV_RAWMIDI_STREAM_INPUT:
 739			return snd_rawmidi_info_user(rfile->input, info);
 740		case SNDRV_RAWMIDI_STREAM_OUTPUT:
 741			return snd_rawmidi_info_user(rfile->output, info);
 742		default:
 743			return -EINVAL;
 744		}
 745	}
 
 
 
 
 
 746	case SNDRV_RAWMIDI_IOCTL_PARAMS:
 747	{
 748		struct snd_rawmidi_params params;
 
 749		if (copy_from_user(&params, argp, sizeof(struct snd_rawmidi_params)))
 750			return -EFAULT;
 
 
 
 
 751		switch (params.stream) {
 752		case SNDRV_RAWMIDI_STREAM_OUTPUT:
 753			if (rfile->output == NULL)
 754				return -EINVAL;
 755			return snd_rawmidi_output_params(rfile->output, &params);
 756		case SNDRV_RAWMIDI_STREAM_INPUT:
 757			if (rfile->input == NULL)
 758				return -EINVAL;
 759			return snd_rawmidi_input_params(rfile->input, &params);
 760		default:
 761			return -EINVAL;
 762		}
 763	}
 764	case SNDRV_RAWMIDI_IOCTL_STATUS:
 765	{
 766		int err = 0;
 767		struct snd_rawmidi_status status;
 768		if (copy_from_user(&status, argp, sizeof(struct snd_rawmidi_status)))
 769			return -EFAULT;
 770		switch (status.stream) {
 771		case SNDRV_RAWMIDI_STREAM_OUTPUT:
 772			if (rfile->output == NULL)
 773				return -EINVAL;
 774			err = snd_rawmidi_output_status(rfile->output, &status);
 775			break;
 776		case SNDRV_RAWMIDI_STREAM_INPUT:
 777			if (rfile->input == NULL)
 778				return -EINVAL;
 779			err = snd_rawmidi_input_status(rfile->input, &status);
 780			break;
 781		default:
 782			return -EINVAL;
 783		}
 784		if (err < 0)
 785			return err;
 786		if (copy_to_user(argp, &status, sizeof(struct snd_rawmidi_status)))
 787			return -EFAULT;
 788		return 0;
 789	}
 790	case SNDRV_RAWMIDI_IOCTL_DROP:
 791	{
 792		int val;
 
 793		if (get_user(val, (int __user *) argp))
 794			return -EFAULT;
 795		switch (val) {
 796		case SNDRV_RAWMIDI_STREAM_OUTPUT:
 797			if (rfile->output == NULL)
 798				return -EINVAL;
 799			return snd_rawmidi_drop_output(rfile->output);
 800		default:
 801			return -EINVAL;
 802		}
 803	}
 804	case SNDRV_RAWMIDI_IOCTL_DRAIN:
 805	{
 806		int val;
 
 807		if (get_user(val, (int __user *) argp))
 808			return -EFAULT;
 809		switch (val) {
 810		case SNDRV_RAWMIDI_STREAM_OUTPUT:
 811			if (rfile->output == NULL)
 812				return -EINVAL;
 813			return snd_rawmidi_drain_output(rfile->output);
 814		case SNDRV_RAWMIDI_STREAM_INPUT:
 815			if (rfile->input == NULL)
 816				return -EINVAL;
 817			return snd_rawmidi_drain_input(rfile->input);
 818		default:
 819			return -EINVAL;
 820		}
 821	}
 822	default:
 823		rmidi_dbg(rfile->rmidi,
 824			  "rawmidi: unknown command = 0x%x\n", cmd);
 
 
 825	}
 826	return -ENOTTY;
 827}
 828
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 829static int snd_rawmidi_control_ioctl(struct snd_card *card,
 830				     struct snd_ctl_file *control,
 831				     unsigned int cmd,
 832				     unsigned long arg)
 833{
 834	void __user *argp = (void __user *)arg;
 835
 836	switch (cmd) {
 837	case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE:
 838	{
 839		int device;
 840		
 841		if (get_user(device, (int __user *)argp))
 842			return -EFAULT;
 843		if (device >= SNDRV_RAWMIDI_DEVICES) /* next device is -1 */
 844			device = SNDRV_RAWMIDI_DEVICES - 1;
 845		mutex_lock(&register_mutex);
 846		device = device < 0 ? 0 : device + 1;
 847		while (device < SNDRV_RAWMIDI_DEVICES) {
 848			if (snd_rawmidi_search(card, device))
 849				break;
 850			device++;
 851		}
 852		if (device == SNDRV_RAWMIDI_DEVICES)
 853			device = -1;
 854		mutex_unlock(&register_mutex);
 855		if (put_user(device, (int __user *)argp))
 856			return -EFAULT;
 857		return 0;
 858	}
 859	case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE:
 860	{
 861		int val;
 862		
 863		if (get_user(val, (int __user *)argp))
 864			return -EFAULT;
 865		control->prefer_rawmidi_subdevice = val;
 866		return 0;
 867	}
 868	case SNDRV_CTL_IOCTL_RAWMIDI_INFO:
 869		return snd_rawmidi_info_select_user(card, argp);
 870	}
 871	return -ENOIOCTLCMD;
 872}
 873
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 874/**
 875 * snd_rawmidi_receive - receive the input data from the device
 876 * @substream: the rawmidi substream
 877 * @buffer: the buffer pointer
 878 * @count: the data size to read
 879 *
 880 * Reads the data from the internal buffer.
 881 *
 882 * Return: The size of read data, or a negative error code on failure.
 883 */
 884int snd_rawmidi_receive(struct snd_rawmidi_substream *substream,
 885			const unsigned char *buffer, int count)
 886{
 887	unsigned long flags;
 888	int result = 0, count1;
 889	struct snd_rawmidi_runtime *runtime = substream->runtime;
 890
 
 891	if (!substream->opened)
 892		return -EBADFD;
 893	if (runtime->buffer == NULL) {
 
 894		rmidi_dbg(substream->rmidi,
 895			  "snd_rawmidi_receive: input is not active!!!\n");
 896		return -EINVAL;
 897	}
 898	spin_lock_irqsave(&runtime->lock, flags);
 899	if (count == 1) {	/* special case, faster code */
 
 
 
 
 
 
 900		substream->bytes++;
 901		if (runtime->avail < runtime->buffer_size) {
 902			runtime->buffer[runtime->hw_ptr++] = buffer[0];
 903			runtime->hw_ptr %= runtime->buffer_size;
 904			runtime->avail++;
 905			result++;
 906		} else {
 907			runtime->xruns++;
 908		}
 909	} else {
 910		substream->bytes += count;
 911		count1 = runtime->buffer_size - runtime->hw_ptr;
 912		if (count1 > count)
 913			count1 = count;
 914		if (count1 > (int)(runtime->buffer_size - runtime->avail))
 915			count1 = runtime->buffer_size - runtime->avail;
 
 
 
 916		memcpy(runtime->buffer + runtime->hw_ptr, buffer, count1);
 917		runtime->hw_ptr += count1;
 918		runtime->hw_ptr %= runtime->buffer_size;
 919		runtime->avail += count1;
 920		count -= count1;
 921		result += count1;
 922		if (count > 0) {
 923			buffer += count1;
 924			count1 = count;
 925			if (count1 > (int)(runtime->buffer_size - runtime->avail)) {
 926				count1 = runtime->buffer_size - runtime->avail;
 927				runtime->xruns += count - count1;
 928			}
 929			if (count1 > 0) {
 930				memcpy(runtime->buffer, buffer, count1);
 931				runtime->hw_ptr = count1;
 932				runtime->avail += count1;
 933				result += count1;
 934			}
 935		}
 936	}
 937	if (result > 0) {
 938		if (runtime->event)
 939			schedule_work(&runtime->event_work);
 940		else if (snd_rawmidi_ready(substream))
 941			wake_up(&runtime->sleep);
 942	}
 943	spin_unlock_irqrestore(&runtime->lock, flags);
 944	return result;
 945}
 946EXPORT_SYMBOL(snd_rawmidi_receive);
 947
 948static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream,
 949				     unsigned char __user *userbuf,
 950				     unsigned char *kernelbuf, long count)
 951{
 952	unsigned long flags;
 953	long result = 0, count1;
 954	struct snd_rawmidi_runtime *runtime = substream->runtime;
 
 
 955
 
 
 956	while (count > 0 && runtime->avail) {
 957		count1 = runtime->buffer_size - runtime->appl_ptr;
 958		if (count1 > count)
 959			count1 = count;
 960		spin_lock_irqsave(&runtime->lock, flags);
 961		if (count1 > (int)runtime->avail)
 962			count1 = runtime->avail;
 
 
 
 
 
 
 
 963		if (kernelbuf)
 964			memcpy(kernelbuf + result, runtime->buffer + runtime->appl_ptr, count1);
 965		if (userbuf) {
 966			spin_unlock_irqrestore(&runtime->lock, flags);
 967			if (copy_to_user(userbuf + result,
 968					 runtime->buffer + runtime->appl_ptr, count1)) {
 969				return result > 0 ? result : -EFAULT;
 970			}
 971			spin_lock_irqsave(&runtime->lock, flags);
 
 972		}
 973		runtime->appl_ptr += count1;
 974		runtime->appl_ptr %= runtime->buffer_size;
 975		runtime->avail -= count1;
 976		spin_unlock_irqrestore(&runtime->lock, flags);
 977		result += count1;
 978		count -= count1;
 979	}
 980	return result;
 
 
 
 981}
 982
 983long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream,
 984			     unsigned char *buf, long count)
 985{
 986	snd_rawmidi_input_trigger(substream, 1);
 987	return snd_rawmidi_kernel_read1(substream, NULL/*userbuf*/, buf, count);
 988}
 989EXPORT_SYMBOL(snd_rawmidi_kernel_read);
 990
 991static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count,
 992				loff_t *offset)
 993{
 994	long result;
 995	int count1;
 996	struct snd_rawmidi_file *rfile;
 997	struct snd_rawmidi_substream *substream;
 998	struct snd_rawmidi_runtime *runtime;
 999
1000	rfile = file->private_data;
1001	substream = rfile->input;
1002	if (substream == NULL)
1003		return -EIO;
1004	runtime = substream->runtime;
1005	snd_rawmidi_input_trigger(substream, 1);
1006	result = 0;
1007	while (count > 0) {
1008		spin_lock_irq(&runtime->lock);
1009		while (!snd_rawmidi_ready(substream)) {
1010			wait_queue_t wait;
 
1011			if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1012				spin_unlock_irq(&runtime->lock);
1013				return result > 0 ? result : -EAGAIN;
1014			}
1015			init_waitqueue_entry(&wait, current);
1016			add_wait_queue(&runtime->sleep, &wait);
1017			set_current_state(TASK_INTERRUPTIBLE);
1018			spin_unlock_irq(&runtime->lock);
1019			schedule();
1020			remove_wait_queue(&runtime->sleep, &wait);
1021			if (rfile->rmidi->card->shutdown)
1022				return -ENODEV;
1023			if (signal_pending(current))
1024				return result > 0 ? result : -ERESTARTSYS;
1025			if (!runtime->avail)
 
 
1026				return result > 0 ? result : -EIO;
1027			spin_lock_irq(&runtime->lock);
1028		}
1029		spin_unlock_irq(&runtime->lock);
1030		count1 = snd_rawmidi_kernel_read1(substream,
1031						  (unsigned char __user *)buf,
1032						  NULL/*kernelbuf*/,
1033						  count);
1034		if (count1 < 0)
1035			return result > 0 ? result : count1;
1036		result += count1;
1037		buf += count1;
1038		count -= count1;
1039	}
1040	return result;
1041}
1042
1043/**
1044 * snd_rawmidi_transmit_empty - check whether the output buffer is empty
1045 * @substream: the rawmidi substream
1046 *
1047 * Return: 1 if the internal output buffer is empty, 0 if not.
1048 */
1049int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream)
1050{
1051	struct snd_rawmidi_runtime *runtime = substream->runtime;
1052	int result;
1053	unsigned long flags;
1054
1055	if (runtime->buffer == NULL) {
 
 
1056		rmidi_dbg(substream->rmidi,
1057			  "snd_rawmidi_transmit_empty: output is not active!!!\n");
1058		return 1;
1059	}
1060	spin_lock_irqsave(&runtime->lock, flags);
1061	result = runtime->avail >= runtime->buffer_size;
1062	spin_unlock_irqrestore(&runtime->lock, flags);
1063	return result;		
1064}
1065EXPORT_SYMBOL(snd_rawmidi_transmit_empty);
1066
1067/**
1068 * snd_rawmidi_transmit_peek - copy data from the internal buffer
1069 * @substream: the rawmidi substream
1070 * @buffer: the buffer pointer
1071 * @count: data size to transfer
1072 *
1073 * Copies data from the internal output buffer to the given buffer.
1074 *
1075 * Call this in the interrupt handler when the midi output is ready,
1076 * and call snd_rawmidi_transmit_ack() after the transmission is
1077 * finished.
1078 *
1079 * Return: The size of copied data, or a negative error code on failure.
1080 */
1081int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
1082			      unsigned char *buffer, int count)
1083{
1084	unsigned long flags;
1085	int result, count1;
1086	struct snd_rawmidi_runtime *runtime = substream->runtime;
1087
1088	if (runtime->buffer == NULL) {
1089		rmidi_dbg(substream->rmidi,
1090			  "snd_rawmidi_transmit_peek: output is not active!!!\n");
1091		return -EINVAL;
1092	}
1093	result = 0;
1094	spin_lock_irqsave(&runtime->lock, flags);
1095	if (runtime->avail >= runtime->buffer_size) {
1096		/* warning: lowlevel layer MUST trigger down the hardware */
1097		goto __skip;
1098	}
1099	if (count == 1) {	/* special case, faster code */
1100		*buffer = runtime->buffer[runtime->hw_ptr];
1101		result++;
1102	} else {
1103		count1 = runtime->buffer_size - runtime->hw_ptr;
1104		if (count1 > count)
1105			count1 = count;
1106		if (count1 > (int)(runtime->buffer_size - runtime->avail))
1107			count1 = runtime->buffer_size - runtime->avail;
 
 
 
1108		memcpy(buffer, runtime->buffer + runtime->hw_ptr, count1);
1109		count -= count1;
1110		result += count1;
1111		if (count > 0) {
1112			if (count > (int)(runtime->buffer_size - runtime->avail - count1))
1113				count = runtime->buffer_size - runtime->avail - count1;
 
 
 
1114			memcpy(buffer + count1, runtime->buffer, count);
1115			result += count;
1116		}
1117	}
1118      __skip:
1119	spin_unlock_irqrestore(&runtime->lock, flags);
1120	return result;
1121}
1122EXPORT_SYMBOL(snd_rawmidi_transmit_peek);
1123
1124/**
1125 * snd_rawmidi_transmit_ack - acknowledge the transmission
1126 * @substream: the rawmidi substream
1127 * @count: the transferred count
 
1128 *
1129 * Advances the hardware pointer for the internal output buffer with
1130 * the given size and updates the condition.
1131 * Call after the transmission is finished.
1132 *
1133 * Return: The advanced size if successful, or a negative error code on failure.
 
 
 
 
1134 */
1135int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1136{
1137	unsigned long flags;
1138	struct snd_rawmidi_runtime *runtime = substream->runtime;
1139
1140	if (runtime->buffer == NULL) {
1141		rmidi_dbg(substream->rmidi,
1142			  "snd_rawmidi_transmit_ack: output is not active!!!\n");
1143		return -EINVAL;
1144	}
1145	spin_lock_irqsave(&runtime->lock, flags);
1146	snd_BUG_ON(runtime->avail + count > runtime->buffer_size);
 
1147	runtime->hw_ptr += count;
1148	runtime->hw_ptr %= runtime->buffer_size;
1149	runtime->avail += count;
1150	substream->bytes += count;
1151	if (count > 0) {
1152		if (runtime->drain || snd_rawmidi_ready(substream))
1153			wake_up(&runtime->sleep);
1154	}
1155	spin_unlock_irqrestore(&runtime->lock, flags);
1156	return count;
1157}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1158EXPORT_SYMBOL(snd_rawmidi_transmit_ack);
1159
1160/**
1161 * snd_rawmidi_transmit - copy from the buffer to the device
1162 * @substream: the rawmidi substream
1163 * @buffer: the buffer pointer
1164 * @count: the data size to transfer
1165 * 
1166 * Copies data from the buffer to the device and advances the pointer.
1167 *
1168 * Return: The copied size if successful, or a negative error code on failure.
1169 */
1170int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream,
1171			 unsigned char *buffer, int count)
1172{
 
1173	if (!substream->opened)
1174		return -EBADFD;
1175	count = snd_rawmidi_transmit_peek(substream, buffer, count);
1176	if (count < 0)
1177		return count;
1178	return snd_rawmidi_transmit_ack(substream, count);
1179}
1180EXPORT_SYMBOL(snd_rawmidi_transmit);
1181
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1182static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
1183				      const unsigned char __user *userbuf,
1184				      const unsigned char *kernelbuf,
1185				      long count)
1186{
1187	unsigned long flags;
1188	long count1, result;
1189	struct snd_rawmidi_runtime *runtime = substream->runtime;
 
1190
1191	if (snd_BUG_ON(!kernelbuf && !userbuf))
1192		return -EINVAL;
1193	if (snd_BUG_ON(!runtime->buffer))
1194		return -EINVAL;
1195
1196	result = 0;
1197	spin_lock_irqsave(&runtime->lock, flags);
1198	if (substream->append) {
1199		if ((long)runtime->avail < count) {
1200			spin_unlock_irqrestore(&runtime->lock, flags);
1201			return -EAGAIN;
1202		}
1203	}
 
1204	while (count > 0 && runtime->avail > 0) {
1205		count1 = runtime->buffer_size - runtime->appl_ptr;
1206		if (count1 > count)
1207			count1 = count;
1208		if (count1 > (long)runtime->avail)
1209			count1 = runtime->avail;
 
 
 
 
 
 
 
1210		if (kernelbuf)
1211			memcpy(runtime->buffer + runtime->appl_ptr,
1212			       kernelbuf + result, count1);
1213		else if (userbuf) {
1214			spin_unlock_irqrestore(&runtime->lock, flags);
1215			if (copy_from_user(runtime->buffer + runtime->appl_ptr,
1216					   userbuf + result, count1)) {
1217				spin_lock_irqsave(&runtime->lock, flags);
1218				result = result > 0 ? result : -EFAULT;
1219				goto __end;
1220			}
1221			spin_lock_irqsave(&runtime->lock, flags);
1222		}
1223		runtime->appl_ptr += count1;
1224		runtime->appl_ptr %= runtime->buffer_size;
1225		runtime->avail -= count1;
1226		result += count1;
1227		count -= count1;
1228	}
1229      __end:
1230	count1 = runtime->avail < runtime->buffer_size;
1231	spin_unlock_irqrestore(&runtime->lock, flags);
 
1232	if (count1)
1233		snd_rawmidi_output_trigger(substream, 1);
1234	return result;
1235}
1236
1237long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream,
1238			      const unsigned char *buf, long count)
1239{
1240	return snd_rawmidi_kernel_write1(substream, NULL, buf, count);
1241}
1242EXPORT_SYMBOL(snd_rawmidi_kernel_write);
1243
1244static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf,
1245				 size_t count, loff_t *offset)
1246{
1247	long result, timeout;
1248	int count1;
1249	struct snd_rawmidi_file *rfile;
1250	struct snd_rawmidi_runtime *runtime;
1251	struct snd_rawmidi_substream *substream;
1252
1253	rfile = file->private_data;
1254	substream = rfile->output;
1255	runtime = substream->runtime;
1256	/* we cannot put an atomic message to our buffer */
1257	if (substream->append && count > runtime->buffer_size)
1258		return -EIO;
1259	result = 0;
1260	while (count > 0) {
1261		spin_lock_irq(&runtime->lock);
1262		while (!snd_rawmidi_ready_append(substream, count)) {
1263			wait_queue_t wait;
 
1264			if (file->f_flags & O_NONBLOCK) {
1265				spin_unlock_irq(&runtime->lock);
1266				return result > 0 ? result : -EAGAIN;
1267			}
1268			init_waitqueue_entry(&wait, current);
1269			add_wait_queue(&runtime->sleep, &wait);
1270			set_current_state(TASK_INTERRUPTIBLE);
1271			spin_unlock_irq(&runtime->lock);
1272			timeout = schedule_timeout(30 * HZ);
1273			remove_wait_queue(&runtime->sleep, &wait);
1274			if (rfile->rmidi->card->shutdown)
1275				return -ENODEV;
1276			if (signal_pending(current))
1277				return result > 0 ? result : -ERESTARTSYS;
1278			if (!runtime->avail && !timeout)
 
 
1279				return result > 0 ? result : -EIO;
1280			spin_lock_irq(&runtime->lock);
1281		}
1282		spin_unlock_irq(&runtime->lock);
1283		count1 = snd_rawmidi_kernel_write1(substream, buf, NULL, count);
1284		if (count1 < 0)
1285			return result > 0 ? result : count1;
1286		result += count1;
1287		buf += count1;
1288		if ((size_t)count1 < count && (file->f_flags & O_NONBLOCK))
1289			break;
1290		count -= count1;
1291	}
1292	if (file->f_flags & O_DSYNC) {
1293		spin_lock_irq(&runtime->lock);
1294		while (runtime->avail != runtime->buffer_size) {
1295			wait_queue_t wait;
1296			unsigned int last_avail = runtime->avail;
 
1297			init_waitqueue_entry(&wait, current);
1298			add_wait_queue(&runtime->sleep, &wait);
1299			set_current_state(TASK_INTERRUPTIBLE);
1300			spin_unlock_irq(&runtime->lock);
1301			timeout = schedule_timeout(30 * HZ);
1302			remove_wait_queue(&runtime->sleep, &wait);
1303			if (signal_pending(current))
1304				return result > 0 ? result : -ERESTARTSYS;
1305			if (runtime->avail == last_avail && !timeout)
1306				return result > 0 ? result : -EIO;
1307			spin_lock_irq(&runtime->lock);
1308		}
1309		spin_unlock_irq(&runtime->lock);
1310	}
1311	return result;
1312}
1313
1314static unsigned int snd_rawmidi_poll(struct file *file, poll_table * wait)
1315{
1316	struct snd_rawmidi_file *rfile;
1317	struct snd_rawmidi_runtime *runtime;
1318	unsigned int mask;
1319
1320	rfile = file->private_data;
1321	if (rfile->input != NULL) {
1322		runtime = rfile->input->runtime;
1323		snd_rawmidi_input_trigger(rfile->input, 1);
1324		poll_wait(file, &runtime->sleep, wait);
1325	}
1326	if (rfile->output != NULL) {
1327		runtime = rfile->output->runtime;
1328		poll_wait(file, &runtime->sleep, wait);
1329	}
1330	mask = 0;
1331	if (rfile->input != NULL) {
1332		if (snd_rawmidi_ready(rfile->input))
1333			mask |= POLLIN | POLLRDNORM;
1334	}
1335	if (rfile->output != NULL) {
1336		if (snd_rawmidi_ready(rfile->output))
1337			mask |= POLLOUT | POLLWRNORM;
1338	}
1339	return mask;
1340}
1341
1342/*
1343 */
1344#ifdef CONFIG_COMPAT
1345#include "rawmidi_compat.c"
1346#else
1347#define snd_rawmidi_ioctl_compat	NULL
1348#endif
1349
1350/*
1351
1352 */
1353
1354static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry,
1355				       struct snd_info_buffer *buffer)
1356{
1357	struct snd_rawmidi *rmidi;
1358	struct snd_rawmidi_substream *substream;
1359	struct snd_rawmidi_runtime *runtime;
 
 
 
1360
1361	rmidi = entry->private_data;
1362	snd_iprintf(buffer, "%s\n\n", rmidi->name);
1363	mutex_lock(&rmidi->open_mutex);
 
 
 
 
 
1364	if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) {
1365		list_for_each_entry(substream,
1366				    &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams,
1367				    list) {
1368			snd_iprintf(buffer,
1369				    "Output %d\n"
1370				    "  Tx bytes     : %lu\n",
1371				    substream->number,
1372				    (unsigned long) substream->bytes);
1373			if (substream->opened) {
1374				snd_iprintf(buffer,
1375				    "  Owner PID    : %d\n",
1376				    pid_vnr(substream->pid));
1377				runtime = substream->runtime;
 
 
 
 
1378				snd_iprintf(buffer,
1379				    "  Mode         : %s\n"
1380				    "  Buffer size  : %lu\n"
1381				    "  Avail        : %lu\n",
1382				    runtime->oss ? "OSS compatible" : "native",
1383				    (unsigned long) runtime->buffer_size,
1384				    (unsigned long) runtime->avail);
1385			}
1386		}
1387	}
1388	if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT) {
1389		list_for_each_entry(substream,
1390				    &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams,
1391				    list) {
1392			snd_iprintf(buffer,
1393				    "Input %d\n"
1394				    "  Rx bytes     : %lu\n",
1395				    substream->number,
1396				    (unsigned long) substream->bytes);
1397			if (substream->opened) {
1398				snd_iprintf(buffer,
1399					    "  Owner PID    : %d\n",
1400					    pid_vnr(substream->pid));
1401				runtime = substream->runtime;
 
 
 
 
 
1402				snd_iprintf(buffer,
1403					    "  Buffer size  : %lu\n"
1404					    "  Avail        : %lu\n"
1405					    "  Overruns     : %lu\n",
1406					    (unsigned long) runtime->buffer_size,
1407					    (unsigned long) runtime->avail,
1408					    (unsigned long) runtime->xruns);
 
 
 
 
 
 
1409			}
1410		}
1411	}
1412	mutex_unlock(&rmidi->open_mutex);
1413}
1414
1415/*
1416 *  Register functions
1417 */
1418
1419static const struct file_operations snd_rawmidi_f_ops =
1420{
1421	.owner =	THIS_MODULE,
1422	.read =		snd_rawmidi_read,
1423	.write =	snd_rawmidi_write,
1424	.open =		snd_rawmidi_open,
1425	.release =	snd_rawmidi_release,
1426	.llseek =	no_llseek,
1427	.poll =		snd_rawmidi_poll,
1428	.unlocked_ioctl =	snd_rawmidi_ioctl,
1429	.compat_ioctl =	snd_rawmidi_ioctl_compat,
1430};
1431
1432static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi,
1433					struct snd_rawmidi_str *stream,
1434					int direction,
1435					int count)
1436{
1437	struct snd_rawmidi_substream *substream;
1438	int idx;
1439
1440	for (idx = 0; idx < count; idx++) {
1441		substream = kzalloc(sizeof(*substream), GFP_KERNEL);
1442		if (substream == NULL) {
1443			rmidi_err(rmidi, "rawmidi: cannot allocate substream\n");
1444			return -ENOMEM;
1445		}
1446		substream->stream = direction;
1447		substream->number = idx;
1448		substream->rmidi = rmidi;
1449		substream->pstr = stream;
 
1450		list_add_tail(&substream->list, &stream->substreams);
1451		stream->substream_count++;
1452	}
1453	return 0;
1454}
1455
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1456/**
1457 * snd_rawmidi_new - create a rawmidi instance
1458 * @card: the card instance
1459 * @id: the id string
1460 * @device: the device index
1461 * @output_count: the number of output streams
1462 * @input_count: the number of input streams
1463 * @rrawmidi: the pointer to store the new rawmidi instance
1464 *
1465 * Creates a new rawmidi instance.
1466 * Use snd_rawmidi_set_ops() to set the operators to the new instance.
1467 *
1468 * Return: Zero if successful, or a negative error code on failure.
1469 */
1470int snd_rawmidi_new(struct snd_card *card, char *id, int device,
1471		    int output_count, int input_count,
1472		    struct snd_rawmidi ** rrawmidi)
1473{
1474	struct snd_rawmidi *rmidi;
1475	int err;
1476	static struct snd_device_ops ops = {
1477		.dev_free = snd_rawmidi_dev_free,
1478		.dev_register = snd_rawmidi_dev_register,
1479		.dev_disconnect = snd_rawmidi_dev_disconnect,
1480	};
1481
1482	if (snd_BUG_ON(!card))
1483		return -ENXIO;
1484	if (rrawmidi)
1485		*rrawmidi = NULL;
1486	rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL);
1487	if (rmidi == NULL) {
1488		dev_err(card->dev, "rawmidi: cannot allocate\n");
1489		return -ENOMEM;
1490	}
1491	rmidi->card = card;
1492	rmidi->device = device;
1493	mutex_init(&rmidi->open_mutex);
1494	init_waitqueue_head(&rmidi->open_wait);
1495	INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams);
1496	INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams);
1497
1498	if (id != NULL)
1499		strlcpy(rmidi->id, id, sizeof(rmidi->id));
1500	if ((err = snd_rawmidi_alloc_substreams(rmidi,
1501						&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT],
1502						SNDRV_RAWMIDI_STREAM_INPUT,
1503						input_count)) < 0) {
1504		snd_rawmidi_free(rmidi);
1505		return err;
1506	}
1507	if ((err = snd_rawmidi_alloc_substreams(rmidi,
1508						&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT],
1509						SNDRV_RAWMIDI_STREAM_OUTPUT,
1510						output_count)) < 0) {
1511		snd_rawmidi_free(rmidi);
1512		return err;
1513	}
1514	if ((err = snd_device_new(card, SNDRV_DEV_RAWMIDI, rmidi, &ops)) < 0) {
1515		snd_rawmidi_free(rmidi);
1516		return err;
1517	}
1518	if (rrawmidi)
1519		*rrawmidi = rmidi;
1520	return 0;
1521}
1522EXPORT_SYMBOL(snd_rawmidi_new);
1523
1524static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream)
1525{
1526	struct snd_rawmidi_substream *substream;
1527
1528	while (!list_empty(&stream->substreams)) {
1529		substream = list_entry(stream->substreams.next, struct snd_rawmidi_substream, list);
1530		list_del(&substream->list);
1531		kfree(substream);
1532	}
1533}
1534
1535static int snd_rawmidi_free(struct snd_rawmidi *rmidi)
 
1536{
1537	if (!rmidi)
1538		return 0;
1539
1540	snd_info_free_entry(rmidi->proc_entry);
1541	rmidi->proc_entry = NULL;
1542	mutex_lock(&register_mutex);
1543	if (rmidi->ops && rmidi->ops->dev_unregister)
1544		rmidi->ops->dev_unregister(rmidi);
1545	mutex_unlock(&register_mutex);
1546
1547	snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]);
1548	snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]);
1549	if (rmidi->private_free)
1550		rmidi->private_free(rmidi);
 
1551	kfree(rmidi);
1552	return 0;
1553}
 
1554
1555static int snd_rawmidi_dev_free(struct snd_device *device)
1556{
1557	struct snd_rawmidi *rmidi = device->device_data;
 
1558	return snd_rawmidi_free(rmidi);
1559}
1560
1561#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
1562static void snd_rawmidi_dev_seq_free(struct snd_seq_device *device)
1563{
1564	struct snd_rawmidi *rmidi = device->private_data;
 
1565	rmidi->seq_dev = NULL;
1566}
1567#endif
1568
1569static int snd_rawmidi_dev_register(struct snd_device *device)
1570{
1571	int err;
1572	struct snd_info_entry *entry;
1573	char name[16];
1574	struct snd_rawmidi *rmidi = device->device_data;
1575
1576	if (rmidi->device >= SNDRV_RAWMIDI_DEVICES)
1577		return -ENOMEM;
1578	mutex_lock(&register_mutex);
1579	if (snd_rawmidi_search(rmidi->card, rmidi->device)) {
1580		mutex_unlock(&register_mutex);
1581		return -EBUSY;
 
 
1582	}
1583	list_add_tail(&rmidi->list, &snd_rawmidi_devices);
1584	sprintf(name, "midiC%iD%i", rmidi->card->number, rmidi->device);
1585	if ((err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI,
1586				       rmidi->card, rmidi->device,
1587				       &snd_rawmidi_f_ops, rmidi, name)) < 0) {
1588		rmidi_err(rmidi, "unable to register rawmidi device %i:%i\n",
1589			  rmidi->card->number, rmidi->device);
1590		list_del(&rmidi->list);
1591		mutex_unlock(&register_mutex);
1592		return err;
 
 
 
 
 
 
 
1593	}
1594	if (rmidi->ops && rmidi->ops->dev_register &&
1595	    (err = rmidi->ops->dev_register(rmidi)) < 0) {
1596		snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device);
1597		list_del(&rmidi->list);
1598		mutex_unlock(&register_mutex);
1599		return err;
1600	}
1601#ifdef CONFIG_SND_OSSEMUL
1602	rmidi->ossreg = 0;
1603	if ((int)rmidi->device == midi_map[rmidi->card->number]) {
 
1604		if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI,
1605					    rmidi->card, 0, &snd_rawmidi_f_ops,
1606					    rmidi) < 0) {
1607			rmidi_err(rmidi,
1608				  "unable to register OSS rawmidi device %i:%i\n",
1609				  rmidi->card->number, 0);
1610		} else {
1611			rmidi->ossreg++;
1612#ifdef SNDRV_OSS_INFO_DEV_MIDI
1613			snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number, rmidi->name);
1614#endif
1615		}
1616	}
1617	if ((int)rmidi->device == amidi_map[rmidi->card->number]) {
 
1618		if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI,
1619					    rmidi->card, 1, &snd_rawmidi_f_ops,
1620					    rmidi) < 0) {
1621			rmidi_err(rmidi,
1622				  "unable to register OSS rawmidi device %i:%i\n",
1623				  rmidi->card->number, 1);
1624		} else {
1625			rmidi->ossreg++;
1626		}
1627	}
1628#endif /* CONFIG_SND_OSSEMUL */
1629	mutex_unlock(&register_mutex);
1630	sprintf(name, "midi%d", rmidi->device);
1631	entry = snd_info_create_card_entry(rmidi->card, name, rmidi->card->proc_root);
1632	if (entry) {
1633		entry->private_data = rmidi;
1634		entry->c.text.read = snd_rawmidi_proc_info_read;
1635		if (snd_info_register(entry) < 0) {
1636			snd_info_free_entry(entry);
1637			entry = NULL;
1638		}
1639	}
1640	rmidi->proc_entry = entry;
1641#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
1642	if (!rmidi->ops || !rmidi->ops->dev_register) { /* own registration mechanism */
 
1643		if (snd_seq_device_new(rmidi->card, rmidi->device, SNDRV_SEQ_DEV_ID_MIDISYNTH, 0, &rmidi->seq_dev) >= 0) {
1644			rmidi->seq_dev->private_data = rmidi;
1645			rmidi->seq_dev->private_free = snd_rawmidi_dev_seq_free;
1646			sprintf(rmidi->seq_dev->name, "MIDI %d-%d", rmidi->card->number, rmidi->device);
1647			snd_device_register(rmidi->card, rmidi->seq_dev);
1648		}
1649	}
1650#endif
1651	return 0;
 
 
 
 
 
 
 
1652}
1653
1654static int snd_rawmidi_dev_disconnect(struct snd_device *device)
1655{
1656	struct snd_rawmidi *rmidi = device->device_data;
1657	int dir;
1658
1659	mutex_lock(&register_mutex);
1660	mutex_lock(&rmidi->open_mutex);
1661	wake_up(&rmidi->open_wait);
1662	list_del_init(&rmidi->list);
1663	for (dir = 0; dir < 2; dir++) {
1664		struct snd_rawmidi_substream *s;
 
1665		list_for_each_entry(s, &rmidi->streams[dir].substreams, list) {
1666			if (s->runtime)
1667				wake_up(&s->runtime->sleep);
1668		}
1669	}
1670
1671#ifdef CONFIG_SND_OSSEMUL
1672	if (rmidi->ossreg) {
1673		if ((int)rmidi->device == midi_map[rmidi->card->number]) {
1674			snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, rmidi->card, 0);
1675#ifdef SNDRV_OSS_INFO_DEV_MIDI
1676			snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number);
1677#endif
1678		}
1679		if ((int)rmidi->device == amidi_map[rmidi->card->number])
1680			snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, rmidi->card, 1);
1681		rmidi->ossreg = 0;
1682	}
1683#endif /* CONFIG_SND_OSSEMUL */
1684	snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device);
1685	mutex_unlock(&rmidi->open_mutex);
1686	mutex_unlock(&register_mutex);
1687	return 0;
1688}
1689
1690/**
1691 * snd_rawmidi_set_ops - set the rawmidi operators
1692 * @rmidi: the rawmidi instance
1693 * @stream: the stream direction, SNDRV_RAWMIDI_STREAM_XXX
1694 * @ops: the operator table
1695 *
1696 * Sets the rawmidi operators for the given stream direction.
1697 */
1698void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream,
1699			 struct snd_rawmidi_ops *ops)
1700{
1701	struct snd_rawmidi_substream *substream;
1702	
1703	list_for_each_entry(substream, &rmidi->streams[stream].substreams, list)
1704		substream->ops = ops;
1705}
1706EXPORT_SYMBOL(snd_rawmidi_set_ops);
1707
1708/*
1709 *  ENTRY functions
1710 */
1711
1712static int __init alsa_rawmidi_init(void)
1713{
1714
1715	snd_ctl_register_ioctl(snd_rawmidi_control_ioctl);
1716	snd_ctl_register_ioctl_compat(snd_rawmidi_control_ioctl);
1717#ifdef CONFIG_SND_OSSEMUL
1718	{ int i;
1719	/* check device map table */
1720	for (i = 0; i < SNDRV_CARDS; i++) {
1721		if (midi_map[i] < 0 || midi_map[i] >= SNDRV_RAWMIDI_DEVICES) {
1722			pr_err("ALSA: rawmidi: invalid midi_map[%d] = %d\n",
1723			       i, midi_map[i]);
1724			midi_map[i] = 0;
1725		}
1726		if (amidi_map[i] < 0 || amidi_map[i] >= SNDRV_RAWMIDI_DEVICES) {
1727			pr_err("ALSA: rawmidi: invalid amidi_map[%d] = %d\n",
1728			       i, amidi_map[i]);
1729			amidi_map[i] = 1;
1730		}
1731	}
1732	}
1733#endif /* CONFIG_SND_OSSEMUL */
1734	return 0;
1735}
1736
1737static void __exit alsa_rawmidi_exit(void)
1738{
1739	snd_ctl_unregister_ioctl(snd_rawmidi_control_ioctl);
1740	snd_ctl_unregister_ioctl_compat(snd_rawmidi_control_ioctl);
1741}
1742
1743module_init(alsa_rawmidi_init)
1744module_exit(alsa_rawmidi_exit)