mISDN: Add ISDN sample clock API to mISDN core (3bd69ad1) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/isdn/hardware/mISDN/hfc_multi.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -197,6 +197,9 @@ struct hfc_multi {

		spinlock_t lock; /* the lock */

		struct mISDNclock iclock; / isdn clock support */
		int iclock_on;

		/*
		* the channel index is counted from 0, regardless where the channel
		* is located on the hfc-channel.

drivers/isdn/hardware/mISDN/hfcmulti.c

+38 −7

Original line number	Diff line number	Diff line
		@@ -133,6 +133,12 @@
		* Give the value of the clock control register (A_ST_CLK_DLY)
		* of the S/T interfaces in TE mode.
		* This register is needed for the TBR3 certification, so don't change it.
		*
		* clock:
		* NOTE: only one clockdelay_te value must be given once
		* Selects interface with clock source for mISDN and applications.
		* Set to card number starting with 1. Set to -1 to disable.
		* By default, the first card is used as clock source.
		*/

		/*
		@@ -190,12 +196,13 @@ static int nt_t1_count[] = { 3840, 1920, 960, 480, 240, 120, 60, 30 };
		*/

		static uint type[MAX_CARDS];
		static uint pcm[MAX_CARDS];
		static uint dslot[MAX_CARDS];
		static int pcm[MAX_CARDS];
		static int dslot[MAX_CARDS];
		static uint iomode[MAX_CARDS];
		static uint port[MAX_PORTS];
		static uint debug;
		static uint poll;
		static int clock;
		static uint timer;
		static uint clockdelay_te = CLKDEL_TE;
		static uint clockdelay_nt = CLKDEL_NT;
		@@ -207,12 +214,13 @@ MODULE_LICENSE("GPL");
		MODULE_VERSION(HFC_MULTI_VERSION);
		module_param(debug, uint, S_IRUGO \| S_IWUSR);
		module_param(poll, uint, S_IRUGO \| S_IWUSR);
		module_param(clock, int, S_IRUGO \| S_IWUSR);
		module_param(timer, uint, S_IRUGO \| S_IWUSR);
		module_param(clockdelay_te, uint, S_IRUGO \| S_IWUSR);
		module_param(clockdelay_nt, uint, S_IRUGO \| S_IWUSR);
		module_param_array(type, uint, NULL, S_IRUGO \| S_IWUSR);
		module_param_array(pcm, uint, NULL, S_IRUGO \| S_IWUSR);
		module_param_array(dslot, uint, NULL, S_IRUGO \| S_IWUSR);
		module_param_array(pcm, int, NULL, S_IRUGO \| S_IWUSR);
		module_param_array(dslot, int, NULL, S_IRUGO \| S_IWUSR);
		module_param_array(iomode, uint, NULL, S_IRUGO \| S_IWUSR);
		module_param_array(port, uint, NULL, S_IRUGO \| S_IWUSR);

		@@ -2629,6 +2637,7 @@ hfcmulti_interrupt(int intno, void *dev_id)
		iqcnt = 0;
		}
		#endif

		if (!r_irq_statech &&
		!(status & (V_DTMF_STA \| V_LOST_STA \| V_EXT_IRQSTA \|
		V_MISC_IRQSTA \| V_FR_IRQSTA))) {
		@@ -2683,11 +2692,13 @@ hfcmulti_interrupt(int intno, void *dev_id)
		plxsd_checksync(hc, 0);
		}
		}
		if (r_irq_misc & V_TI_IRQ)
		if (r_irq_misc & V_TI_IRQ) {
		if (hc->iclock_on)
		mISDN_clock_update(hc->iclock, poll, NULL);
		handle_timer_irq(hc);
		}

		if (r_irq_misc & V_DTMF_IRQ) {
		/* -> DTMF IRQ */
		hfcmulti_dtmf(hc);
		}
		if (r_irq_misc & V_IRQ_PROC) {
		@@ -4075,6 +4086,15 @@ hfcm_dctrl(struct mISDNchannel ch, u_int cmd, void arg)
		return err;
		}

		static int
		clockctl(void *priv, int enable)
		{
		struct hfc_multi *hc = priv;

		hc->iclock_on = enable;
		return 0;
		}

		/*
		* initialize the card
		*/
		@@ -4489,10 +4509,14 @@ release_card(struct hfc_multi *hc)
		printk(KERN_WARNING "%s: release card (%d) entered\n",
		__func__, hc->id);

		/* unregister clock source */
		if (hc->iclock)
		mISDN_unregister_clock(hc->iclock);

		/* disable irq */
		spin_lock_irqsave(&hc->lock, flags);
		disable_hwirq(hc);
		spin_unlock_irqrestore(&hc->lock, flags);

		udelay(1000);

		/* dimm leds */
		@@ -5003,6 +5027,10 @@ hfcmulti_init(struct pci_dev pdev, const struct pci_device_id ent)
		list_add_tail(&hc->list, &HFClist);
		spin_unlock_irqrestore(&HFClock, flags);

		/* use as clock source */
		if (clock == HFC_cnt + 1)
		hc->iclock = mISDN_register_clock("HFCMulti", 0, clockctl, hc);

		/* initialize hardware */
		ret_err = init_card(hc);
		if (ret_err) {
		@@ -5273,6 +5301,9 @@ HFCmulti_init(void)

		}

		if (!clock)
		clock = 1;

		err = pci_register_driver(&hfcmultipci_driver);
		if (err < 0) {
		printk(KERN_ERR "error registering pci driver: %x\n", err);

drivers/isdn/mISDN/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -8,6 +8,6 @@ obj-$(CONFIG_MISDN_L1OIP) += l1oip.o

		# multi objects

		mISDN_core-objs := core.o fsm.o socket.o hwchannel.o stack.o layer1.o layer2.o tei.o timerdev.o
		mISDN_core-objs := core.o fsm.o socket.o clock.o hwchannel.o stack.o layer1.o layer2.o tei.o timerdev.o
		mISDN_dsp-objs := dsp_core.o dsp_cmx.o dsp_tones.o dsp_dtmf.o dsp_audio.o dsp_blowfish.o dsp_pipeline.o dsp_hwec.o
		l1oip-objs := l1oip_core.o l1oip_codec.o

drivers/isdn/mISDN/clock.c

0 → 100644

+216 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2008 by Andreas Eversberg <andreas@eversberg.eu>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*
		* 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.
		*
		* Quick API description:
		*
		* A clock source registers using mISDN_register_clock:
		* name = text string to name clock source
		* priority = value to priorize clock sources (0 = default)
		* ctl = callback function to enable/disable clock source
		* priv = private pointer of clock source
		* return = pointer to clock source structure;
		*
		* Note: Callback 'ctl' can be called before mISDN_register_clock returns!
		* Also it can be called during mISDN_unregister_clock.
		*
		* A clock source calls mISDN_clock_update with given samples elapsed, if
		* enabled. If function call is delayed, tv must be set with the timestamp
		* of the actual event.
		*
		* A clock source unregisters using mISDN_unregister_clock.
		*
		* To get current clock, call mISDN_clock_get. The signed short value
		* counts the number of samples since. Time since last clock event is added.
		*
		*/

		#include <linux/types.h>
		#include <linux/stddef.h>
		#include <linux/spinlock.h>
		#include <linux/mISDNif.h>
		#include "core.h"

		static u_int *debug;
		static LIST_HEAD(iclock_list);
		DEFINE_RWLOCK(iclock_lock);
		u16 iclock_count; /* counter of last clock */
		struct timeval iclock_tv; /* time stamp of last clock */
		int iclock_tv_valid; /* already received one timestamp */
		struct mISDNclock *iclock_current;

		void
		mISDN_init_clock(u_int *dp)
		{
		debug = dp;
		do_gettimeofday(&iclock_tv);
		}

		static void
		select_iclock(void)
		{
		struct mISDNclock iclock, bestclock = NULL, *lastclock = NULL;
		int pri = -128;

		list_for_each_entry(iclock, &iclock_list, list) {
		if (iclock->pri > pri) {
		pri = iclock->pri;
		bestclock = iclock;
		}
		if (iclock_current == iclock)
		lastclock = iclock;
		}
		if (lastclock && bestclock != lastclock) {
		/* last used clock source still exists but changes, disable */
		if (*debug & DEBUG_CLOCK)
		printk(KERN_DEBUG "Old clock source '%s' disable.\n",
		lastclock->name);
		lastclock->ctl(lastclock->priv, 0);
		}
		if (bestclock && bestclock != iclock_current) {
		/* new clock source selected, enable */
		if (*debug & DEBUG_CLOCK)
		printk(KERN_DEBUG "New clock source '%s' enable.\n",
		bestclock->name);
		bestclock->ctl(bestclock->priv, 1);
		}
		if (bestclock != iclock_current) {
		/* no clock received yet */
		iclock_tv_valid = 0;
		}
		iclock_current = bestclock;
		}

		struct mISDNclock
		mISDN_register_clock(char name, int pri, clockctl_func_t ctl, void priv)
		{
		u_long flags;
		struct mISDNclock *iclock;

		if (*debug & (DEBUG_CORE \| DEBUG_CLOCK))
		printk(KERN_DEBUG "%s: %s %d\n", __func__, name, pri);
		iclock = kzalloc(sizeof(struct mISDNclock), GFP_ATOMIC);
		if (!iclock) {
		printk(KERN_ERR "%s: No memory for clock entry.\n", __func__);
		return NULL;
		}
		strncpy(iclock->name, name, sizeof(iclock->name)-1);
		iclock->pri = pri;
		iclock->priv = priv;
		iclock->ctl = ctl;
		write_lock_irqsave(&iclock_lock, flags);
		list_add_tail(&iclock->list, &iclock_list);
		select_iclock();
		write_unlock_irqrestore(&iclock_lock, flags);
		return iclock;
		}
		EXPORT_SYMBOL(mISDN_register_clock);

		void
		mISDN_unregister_clock(struct mISDNclock *iclock)
		{
		u_long flags;

		if (*debug & (DEBUG_CORE \| DEBUG_CLOCK))
		printk(KERN_DEBUG "%s: %s %d\n", __func__, iclock->name,
		iclock->pri);
		write_lock_irqsave(&iclock_lock, flags);
		if (iclock_current == iclock) {
		if (*debug & DEBUG_CLOCK)
		printk(KERN_DEBUG
		"Current clock source '%s' unregisters.\n",
		iclock->name);
		iclock->ctl(iclock->priv, 0);
		}
		list_del(&iclock->list);
		select_iclock();
		write_unlock_irqrestore(&iclock_lock, flags);
		}
		EXPORT_SYMBOL(mISDN_unregister_clock);

		void
		mISDN_clock_update(struct mISDNclock iclock, int samples, struct timeval tv)
		{
		u_long flags;
		struct timeval tv_now;
		time_t elapsed_sec;
		int elapsed_8000th;

		write_lock_irqsave(&iclock_lock, flags);
		if (iclock_current != iclock) {
		printk(KERN_ERR "%s: '%s' sends us clock updates, but we do "
		"listen to '%s'. This is a bug!\n", __func__,
		iclock->name,
		iclock_current ? iclock_current->name : "nothing");
		iclock->ctl(iclock->priv, 0);
		write_unlock_irqrestore(&iclock_lock, flags);
		return;
		}
		if (iclock_tv_valid) {
		/* increment sample counter by given samples */
		iclock_count += samples;
		if (tv) { /* tv must be set, if function call is delayed */
		iclock_tv.tv_sec = tv->tv_sec;
		iclock_tv.tv_usec = tv->tv_usec;
		} else
		do_gettimeofday(&iclock_tv);
		} else {
		/* calc elapsed time by system clock */
		if (tv) { /* tv must be set, if function call is delayed */
		tv_now.tv_sec = tv->tv_sec;
		tv_now.tv_usec = tv->tv_usec;
		} else
		do_gettimeofday(&tv_now);
		elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec;
		elapsed_8000th = (tv_now.tv_usec / 125)
		- (iclock_tv.tv_usec / 125);
		if (elapsed_8000th < 0) {
		elapsed_sec -= 1;
		elapsed_8000th += 8000;
		}
		/* add elapsed time to counter and set new timestamp */
		iclock_count += elapsed_sec * 8000 + elapsed_8000th;
		iclock_tv.tv_sec = tv_now.tv_sec;
		iclock_tv.tv_usec = tv_now.tv_usec;
		iclock_tv_valid = 1;
		if (*debug & DEBUG_CLOCK)
		printk("Received first clock from source '%s'.\n",
		iclock_current ? iclock_current->name : "nothing");
		}
		write_unlock_irqrestore(&iclock_lock, flags);
		}
		EXPORT_SYMBOL(mISDN_clock_update);

		unsigned short
		mISDN_clock_get(void)
		{
		u_long flags;
		struct timeval tv_now;
		time_t elapsed_sec;
		int elapsed_8000th;
		u16 count;

		read_lock_irqsave(&iclock_lock, flags);
		/* calc elapsed time by system clock */
		do_gettimeofday(&tv_now);
		elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec;
		elapsed_8000th = (tv_now.tv_usec / 125) - (iclock_tv.tv_usec / 125);
		if (elapsed_8000th < 0) {
		elapsed_sec -= 1;
		elapsed_8000th += 8000;
		}
		/* add elapsed time to counter */
		count = iclock_count + elapsed_sec * 8000 + elapsed_8000th;
		read_unlock_irqrestore(&iclock_lock, flags);
		return count;
		}
		EXPORT_SYMBOL(mISDN_clock_get);

drivers/isdn/mISDN/core.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -199,6 +199,7 @@ mISDNInit(void)

		printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n",
		MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE);
		mISDN_init_clock(&debug);
		mISDN_initstack(&debug);
		err = mISDN_inittimer(&debug);
		if (err)