if (woinst->state == WAVE_STATE_CLOSED) {			calculate_ofrag(woinst);			if (emu10k1_waveout_open(wave_dev) < 0) {				spin_unlock_irqrestore(&woinst->lock, flags);				ERROR();				return -EINVAL;			}		}		woinst->mmapped = 1;		max_pages += woinst->buffer.pages;		spin_unlock_irqrestore(&woinst->lock, flags);	}	if (vma->vm_flags & VM_READ) {		wiinst = wave_dev->wiinst;		spin_lock_irqsave(&wiinst->lock, flags);		if (wiinst->state == WAVE_STATE_CLOSED) {			calculate_ifrag(wiinst);			if (emu10k1_wavein_open(wave_dev) < 0) {				spin_unlock_irqrestore(&wiinst->lock, flags);				ERROR();				return -EINVAL;			}		}		wiinst->mmapped = 1;		max_pages += wiinst->buffer.pages;		spin_unlock_irqrestore(&wiinst->lock, flags);	}	n_pages = ((vma->vm_end - vma->vm_start) + PAGE_SIZE - 1) >> PAGE_SHIFT;	pgoffset = vma->vm_pgoff;	DPD(2, "vma_start: %#lx, vma_end: %#lx, vma_offset: %ld\n", vma->vm_start, vma->vm_end, pgoffset);	DPD(2, "n_pages: %ld, max_pages: %ld\n", n_pages, max_pages);	if (pgoffset + n_pages > max_pages)		return -EINVAL;	vma->vm_flags |= VM_RESERVED;	vma->vm_ops = &emu10k1_mm_ops;	vma->vm_private_data = wave_dev;	return 0;}static int emu10k1_audio_open(struct inode *inode, struct file *file){	int minor = MINOR(inode->i_rdev);	struct emu10k1_card *card = NULL;	struct list_head *entry;	struct emu10k1_wavedevice *wave_dev;	DPF(2, "emu10k1_audio_open()\n");	/* Check for correct device to open */	list_for_each(entry, &emu10k1_devs) {		card = list_entry(entry, struct emu10k1_card, list);		if (!((card->audio_dev ^ minor) & ~0xf) || !((card->audio_dev1 ^ minor) & ~0xf))			goto match;	}	return -ENODEV;match:	wave_dev = (struct emu10k1_wavedevice *) kmalloc(sizeof(struct emu10k1_wavedevice), GFP_KERNEL);	if (wave_dev == NULL) { 		ERROR();		return -ENOMEM;	}	wave_dev->card = card;	wave_dev->wiinst = NULL;	wave_dev->woinst = NULL;	wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;	/* Default */	if (file->f_mode & FMODE_READ) {		/* Recording */		struct wiinst *wiinst;		if ((wiinst = (struct wiinst *) kmalloc(sizeof(struct wiinst), GFP_KERNEL)) == NULL) {			ERROR();			kfree(wave_dev);			return -ENOMEM;		}		wiinst->recsrc = card->wavein.recsrc;                wiinst->fxwc = card->wavein.fxwc;		switch (wiinst->recsrc) {		case WAVERECORD_AC97:			wiinst->format.id = AFMT_S16_LE;			wiinst->format.samplingrate = 8000;			wiinst->format.bitsperchannel = 16;			wiinst->format.channels = 1;			break;		case WAVERECORD_MIC:			wiinst->format.id = AFMT_S16_LE;			wiinst->format.samplingrate = 8000;			wiinst->format.bitsperchannel = 16;			wiinst->format.channels = 1;			break;		case WAVERECORD_FX:			wiinst->format.id = AFMT_S16_LE;			wiinst->format.samplingrate = 48000;			wiinst->format.bitsperchannel = 16;			wiinst->format.channels = hweight32(wiinst->fxwc);			break;		default:			kfree(wave_dev);			kfree(wiinst);			BUG();			break;		}		wiinst->state = WAVE_STATE_CLOSED;		wiinst->buffer.ossfragshift = 0;		wiinst->buffer.fragment_size = 0;		wiinst->buffer.numfrags = 0;		init_waitqueue_head(&wiinst->wait_queue);		wiinst->mmapped = 0;		wiinst->total_recorded = 0;		wiinst->blocks = 0;		wiinst->lock = SPIN_LOCK_UNLOCKED;		tasklet_init(&wiinst->timer.tasklet, emu10k1_wavein_bh, (unsigned long) wave_dev);		wave_dev->wiinst = wiinst;		emu10k1_wavein_setformat(wave_dev, &wiinst->format);	}	if (file->f_mode & FMODE_WRITE) {		struct woinst *woinst;		int i;		if ((woinst = (struct woinst *) kmalloc(sizeof(struct woinst), GFP_KERNEL)) == NULL) {			ERROR();			return -ENODEV;		}		if (wave_dev->wiinst != NULL) {			woinst->format = wave_dev->wiinst->format;		} else {			woinst->format.id = AFMT_U8;			woinst->format.samplingrate = 8000;			woinst->format.bitsperchannel = 8;			woinst->format.channels = 1;		}		woinst->state = WAVE_STATE_CLOSED;		woinst->buffer.fragment_size = 0;		woinst->buffer.ossfragshift = 0;		woinst->buffer.numfrags = 0;		woinst->device = (card->audio_dev1 == minor);		woinst->timer.state = TIMER_STATE_UNINSTALLED;		woinst->num_voices = 1;		for (i = 0; i < WAVEOUT_MAXVOICES; i++) {			woinst->voice[i].usage = VOICE_USAGE_FREE;			woinst->voice[i].mem.emupageindex = -1;		}		init_waitqueue_head(&woinst->wait_queue);		woinst->mmapped = 0;		woinst->total_copied = 0;		woinst->total_played = 0;		woinst->blocks = 0;		woinst->lock = SPIN_LOCK_UNLOCKED;		tasklet_init(&woinst->timer.tasklet, emu10k1_waveout_bh, (unsigned long) wave_dev);		wave_dev->woinst = woinst;		emu10k1_waveout_setformat(wave_dev, &woinst->format);	}	file->private_data = (void *) wave_dev;	return 0;}static int emu10k1_audio_release(struct inode *inode, struct file *file){	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;	struct emu10k1_card *card;	unsigned long flags;	card = wave_dev->card;	DPF(2, "emu10k1_audio_release()\n");	if (file->f_mode & FMODE_WRITE) {		struct woinst *woinst = wave_dev->woinst;		spin_lock_irqsave(&woinst->lock, flags);		if (woinst->format.passthrough && card->pt.state != PT_STATE_INACTIVE) {			spin_lock(&card->pt.lock);                        emu10k1_pt_stop(card);			spin_unlock(&card->pt.lock);		}		if (woinst->state & WAVE_STATE_OPEN) {			if (woinst->state & WAVE_STATE_STARTED) {				if (!(file->f_flags & O_NONBLOCK)) {					while (!signal_pending(current)					       && (woinst->total_played < woinst->total_copied)) {						DPF(4, "Buffer hasn't been totally played, sleep....\n");						spin_unlock_irqrestore(&woinst->lock, flags);						interruptible_sleep_on(&woinst->wait_queue);						spin_lock_irqsave(&woinst->lock, flags);					}				}			}			emu10k1_waveout_close(wave_dev);		}		spin_unlock_irqrestore(&woinst->lock, flags);		/* remove the tasklet */		tasklet_kill(&woinst->timer.tasklet);		kfree(wave_dev->woinst);	}	if (file->f_mode & FMODE_READ) {		struct wiinst *wiinst = wave_dev->wiinst;		spin_lock_irqsave(&wiinst->lock, flags);		if (wiinst->state & WAVE_STATE_OPEN) {			emu10k1_wavein_close(wave_dev);		}		spin_unlock_irqrestore(&wiinst->lock, flags);		tasklet_kill(&wiinst->timer.tasklet);		kfree(wave_dev->wiinst);	}	kfree(wave_dev);	if (waitqueue_active(&card->open_wait))		wake_up_interruptible(&card->open_wait);	return 0;}/* FIXME sort out poll() + mmap() */static unsigned int emu10k1_audio_poll(struct file *file, struct poll_table_struct *wait){	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;	struct woinst *woinst = wave_dev->woinst;	struct wiinst *wiinst = wave_dev->wiinst;	unsigned int mask = 0;	u32 bytestocopy;	unsigned long flags;	DPF(4, "emu10k1_audio_poll()\n");	if (file->f_mode & FMODE_WRITE)		poll_wait(file, &woinst->wait_queue, wait);	if (file->f_mode & FMODE_READ)		poll_wait(file, &wiinst->wait_queue, wait);	if (file->f_mode & FMODE_WRITE) {		spin_lock_irqsave(&woinst->lock, flags);		if (woinst->state & WAVE_STATE_OPEN) {			emu10k1_waveout_update(woinst);			emu10k1_waveout_getxfersize(woinst, &bytestocopy);			if (bytestocopy >= woinst->buffer.fragment_size)				mask |= POLLOUT | POLLWRNORM;		} else			mask |= POLLOUT | POLLWRNORM;		spin_unlock_irqrestore(&woinst->lock, flags);	}	if (file->f_mode & FMODE_READ) {		spin_lock_irqsave(&wiinst->lock, flags);		if (wiinst->state & WAVE_STATE_OPEN) {			emu10k1_wavein_update(wave_dev->card, wiinst);			emu10k1_wavein_getxfersize(wiinst, &bytestocopy);			if (bytestocopy >= wiinst->buffer.fragment_size)				mask |= POLLIN | POLLRDNORM;		}		spin_unlock_irqrestore(&wiinst->lock, flags);	}	return mask;}static void calculate_ofrag(struct woinst *woinst){	struct waveout_buffer *buffer = &woinst->buffer;	u32 fragsize;	if (buffer->fragment_size)		return;	if (!buffer->ossfragshift) {		fragsize = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTFRAGLEN) / 1000 - 1;		while (fragsize) {			fragsize >>= 1;			buffer->ossfragshift++;		}	}	if (buffer->ossfragshift < WAVEOUT_MINFRAGSHIFT)		buffer->ossfragshift = WAVEOUT_MINFRAGSHIFT;	buffer->fragment_size = 1 << buffer->ossfragshift;	while (buffer->fragment_size * WAVEOUT_MINFRAGS > WAVEOUT_MAXBUFSIZE)		buffer->fragment_size >>= 1;	/* now we are sure that:	 (2^WAVEOUT_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEOUT_MAXBUFSIZE / WAVEOUT_MINFRAGS)	*/	if (!buffer->numfrags) {		u32 numfrags;		numfrags = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTBUFLEN) /			   (buffer->fragment_size * 1000) - 1;		buffer->numfrags = 1;		while (numfrags) {			numfrags >>= 1;			buffer->numfrags <<= 1;		}	}	if (buffer->numfrags < WAVEOUT_MINFRAGS)		buffer->numfrags = WAVEOUT_MINFRAGS;	if (buffer->numfrags * buffer->fragment_size > WAVEOUT_MAXBUFSIZE)		buffer->numfrags = WAVEOUT_MAXBUFSIZE / buffer->fragment_size;	if (buffer->numfrags < WAVEOUT_MINFRAGS)		BUG();	buffer->size = buffer->fragment_size * buffer->numfrags;	buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);	DPD(2, " calculated playback fragment_size -> %d\n", buffer->fragment_size);	DPD(2, " calculated playback numfrags -> %d\n", buffer->numfrags);	return;}static void calculate_ifrag(struct wiinst *wiinst){	struct wavein_buffer *buffer = &wiinst->buffer;	u32 fragsize, bufsize, size[4];	int i, j;	if (buffer->fragment_size)		return;	if (!buffer->ossfragshift) {		fragsize = (wiinst->format.bytespersec * WAVEIN_DEFAULTFRAGLEN) / 1000 - 1;		while (fragsize) {			fragsize >>= 1;			buffer->ossfragshift++;		}	}	if (buffer->ossfragshift < WAVEIN_MINFRAGSHIFT)		buffer->ossfragshift = WAVEIN_MINFRAGSHIFT;	buffer->fragment_size = 1 << buffer->ossfragshift;	while (buffer->fragment_size * WAVEIN_MINFRAGS > WAVEIN_MAXBUFSIZE)		buffer->fragment_size >>= 1;	/* now we are sure that:	   (2^WAVEIN_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEIN_MAXBUFSIZE / WAVEIN_MINFRAGS)        */	if (!buffer->numfrags)		buffer->numfrags = (wiinst->format.bytespersec * WAVEIN_DEFAULTBUFLEN) / (buffer->fragment_size * 1000) - 1;	if (buffer->numfrags < WAVEIN_MINFRAGS)		buffer->numfrags = WAVEIN_MINFRAGS;	if (buffer->numfrags * buffer->fragment_size > WAVEIN_MAXBUFSIZE)		buffer->numfrags = WAVEIN_MAXBUFSIZE / buffer->fragment_size;	if (buffer->numfrags < WAVEIN_MINFRAGS)		BUG();	bufsize = buffer->fragment_size * buffer->numfrags;	/* the buffer size for recording is restricted to certain values, adjust it now */	if (bufsize >= 0x10000) {		buffer->size = 0x10000;		buffer->sizeregval = 0x1f;	} else {		buffer->size = 0;		size[0] = 384;		size[1] = 448;		size[2] = 512;		size[3] = 640;		for (i = 0; i < 8; i++)			for (j = 0; j < 4; j++)				if (bufsize >= size[j]) {					buffer->size = size[j];					size[j] *= 2;					buffer->sizeregval = i * 4 + j + 1;				} else					goto exitloop;	      exitloop:		if (buffer->size == 0) {			buffer->size = 384;			buffer->sizeregval = 0x01;		}	}	/* adjust the fragment size so that buffer size is an integer multiple */	while (buffer->size % buffer->fragment_size)		buffer->fragment_size >>= 1;	buffer->numfrags = buffer->size / buffer->fragment_size;	buffer->pages =  buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);	DPD(2, " calculated recording fragment_size -> %d\n", buffer->fragment_size);	DPD(2, " calculated recording numfrags -> %d\n", buffer->numfrags);	DPD(2, " buffer size register -> %#04x\n", buffer->sizeregval);	return;}void emu10k1_wavein_bh(unsigned long refdata){	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;	struct wiinst *wiinst = wave_dev->wiinst;	u32 bytestocopy;	unsigned long flags;	if (!wiinst)		return;	spin_lock_irqsave(&wiinst->lock, flags);	if (!(wiinst->state & WAVE_STATE_STARTED)) {		spin_unlock_irqrestore(&wiinst->lock, flags);		return;	}	emu10k1_wavein_update(wave_dev->card, wiinst);	emu10k1_wavein_getxfersize(wiinst, &bytestocopy);	spin_unlock_irqrestore(&wiinst->lock, flags);	if (bytestocopy >= wiinst->buffer.fragment_size) {	 	if (waitqueue_active(&wiinst->wait_queue))			wake_up_interruptible(&wiinst->wait_queue);	} else		DPD(3, "Not enough transfer size, %d\n", bytestocopy);	return;}void emu10k1_waveout_bh(unsigned long refdata){	struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;	struct woinst *woinst = wave_dev->woinst;	u32 bytestocopy;	unsigned long flags;	if (!woinst)		return;	spin_lock_irqsave(&woinst->lock, flags);	if (!(woinst->state & WAVE_STATE_STARTED)) {		spin_unlock_irqrestore(&woinst->lock, flags);		return;	}	emu10k1_waveout_update(woinst);	emu10k1_waveout_getxfersize(woinst, &bytestocopy);	if (woinst->buffer.fill_silence) {		spin_unlock_irqrestore(&woinst->lock, flags);		emu10k1_waveout_fillsilence(woinst);	} else		spin_unlock_irqrestore(&woinst->lock, flags);	if (bytestocopy >= woinst->buffer.fragment_size) {		if (waitqueue_active(&woinst->wait_queue))			wake_up_interruptible(&woinst->wait_queue);	} else		DPD(3, "Not enough transfer size -> %d\n", bytestocopy);	return;}struct file_operations emu10k1_audio_fops = {	owner:		THIS_MODULE,	llseek:		no_llseek,	read:		emu10k1_audio_read,	write:		emu10k1_audio_write,	poll:		emu10k1_audio_poll,	ioctl:		emu10k1_audio_ioctl,	mmap:		emu10k1_audio_mmap,	open:		emu10k1_audio_open,	release:	emu10k1_audio_release,};