ixj-redhat.c

radius协议源码÷The Radius Stack will connect to a Radius Server. This stack implementation is built upo

		fOffHook |= 2;

	return fOffHook;
}

static void ixj_ring_off(board)
{
	IXJ *j = &ixj[board];

	if (j->dsp.low == 0x20)	// Internet PhoneJACK
	 {
		if (ixjdebug > 0)
			printk(KERN_INFO "IXJ Ring Off\n");
		j->gpio.bytes.high = 0x0B;
		j->gpio.bytes.low = 0x00;
		j->gpio.bits.gpio1 = 0;
		j->gpio.bits.gpio2 = 1;
		j->gpio.bits.gpio5 = 0;
		ixj_WriteDSPCommand(j->gpio.word, board);
	} else			// Internet LineJACK
	 {
		if (ixjdebug > 0)
			printk(KERN_INFO "IXJ Ring Off\n");

		SLIC_SetState(PLD_SLIC_STATE_STANDBY, board);

		SLIC_GetState(board);
	}
}

static void ixj_ring_start(int board)
{
	IXJ *j = &ixj[board];

	j->flags.cringing = 1;
	if (ixj_hookstate(board) & 1) {
		if (j->port == PORT_POTS)
			ixj_ring_off(board);
		j->flags.cringing = 0;
	} else {
		j->ring_cadence_jif = jiffies;
		j->ring_cadence_t = 15;
		if (j->ring_cadence & 1 << j->ring_cadence_t) {
			ixj_ring_on(board);
		} else {
			ixj_ring_off(board);
		}
	}
}

static int ixj_ring(int board)
{
	char cntr;
	unsigned long jif, det;
	IXJ *j = &ixj[board];

	j->flags.ringing = 1;
	if (ixj_hookstate(board) & 1) {
		ixj_ring_off(board);
		j->flags.ringing = 0;
		return 1;
	}
	det = 0;
	for (cntr = 0; cntr < j->maxrings; cntr++) {
		jif = jiffies + (1 * hertz);
		ixj_ring_on(board);
		while (time_before(jiffies, jif)) {
			if (ixj_hookstate(board) & 1) {
				ixj_ring_off(board);
				j->flags.ringing = 0;
				return 1;
			}
			current->state = TASK_INTERRUPTIBLE;
			schedule_timeout(1);
			if (signal_pending(current))
				break;
		}
		jif = jiffies + (3 * hertz);
		ixj_ring_off(board);
		while (time_before(jiffies, jif)) {
			if (ixj_hookstate(board) & 1) {
				det = jiffies + (hertz / 100);
				while (time_before(jiffies, det)) {
					current->state = TASK_INTERRUPTIBLE;
					schedule_timeout(1);
					if (signal_pending(current))
						break;
				}
				if (ixj_hookstate(board) & 1) {
					j->flags.ringing = 0;
					return 1;
				}
			}
			current->state = TASK_INTERRUPTIBLE;
			schedule_timeout(1);
			if (signal_pending(current))
				break;
		}
	}
	ixj_ring_off(board);
	j->flags.ringing = 0;
	return 0;
}

int ixj_open(struct phone_device *p, struct file *file_p)
{
	IXJ *j = &ixj[p->board];

	if (!j->DSPbase)
		return -ENODEV;

	if (file_p->f_mode & FMODE_READ)
		j->readers++;
	if (file_p->f_mode & FMODE_WRITE)
		j->writers++;

	MOD_INC_USE_COUNT;

	if (ixjdebug > 0)
		printk(KERN_INFO "Opening board %d\n", p->board);

	return 0;
}

int ixj_release(struct inode *inode, struct file *file_p)
{
	IXJ_TONE ti;
	int board = NUM(inode->i_rdev);
	IXJ *j = &ixj[board];

	if (ixjdebug > 0)
		printk(KERN_INFO "Closing board %d\n", NUM(inode->i_rdev));

	daa_set_mode(board, SOP_PU_SLEEP);
	ixj_set_port(board, PORT_POTS);
	aec_stop(board);
	ixj_play_stop(board);
	ixj_record_stop(board);

	// Restore the tone table to default settings.
	ti.tone_index = 10;
	ti.gain0 = 1;
	ti.freq0 = hz941;
	ti.gain1 = 0;
	ti.freq1 = hz1209;
	ti.tone_index = 11;
	ti.gain0 = 1;
	ti.freq0 = hz941;
	ti.gain1 = 0;
	ti.freq1 = hz1336;
	ti.tone_index = 12;
	ti.gain0 = 1;
	ti.freq0 = hz941;
	ti.gain1 = 0;
	ti.freq1 = hz1477;
	ti.tone_index = 13;
	ti.gain0 = 1;
	ti.freq0 = hz800;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 14;
	ti.gain0 = 1;
	ti.freq0 = hz1000;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 15;
	ti.gain0 = 1;
	ti.freq0 = hz1250;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 16;
	ti.gain0 = 1;
	ti.freq0 = hz950;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 17;
	ti.gain0 = 1;
	ti.freq0 = hz1100;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 18;
	ti.gain0 = 1;
	ti.freq0 = hz1400;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 19;
	ti.gain0 = 1;
	ti.freq0 = hz1500;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 20;
	ti.gain0 = 1;
	ti.freq0 = hz1600;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 21;
	ti.gain0 = 1;
	ti.freq0 = hz1800;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 22;
	ti.gain0 = 1;
	ti.freq0 = hz2100;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 23;
	ti.gain0 = 1;
	ti.freq0 = hz1300;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 24;
	ti.gain0 = 1;
	ti.freq0 = hz2450;
	ti.gain1 = 0;
	ti.freq1 = 0;
	ixj_init_tone(board, &ti);
	ti.tone_index = 25;
	ti.gain0 = 1;
	ti.freq0 = hz350;
	ti.gain1 = 0;
	ti.freq1 = hz440;
	ixj_init_tone(board, &ti);
	ti.tone_index = 26;
	ti.gain0 = 1;
	ti.freq0 = hz440;
	ti.gain1 = 0;
	ti.freq1 = hz480;
	ixj_init_tone(board, &ti);
	ti.tone_index = 27;
	ti.gain0 = 1;
	ti.freq0 = hz480;
	ti.gain1 = 0;
	ti.freq1 = hz620;
	ixj_init_tone(board, &ti);

	idle(board);

	if (file_p->f_mode & FMODE_READ)
		j->readers--;
	if (file_p->f_mode & FMODE_WRITE)
		j->writers--;

	if (j->read_buffer && !j->readers) {
		kfree(j->read_buffer);
		j->read_buffer = NULL;
		j->read_buffer_size = 0;
	}
	if (j->write_buffer && !j->writers) {
		kfree(j->write_buffer);
		j->write_buffer = NULL;
		j->write_buffer_size = 0;
	}
	j->rec_codec = j->play_codec = 0;
	j->rec_frame_size = j->play_frame_size = 0;
	ixj_fasync(-1, file_p, 0);	// remove from list of async notification

	MOD_DEC_USE_COUNT;
	return 0;
}

static int read_filters(int board)
{
	unsigned short fc, cnt;
	int var;
	IXJ *j = &ixj[board];

	if (ixj_WriteDSPCommand(0x5144, board))
		return -1;

	fc = j->ssr.high << 8 | j->ssr.low;
	if (fc == j->frame_count)
		return 1;

	j->frame_count = fc;

	if (j->dtmf_proc)
		return 1;

	var = 10;

	for (cnt = 0; cnt < 4; cnt++) {
		if (ixj_WriteDSPCommand(0x5154 + cnt, board))
			return -1;

		if (ixj_WriteDSPCommand(0x515C, board))
			return -1;

		j->filter_hist[cnt] = j->ssr.high << 8 | j->ssr.low;

		if (j->cadence_f[cnt].enable) {
			if (j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) {
				if (j->cadence_f[cnt].state == 0) {
					j->cadence_f[cnt].state = 1;
					j->cadence_f[cnt].on1min = jiffies + (j->cadence_f[cnt].on1 * hertz * (100 - var) / 10000);
					j->cadence_f[cnt].on1max = jiffies + (j->cadence_f[cnt].on1 * hertz * (100 + var) / 10000);
				} else if (j->cadence_f[cnt].state == 2 &&
					   (time_after(jiffies, j->cadence_f[cnt].off1min) &&
					    time_before(jiffies, j->cadence_f[cnt].off1max))) {
					if (j->cadence_f[cnt].on2) {
						j->cadence_f[cnt].state = 3;
						j->cadence_f[cnt].on2min = jiffies + (j->cadence_f[cnt].on2 * hertz * (100 - var) / 10000);
						j->cadence_f[cnt].on2max = jiffies + (j->cadence_f[cnt].on2 * hertz * (100 + var) / 10000);
					} else {
						j->cadence_f[cnt].state = 6;
					}
				} else if (j->cadence_f[cnt].state == 4 &&
					   (time_after(jiffies, j->cadence_f[cnt].off2min) &&
					    time_before(jiffies, j->cadence_f[cnt].off2max))) {
					if (j->cadence_f[cnt].on2) {
						j->cadence_f[cnt].state = 5;
						j->cadence_f[cnt].on3min = jiffies + (j->cadence_f[cnt].on3 * hertz * (100 - var) / 10000);
						j->cadence_f[cnt].on3max = jiffies + (j->cadence_f[cnt].on3 * hertz * (100 + var) / 10000);
					} else {
						j->cadence_f[cnt].state = 6;
					}
				} else {
					j->cadence_f[cnt].state = 0;
				}
			} else if (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3)) {
				if (j->cadence_f[cnt].state == 1 &&
				    (time_after(jiffies, j->cadence_f[cnt].on1min) &&
				     time_before(jiffies, j->cadence_f[cnt].on1max))) {
					j->cadence_f[cnt].state = 2;
					j->cadence_f[cnt].off1min = jiffies + (j->cadence_f[cnt].off1 * hertz * (100 - var) / 10000);
					j->cadence_f[cnt].off1max = jiffies + (j->cadence_f[cnt].off1 * hertz * (100 + var) / 10000);
				} else if (j->cadence_f[cnt].state == 3 &&
					   (time_after(jiffies, j->cadence_f[cnt].on2min) &&
					    time_before(jiffies, j->cadence_f[cnt].on2max))) {
					j->cadence_f[cnt].state = 4;
					j->cadence_f[cnt].off2min = jiffies + (j->cadence_f[cnt].off2 * hertz * (100 - var) / 10000);
					j->cadence_f[cnt].off2max = jiffies + (j->cadence_f[cnt].off2 * hertz * (100 + var) / 10000);
				} else if (j->cadence_f[cnt].state == 5 &&
					   (time_after(jiffies, j->cadence_f[cnt].on3min) &&
					    time_before(jiffies, j->cadence_f[cnt].on3max))) {
					j->cadence_f[cnt].state = 6;
					j->cadence_f[cnt].off3min = jiffies + (j->cadence_f[cnt].off3 * hertz * (100 - var) / 10000);
					j->cadence_f[cnt].off3max = jiffies + (j->cadence_f[cnt].off3 * hertz * (100 + var) / 10000);
				} else {
					j->cadence_f[cnt].state = 0;
				}
			}
		}
		if (j->cadence_f[cnt].state == 6) {
			j->cadence_f[cnt].state = j->cadence_f[cnt].enable = 0;
			switch (cnt) {
			case 0:
				j->ex.bits.fc0 = 1;
				break;
			case 1:
				j->ex.bits.fc1 = 1;
				break;
			case 2:
				j->ex.bits.fc2 = 1;
				break;
			case 3:
				j->ex.bits.fc3 = 1;
				break;
			}
		}
		if ((j->filter_hist[cnt] & 3 && !(j->filter_hist[cnt] & 12)) ||
		    (j->filter_hist[cnt] & 12 && !(j->filter_hist[cnt] & 3))) {
			switch (cnt) {
			case 0:
				j->ex.bits.f0 = 1;
				break;
			case 1:
				j->ex.bits.f1 = 1;
				break;
			case 2:
				j->ex.bits.f2 = 1;
				break;
			case 3:
				j->ex.bits.f3 = 1;
				break;
			}
		}
	}
	return 0;
}

static int LineMonitor(int board)
{
	IXJ *j = &ixj[board];

	if (j->dtmf_proc) {
		return -1;
	}
	j->dtmf_proc = 1;

	if (ixj_WriteDSPCommand(0x7000, board))		// Line Monitor

		return -1;

	j->dtmf.bytes.high = j->ssr.high;
	j->dtmf.bytes.low = j->ssr.low;
	if (!j->dtmf_state && j->dtmf.bits.dtmf_valid) {
		j->dtmf_state = 1;
		j->dtmf_current = j->dtmf.bits.digit;
	}
	if (j->dtmf_state && !j->dtmf.bits.dtmf_valid)	// && j->dtmf_wp != j->dtmf_rp)
	 {
		j->dtmfbuffer[j->dtmf_wp] = j->dtmf_current;
		j->dtmf_wp++;
		if (j->dtmf_wp == 79)
			j->dtmf_wp = 0;
		j->ex.bits.dtmf_ready = 1;
		j->dtmf_state = 0;
	}
	j->dtmf_proc = 0;

	return 0;
}

ssize_t ixj_read(struct file * file_p, char *buf, size_t length, loff_t * ppos)
{
	unsigned long i = *ppos;
	IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];
	struct wait_queue wait =
	{current, NULL};

	if(j->flags.inread)
		return -EALREADY;

	j->flags.inread = 1;

	add_wait_queue(&j->read_q, &wait);
	current->state = TASK_INTERRUPTIBLE;
	mb();

	while (!j->read_buffer_ready || (j->dtmf_state && j->flags.dtmf_oob)) {
		++j->read_wait;
		if (file_p->f_flags & O_NONBLOCK) {
			current->state = TASK_RUNNING;
			remove_wait_queue(&j->read_q, &wait);
			j->flags.inread = 0;
			return -EAGAIN;
		}
		if (!ixj_hookstate(NUM(file_p->f_dentry->d_inode->i_rdev))) {
			current->state = TASK_RUNNING;
			remove_wait_queue(&j->read_q, &wait);
			j->flags.inread = 0;
			return 0;
		}
		interruptible_sleep_on(&j->read_q);
		if (signal_pending(current)) {
			current->state = TASK_RUNNING;
			remove_wait_queue(&j->read_q, &wait);
			j->flags.inread = 0;
			return -EINTR;
		}
	}

	remove_wait_queue(&j->read_q, &wait);
	current->state = TASK_RUNNING;
	/* Don't ever copy more than the user asks */
	i = copy_to_user(buf, j->read_buffer, min(length, j->read_buffer_size));
	j->read_buffer_ready = 0;
	if (i) {
		j->flags.inread = 0;
		return -EFAULT;
	}
	else {
		j->flags.inread = 0;
		return min(length, j->read_buffer_size);
	}
}

ssize_t ixj_enhanced_read(struct file * file_p, char *buf, size_t length,
			  loff_t * ppos)
{
	int pre_retval;
	ssize_t read_retval = 0;
	IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];

	pre_retval = ixj_PreRead(j, 0L);
	switch (pre_retval) {
	case NORMAL:
		read_retval = ixj_read(file_p, buf, length, ppos);
		ixj_PostRead(j, 0L);
		break;
	case NOPOST:
		read_retval = ixj_read(file_p, buf, length, ppos);
		break;
	case POSTONLY:
		ixj_PostRead(j, 0L);
		break;
	default:
		read_retval = pre_retval;
	}
	return read_retval;
}

ssize_t ixj_write(struct file * file_p, const char *buf, size_t count, loff_t * ppos)
{
	unsigned long i = *ppos;
	int board = NUM(file_p->f_dentry->d_inode->i_rdev);
	IXJ *j = &ixj[board];
	struct wait_queue wait =
	{current, NULL};

	if(j->flags.inwrite)
		return -EALREADY;

	j->flags.inwrite = 1;

	add_wait_queue(&j->write_q, &wait);
	current->state = TASK_INTERRUPTIBLE;
	mb();


	while (!j->write_buffers_empty) {
		++j->write_wait;
		if (file_p->f_flags & O_NONBLOCK) {
			current->state = TASK_RUNNING;
			remove_wait_queue(&j->write_q, &wait);
			j->flags.inwrite = 0;
			return -EAGAIN;
		}
		if (!ixj_hookstate(NUM(file_p->f_dentry->d_inode->i_rdev))) {
			current->state = TASK_RUNNING;
			remove_wait_queue(&j->write_q, &wait);
			j->flags.inwrite = 0;
			return 0;
		}
		interruptible_sleep_on(&j->write_q);
		if (signal_pending(current)) {
			current->state = TASK_RUNNING;
			remove_wait_queue(&j->write_q, &wait);
			j->flags.inwrite = 0;
			return -EINTR;
		}
	}
	current->state = TASK_RUNNING;
	remove_wait_queue(&j->write_q, &wait);
	if (j->write_buffer_wp + count >= j->write_buffer_end)
		j->write_buffer_wp = j->write_buffer;
	i = copy_from_user(j->write_buffer_wp, buf, min(count, j->write_buffer_size));
	if (i) {
		j->flags.inwrite = 0;
		return -EFAULT;
	}

	j->flags.inwrite = 0;
	return min(count, j->write_buffer_size);
}

ssize_t ixj_enhanced_write(struct file * file_p, const char *buf, size_t count,
			   loff_t * ppos)
{
	int pre_retval;
	ssize_t write_retval = 0;
	IXJ *j = &ixj[NUM(file_p->f_dentry->d_inode->i_rdev)];

	pre_retval = ixj_PreWrite(j, 0L);
	switch (pre_retval) {
	case NORMAL:
		write_retval = ixj_write(file_p, buf, count, ppos);