FGCOM/dahdi-linux
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xpp: Convert struct timeval -> ktime_t.

Browse Source 
`struct timeval` has been removed from the kernel interface in 5.0 as
part of fixing the 2038 problem. ktime_t is the preferred kernel time
interface now.

Signed-off-by: Shaun Ruffell <sruffell@sruffell.net>
This commit is contained in:
Shaun Ruffell 2019-03-27 17:17:45 +00:00
parent 8468250328
commit ffcd08205c
10 changed files with 112 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
drivers/dahdi/xpp/card_fxs.c
View File

@ -188,7 +188,7 @@ struct FXS_priv_data {
xpp_line_t neon_blinking;
xpp_line_t neonstate;
xpp_line_t vbat_h; /* High voltage */
struct timeval prev_key_time[CHANNELS_PERXPD];
ktime_t prev_key_time[CHANNELS_PERXPD];
int led_counter[NUM_LEDS][CHANNELS_PERXPD];
int overheat_reset_counter[CHANNELS_PERXPD];
int ohttimer[CHANNELS_PERXPD];
@ -1681,8 +1681,7 @@ static void process_hookstate(xpd_t *xpd, xpp_line_t offhook,
* Reset our previous DTMF memories...
*/
BIT_CLR(priv->prev_key_down, i);
priv->prev_key_time[i].tv_sec =
priv->prev_key_time[i].tv_usec = 0L;
priv->prev_key_time[i] = ktime_set(0L, 0UL);
if (IS_SET(offhook, i)) {
LINE_DBG(SIGNAL, xpd, i, "OFFHOOK\n");
MARK_ON(priv, i, LED_GREEN);
@ -1795,8 +1794,9 @@ static void process_dtmf(xpd_t *xpd, uint portnum, __u8 val)
bool want_mute;
bool want_event;
struct FXS_priv_data *priv;
struct timeval now;
int msec = 0;
ktime_t now;
s64 msec = 0;
struct timespec64 ts;
if (!dtmf_detection)
return;
@ -1813,16 +1813,16 @@ static void process_dtmf(xpd_t *xpd, uint portnum, __u8 val)
BIT_SET(priv->prev_key_down, portnum);
else
BIT_CLR(priv->prev_key_down, portnum);
do_gettimeofday(&now);
if (priv->prev_key_time[portnum].tv_sec != 0)
msec = usec_diff(&now, &priv->prev_key_time[portnum]) / 1000;
now = ktime_get();
if (!dahdi_ktime_equal(priv->prev_key_time[portnum], ktime_set(0, 0)))
msec = ktime_ms_delta(now, priv->prev_key_time[portnum]);
priv->prev_key_time[portnum] = now;
ts = ktime_to_timespec64(now);
LINE_DBG(SIGNAL, xpd, portnum,
"[%lu.%06lu] DTMF digit %-4s '%c' "
"(val=%d, want_mute=%s want_event=%s, delta=%d msec)\n",
now.tv_sec, now.tv_usec, (key_down) ? "DOWN" : "UP", digit,
val, (want_mute) ? "yes" : "no", (want_event) ? "yes" : "no",
msec);
"[%lld.%06ld] DTMF digit %-4s '%c' (val=%d, want_mute=%s want_event=%s, delta=%lld msec)\n",
(s64)ts.tv_sec, ts.tv_nsec * NSEC_PER_USEC,
(key_down) ? "DOWN" : "UP", digit, val,
(want_mute) ? "yes" : "no", (want_event) ? "yes" : "no", msec);
/*
* FIXME: we currently don't use the want_dtmf_mute until
* we are sure about the logic in Asterisk native bridging.

18
drivers/dahdi/xpp/xbus-core.c
View File

@ -259,7 +259,7 @@ void xframe_init(xbus_t *xbus, xframe_t *xframe, void *buf, size_t maxsize,
xframe->packets = xframe->first_free = buf;
xframe->frame_maxlen = maxsize;
atomic_set(&xframe->frame_len, 0);
do_gettimeofday(&xframe->tv_created);
xframe->kt_created = ktime_get();
xframe->xframe_magic = XFRAME_MAGIC;
}
EXPORT_SYMBOL(xframe_init);
@ -946,12 +946,12 @@ static int xbus_initialize(xbus_t *xbus)
int unit;
int subunit;
xpd_t *xpd;
struct timeval time_start;
struct timeval time_end;
ktime_t time_start;
ktime_t time_end;
unsigned long timediff;
int res = 0;
do_gettimeofday(&time_start);
time_start = ktime_get();
XBUS_DBG(DEVICES, xbus, "refcount_xbus=%d\n", refcount_xbus(xbus));
if (xbus_aquire_xpds(xbus) < 0) /* Until end of initialization */
return -EBUSY;
@ -989,7 +989,7 @@ static int xbus_initialize(xbus_t *xbus)
}
}
xbus_echocancel(xbus, 1);
do_gettimeofday(&time_end);
time_end = ktime_get();
timediff = usec_diff(&time_end, &time_start);
timediff /= 1000 * 100;
XBUS_INFO(xbus, "Initialized in %ld.%1ld sec\n", timediff / 10,
@ -1755,8 +1755,7 @@ out:
static void xbus_fill_proc_queue(struct seq_file *sfile, struct xframe_queue *q)
{
seq_printf(sfile,
"%-15s: counts %3d, %3d, %3d worst %3d, overflows %3d "
"worst_lag %02ld.%ld ms\n",
"%-15s: counts %3d, %3d, %3d worst %3d, overflows %3d worst_lag %02lld.%lld ms\n",
q->name, q->steady_state_count, q->count, q->max_count,
q->worst_count, q->overflows, q->worst_lag_usec / 1000,
q->worst_lag_usec % 1000);
@ -1792,8 +1791,9 @@ static int xbus_proc_show(struct seq_file *sfile, void *data)
seq_printf(sfile, "%5d ", xbus->cpu_rcv_tasklet[i]);
seq_printf(sfile, "\n");
}
seq_printf(sfile, "self_ticking: %d (last_tick at %ld)\n",
xbus->self_ticking, xbus->ticker.last_sample.tv.tv_sec);
seq_printf(sfile, "self_ticking: %d (last_tick at %lld)\n",
xbus->self_ticking, ktime_divns(xbus->ticker.last_sample,
NSEC_PER_SEC));
seq_printf(sfile, "command_tick: %d\n",
xbus->command_tick_counter);
seq_printf(sfile, "usec_nosend: %d\n", xbus->usec_nosend);

19
drivers/dahdi/xpp/xbus-core.h
View File

@ -234,8 +234,8 @@ struct xbus {
spinlock_t lock;
/* PCM metrics */
struct timeval last_tx_sync;
struct timeval last_rx_sync;
ktime_t last_tx_sync;
ktime_t last_rx_sync;
unsigned long max_tx_sync;
unsigned long min_tx_sync;
unsigned long max_rx_sync;
@ -255,7 +255,7 @@ struct xbus {
*/
int sync_adjustment;
int sync_adjustment_offset;
long pll_updated_at;
ktime_t pll_updated_at;
atomic_t num_xpds;
@ -279,10 +279,10 @@ struct xframe {
struct list_head frame_list;
atomic_t frame_len;
xbus_t *xbus;
struct timeval tv_created;
struct timeval tv_queued;
struct timeval tv_submitted;
struct timeval tv_received;
ktime_t kt_created;
ktime_t kt_queued;
ktime_t kt_submitted;
ktime_t kt_received;
/* filled by transport layer */
size_t frame_maxlen;
__u8 *packets; /* max XFRAME_DATASIZE */
@ -358,4 +358,9 @@ void xbus_sysfs_remove(xbus_t *xbus);
void astribank_uevent_send(xbus_t *xbus, enum kobject_action act);
static inline s64 xpp_ktime_sec_delta(ktime_t later, ktime_t earlier)
{
return ktime_divns(ktime_sub(later, earlier), NSEC_PER_SEC);
}
#endif /* XBUS_CORE_H */

80
drivers/dahdi/xpp/xbus-pcm.c
View File

@ -111,24 +111,23 @@ static void xpp_ticker_init(struct xpp_ticker *ticker)
{
memset(ticker, 0, sizeof(*ticker));
spin_lock_init(&ticker->lock);
do_gettimeofday(&ticker->last_sample.tv);
ticker->last_sample = ktime_get();
ticker->first_sample = ticker->last_sample;
ticker_set_cycle(ticker, SYNC_ADJ_QUICK);
}
static int xpp_ticker_step(struct xpp_ticker *ticker, const struct timeval *t)
static int xpp_ticker_step(struct xpp_ticker *ticker, const ktime_t t)
{
unsigned long flags;
long usec;
s64 usec;
bool cycled = 0;
spin_lock_irqsave(&ticker->lock, flags);
ticker->last_sample.tv = *t;
ticker->last_sample = t;
/* rate adjust */
if ((ticker->count % ticker->cycle) == ticker->cycle - 1) {
usec =
(long)usec_diff(&ticker->last_sample.tv,
&ticker->first_sample.tv);
usec = ktime_us_delta(ticker->last_sample,
ticker->first_sample);
ticker->first_sample = ticker->last_sample;
ticker->tick_period = usec / ticker->cycle;
cycled = 1;
@ -147,7 +146,7 @@ static inline void xbus_drift_clear(xbus_t *xbus)
{
struct xpp_drift *di = &xbus->drift;
do_gettimeofday(&di->last_lost_tick.tv);
di->last_lost_tick = ktime_get();
ticker_set_cycle(&xbus->ticker, SYNC_ADJ_QUICK);
di->max_speed = -SYNC_ADJ_MAX;
di->min_speed = SYNC_ADJ_MAX;
@ -190,14 +189,14 @@ static void sample_tick(xbus_t *xbus, int sample)
* including abrupt changes in sync -- to verify the stability of the
* algorithm.
*/
static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
static void xpp_drift_step(xbus_t *xbus, const ktime_t kt)
{
struct xpp_drift *di = &xbus->drift;
struct xpp_ticker *ticker = &xbus->ticker;
unsigned long flags;
spin_lock_irqsave(&di->lock, flags);
xpp_ticker_step(&xbus->ticker, tv);
xpp_ticker_step(&xbus->ticker, kt);
/*
* Do we need to be synchronized and is there an established reference
* ticker (another Astribank or another DAHDI device) already?
@ -206,7 +205,7 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
&& xbus->sync_mode == SYNC_MODE_PLL) {
int new_delta_tick = ticker->count - ref_ticker->count;
int lost_ticks = new_delta_tick - di->delta_tick;
long usec_delta;
s64 usec_delta;
di->delta_tick = new_delta_tick;
if (lost_ticks) {
@ -233,9 +232,8 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
}
} else {
/* Sample a delta */
usec_delta =
(long)usec_diff(&ticker->last_sample.tv,
&ref_ticker->last_sample.tv);
usec_delta = ktime_us_delta(ticker->last_sample,
ref_ticker->last_sample);
sample_tick(xbus, usec_delta);
if ((ticker->count % SYNC_CYCLE) >
(SYNC_CYCLE - SYNC_CYCLE_SAMPLE))
@ -282,8 +280,7 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv)
di->offset_min = offset;
XBUS_DBG(SYNC, xbus,
"offset: %d, min_speed=%d, "
"max_speed=%d, usec_delta(last)=%ld\n",
"offset: %d, min_speed=%d, max_speed=%d, usec_delta(last)=%lld\n",
offset_prev, di->min_speed,
di->max_speed, usec_delta);
XBUS_DBG(SYNC, xbus,
@ -356,10 +353,8 @@ static void xpp_set_syncer(xbus_t *xbus, bool on)
static void xbus_command_timer(TIMER_DATA_TYPE timer)
{
xbus_t *xbus = from_timer(xbus, timer, command_timer);
struct timeval now;
BUG_ON(!xbus);
do_gettimeofday(&now);
xbus_command_queue_tick(xbus);
if (!xbus->self_ticking) /* Must be 1KHz rate */
mod_timer(&xbus->command_timer, jiffies + 1);
@ -489,34 +484,34 @@ static void reset_sync_counters(void)
static void send_drift(xbus_t *xbus, int drift)
{
struct timeval now;
const ktime_t now = ktime_get();
const char *msg;
s64 msec_delta;
BUG_ON(abs(drift) > SYNC_ADJ_MAX);
do_gettimeofday(&now);
if (drift > xbus->sync_adjustment)
msg = "up";
else
msg = "down";
msec_delta = ktime_ms_delta(now, xbus->pll_updated_at);
XBUS_DBG(SYNC, xbus,
"%sDRIFT adjust %s (%d) (last update %ld seconds ago)\n",
"%sDRIFT adjust %s (%d) (last update %lld seconds ago)\n",
(disable_pll_sync) ? "Fake " : "", msg, drift,
now.tv_sec - xbus->pll_updated_at);
msec_delta / MSEC_PER_SEC);
if (!disable_pll_sync)
CALL_PROTO(GLOBAL, SYNC_SOURCE, xbus, NULL, SYNC_MODE_PLL,
drift);
xbus->pll_updated_at = now.tv_sec;
xbus->pll_updated_at = now;
}
static void global_tick(void)
{
struct timeval now;
ktime_t now = ktime_get();
do_gettimeofday(&now);
atomic_inc(&xpp_tick_counter);
if ((atomic_read(&xpp_tick_counter) % BIG_TICK_INTERVAL) == 0)
reset_sync_counters();
xpp_ticker_step(&global_ticks_series, &now);
xpp_ticker_step(&global_ticks_series, now);
}
#ifdef DAHDI_SYNC_TICK
@ -525,11 +520,11 @@ void dahdi_sync_tick(struct dahdi_span *span, int is_master)
struct phonedev *phonedev = container_of(span, struct phonedev, span);
xpd_t *xpd = container_of(phonedev, struct xpd, phonedev);
static int redundant_ticks; /* for extra spans */
struct timeval now;
ktime_t now;
if (!force_dahdi_sync)
goto noop;
do_gettimeofday(&now);
now = ktime_get();
BUG_ON(!xpd);
/*
* Detect if any of our spans is dahdi sync master
@ -562,7 +557,7 @@ void dahdi_sync_tick(struct dahdi_span *span, int is_master)
#endif
goto noop;
}
xpp_ticker_step(&dahdi_ticker, &now);
xpp_ticker_step(&dahdi_ticker, now);
dahdi_tick_count++;
//flip_parport_bit(1);
noop:
@ -854,15 +849,14 @@ static bool pcm_valid(xpd_t *xpd, xpacket_t *pack)
static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe)
{
unsigned long flags;
struct timeval now;
unsigned long usec;
const ktime_t now = ktime_get();
s64 usec;
spin_lock_irqsave(&xbus->lock, flags);
do_gettimeofday(&now);
if (unlikely(disable_pcm || !XBUS_IS(xbus, READY)))
goto dropit;
if (XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) {
usec = usec_diff(&now, &xbus->last_tx_sync);
usec = ktime_us_delta(now, xbus->last_tx_sync);
xbus->last_tx_sync = now;
/* ignore startup statistics */
if (likely
@ -872,8 +866,7 @@ static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe)
if ((rate_limit++ % 5003) == 0)
XBUS_DBG(SYNC, xbus,
"Bad PCM TX timing(%d): "
"usec=%ld.\n",
"Bad PCM TX timing(%d): usec=%lld.\n",
rate_limit, usec);
}
if (usec > xbus->max_tx_sync)
@ -1187,11 +1180,10 @@ static void xbus_tick(xbus_t *xbus)
while ((xframe = xframe_dequeue(&xbus->pcm_tospan)) != NULL) {
copy_pcm_tospan(xbus, xframe);
if (XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) {
struct timeval now;
unsigned long usec;
ktime_t now = ktime_get();
s64 usec;
do_gettimeofday(&now);
usec = usec_diff(&now, &xbus->last_rx_sync);
usec = ktime_us_delta(now, xbus->last_rx_sync);
xbus->last_rx_sync = now;
/* ignore startup statistics */
if (likely
@ -1202,9 +1194,7 @@ static void xbus_tick(xbus_t *xbus)
if ((rate_limit++ % 5003) == 0)
XBUS_DBG(SYNC, xbus,
"Bad PCM RX "
"timing(%d): "
"usec=%ld.\n",
"Bad PCM RX timing(%d): usec=%lld.\n",
rate_limit, usec);
}
if (usec > xbus->max_rx_sync)
@ -1235,7 +1225,7 @@ static void xbus_tick(xbus_t *xbus)
}
}
static void do_tick(xbus_t *xbus, const struct timeval *tv_received)
static void do_tick(xbus_t *xbus, const ktime_t kt_received)
{
int counter = atomic_read(&xpp_tick_counter);
unsigned long flags;
@ -1244,7 +1234,7 @@ static void do_tick(xbus_t *xbus, const struct timeval *tv_received)
if (global_ticker == xbus)
global_tick(); /* called from here or dahdi_sync_tick() */
spin_lock_irqsave(&ref_ticker_lock, flags);
xpp_drift_step(xbus, tv_received);
xpp_drift_step(xbus, kt_received);
spin_unlock_irqrestore(&ref_ticker_lock, flags);
if (likely(xbus->self_ticking))
xbus_tick(xbus);
@ -1268,7 +1258,7 @@ void xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe)
* FIXME: what about PRI split?
*/
if (XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) {
do_tick(xbus, &xframe->tv_received);
do_tick(xbus, xframe->kt_received);
atomic_inc(&xbus->pcm_rx_counter);
} else
xbus->xbus_frag_count++;

27
drivers/dahdi/xpp/xbus-pcm.h
View File

@ -39,16 +39,6 @@ enum sync_mode {
SYNC_MODE_QUERY = 0x80,
};
/*
* Abstract representation of timestamp.
* It would (eventually) replace the hard-coded
* timeval structs so we can migrate to better
* time representations.
*/
struct xpp_timestamp {
struct timeval tv;
};
/*
* A ticker encapsulates the timing information of some
* abstract tick source. The following tickers are used:
@ -60,8 +50,8 @@ struct xpp_timestamp {
struct xpp_ticker { /* for rate calculation */
int count;
int cycle;
struct xpp_timestamp first_sample;
struct xpp_timestamp last_sample;
ktime_t first_sample;
ktime_t last_sample;
int tick_period; /* usec/tick */
spinlock_t lock;
};
@ -75,7 +65,7 @@ struct xpp_drift {
int lost_ticks; /* occurances */
int lost_tick_count;
int sync_inaccuracy;
struct xpp_timestamp last_lost_tick;
ktime_t last_lost_tick;
long delta_sum;
int offset_prev;
int offset_range;
@ -88,15 +78,10 @@ struct xpp_drift {
void xpp_drift_init(xbus_t *xbus);
static inline long usec_diff(const struct timeval *tv1,
const struct timeval *tv2)
static inline long usec_diff(const ktime_t *tv1,
const ktime_t *tv2)
{
long diff_sec;
long diff_usec;
diff_sec = tv1->tv_sec - tv2->tv_sec;
diff_usec = tv1->tv_usec - tv2->tv_usec;
return diff_sec * 1000000 + diff_usec;
return ktime_us_delta(*tv1, *tv2);
}
int xbus_pcm_init(void *top);

20
drivers/dahdi/xpp/xbus-sysfs.c
View File

@ -31,6 +31,7 @@
#include <linux/device.h>
#include <linux/delay.h> /* for msleep() to debug */
#include <linux/sched.h>
#include <dahdi/kernel.h>
#include "xpd.h"
#include "xpp_dahdi.h"
#include "xbus-core.h"
@ -117,24 +118,28 @@ static DEVICE_ATTR_READER(timing_show, dev, buf)
xbus_t *xbus;
struct xpp_drift *driftinfo;
int len = 0;
struct timeval now;
ktime_t now;
do_gettimeofday(&now);
now = ktime_get();
xbus = dev_to_xbus(dev);
driftinfo = &xbus->drift;
len +=
snprintf(buf + len, PAGE_SIZE - len, "%-3s",
sync_mode_name(xbus->sync_mode));
if (xbus->sync_mode == SYNC_MODE_PLL) {
bool pll_updated = !dahdi_ktime_equal(xbus->pll_updated_at,
ktime_set(0, 0));
s64 update_delta =
(!pll_updated) ? 0 :
xpp_ktime_sec_delta(now, xbus->pll_updated_at);
len +=
snprintf(buf + len, PAGE_SIZE - len,
" %5d: lost (%4d,%4d) : ", xbus->ticker.cycle,
driftinfo->lost_ticks, driftinfo->lost_tick_count);
len +=
snprintf(buf + len, PAGE_SIZE - len,
"DRIFT %3d %ld sec ago", xbus->sync_adjustment,
(xbus->pll_updated_at ==
0) ? 0 : now.tv_sec - xbus->pll_updated_at);
"DRIFT %3d %lld sec ago", xbus->sync_adjustment,
update_delta);
}
len += snprintf(buf + len, PAGE_SIZE - len, "\n");
return len;
@ -229,7 +234,7 @@ static DEVICE_ATTR_READER(driftinfo_show, dev, buf)
xbus_t *xbus;
struct xpp_drift *di;
struct xpp_ticker *ticker;
struct timeval now;
ktime_t now = ktime_get();
int len = 0;
int hours;
int minutes;
@ -244,8 +249,7 @@ static DEVICE_ATTR_READER(driftinfo_show, dev, buf)
/*
* Calculate lost ticks time
*/
do_gettimeofday(&now);
seconds = now.tv_sec - di->last_lost_tick.tv.tv_sec;
seconds = ktime_ms_delta(now, di->last_lost_tick) / 1000;
minutes = seconds / 60;
seconds = seconds % 60;
hours = minutes / 60;

28
drivers/dahdi/xpp/xframe_queue.c
View File

@ -34,15 +34,15 @@ static void __xframe_dump_queue(struct xframe_queue *q)
xframe_t *xframe;
int i = 0;
char prefix[30];
struct timeval now;
ktime_t now = ktime_get();
do_gettimeofday(&now);
printk(KERN_DEBUG "%s: dump queue '%s' (first packet in each frame)\n",
THIS_MODULE->name, q->name);
list_for_each_entry_reverse(xframe, &q->head, frame_list) {
xpacket_t *pack = (xpacket_t *)&xframe->packets[0];
long usec = usec_diff(&now, &xframe->tv_queued);
snprintf(prefix, ARRAY_SIZE(prefix), " %3d> %5ld.%03ld msec",
s64 usec = ktime_us_delta(now, xframe->kt_queued);
snprintf(prefix, ARRAY_SIZE(prefix), " %3d> %5lld.%03lld msec",
i++, usec / 1000, usec % 1000);
dump_packet(prefix, pack, 1);
}
@ -60,9 +60,7 @@ static bool __xframe_enqueue(struct xframe_queue *q, xframe_t *xframe)
if (q->count >= q->max_count) {
q->overflows++;
if ((overflow_cnt++ % 1000) < 5) {
NOTICE("Overflow of %-15s: counts %3d, %3d, %3d "
"worst %3d, overflows %3d "
"worst_lag %02ld.%ld ms\n",
NOTICE("Overflow of %-15s: counts %3d, %3d, %3d worst %3d, overflows %3d worst_lag %02lld.%lld ms\n",
q->name, q->steady_state_count, q->count,
q->max_count, q->worst_count, q->overflows,
q->worst_lag_usec / 1000,
@ -75,7 +73,7 @@ static bool __xframe_enqueue(struct xframe_queue *q, xframe_t *xframe)
if (++q->count > q->worst_count)
q->worst_count = q->count;
list_add_tail(&xframe->frame_list, &q->head);
do_gettimeofday(&xframe->tv_queued);
xframe->kt_queued = ktime_get();
out:
return ret;
}
@ -96,8 +94,8 @@ static xframe_t *__xframe_dequeue(struct xframe_queue *q)
{
xframe_t *frm = NULL;
struct list_head *h;
struct timeval now;
unsigned long usec_lag;
ktime_t now;
s64 usec_lag;
if (list_empty(&q->head))
goto out;
@ -105,12 +103,8 @@ static xframe_t *__xframe_dequeue(struct xframe_queue *q)
list_del_init(h);
--q->count;
frm = list_entry(h, xframe_t, frame_list);
do_gettimeofday(&now);
usec_lag =
(now.tv_sec - frm->tv_queued.tv_sec) * 1000 * 1000 + (now.tv_usec -
frm->
tv_queued.
tv_usec);
now = ktime_get();
usec_lag = ktime_us_delta(now, frm->kt_queued);
if (q->worst_lag_usec < usec_lag)
q->worst_lag_usec = usec_lag;
out:
@ -284,7 +278,7 @@ xframe_t *get_xframe(struct xframe_queue *q)
BUG_ON(xframe->xframe_magic != XFRAME_MAGIC);
atomic_set(&xframe->frame_len, 0);
xframe->first_free = xframe->packets;
do_gettimeofday(&xframe->tv_created);
xframe->kt_created = ktime_get();
/*
* If later parts bother to correctly initialize their
* headers, there is no need to memset() the whole data.

2
drivers/dahdi/xpp/xframe_queue.h
View File

@ -19,7 +19,7 @@ struct xframe_queue {
/* statistics */
unsigned int worst_count;
unsigned int overflows;
unsigned long worst_lag_usec; /* since xframe creation */
s64 worst_lag_usec; /* since xframe creation */
};
void xframe_queue_init(struct xframe_queue *q, unsigned int steady_state_count,

19
drivers/dahdi/xpp/xpp_usb.c
View File

@ -200,7 +200,7 @@ struct xusb {
int counters[XUSB_COUNTER_MAX];
/* metrics */
struct timeval last_tx;
ktime_t last_tx;
unsigned int max_tx_delay;
uint usb_tx_delay[NUM_BUCKETS];
uint sluggish_debounce;
@ -365,7 +365,7 @@ static int do_send_xframe(xbus_t *xbus, xframe_t *xframe)
BUG_ON(!urb);
/* update urb length */
urb->transfer_buffer_length = XFRAME_LEN(xframe);
do_gettimeofday(&xframe->tv_submitted);
xframe->kt_submitted = ktime_get();
ret = usb_submit_urb(urb, GFP_ATOMIC);
if (ret < 0) {
static int rate_limit;
@ -863,8 +863,8 @@ static void xpp_send_callback(struct urb *urb)
xframe_t *xframe = &uframe->xframe;
xusb_t *xusb = uframe->xusb;
xbus_t *xbus = xbus_num(xusb->xbus_num);
struct timeval now;
long usec;
ktime_t now;
s64 usec;
int writes = atomic_read(&xusb->pending_writes);
int i;
@ -875,9 +875,9 @@ static void xpp_send_callback(struct urb *urb)
}
//flip_parport_bit(6);
atomic_dec(&xusb->pending_writes);
do_gettimeofday(&now);
xusb->last_tx = xframe->tv_submitted;
usec = usec_diff(&now, &xframe->tv_submitted);
now = ktime_get();
xusb->last_tx = xframe->kt_submitted;
usec = ktime_us_delta(now, xframe->kt_submitted);
if (usec < 0)
usec = 0; /* System clock jumped */
if (usec > xusb->max_tx_delay)
@ -931,9 +931,8 @@ static void xpp_receive_callback(struct urb *urb)
xbus_t *xbus = xbus_num(xusb->xbus_num);
size_t size;
bool do_resubmit = 1;
struct timeval now;
ktime_t now = ktime_get();
do_gettimeofday(&now);
atomic_dec(&xusb->pending_reads);
if (!xbus) {
XUSB_ERR(xusb,
@ -961,7 +960,7 @@ static void xpp_receive_callback(struct urb *urb)
goto err;
}
atomic_set(&xframe->frame_len, size);
xframe->tv_received = now;
xframe->kt_received = now;
// if (debug)
// dump_xframe("USB_FRAME_RECEIVE", xbus, xframe, debug);

12
drivers/dahdi/xpp/xproto.c
View File

@ -283,9 +283,8 @@ out:
int xframe_receive(xbus_t *xbus, xframe_t *xframe)
{
int ret = 0;
struct timeval now;
struct timeval tv_received;
int usec;
ktime_t kt_received;
s64 usec;
if (XFRAME_LEN(xframe) < RPACKET_HEADERSIZE) {
static int rate_limit;
@ -301,7 +300,7 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe)
XBUS_DBG(GENERAL, xbus, "Dropped xframe. Is shutting down.\n");
return -ENODEV;
}
tv_received = xframe->tv_received;
kt_received = xframe->kt_received;
/*
* We want to check that xframes do not mix PCM and other commands
*/
@ -315,10 +314,7 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe)
ret = xframe_receive_cmd(xbus, xframe);
}
/* Calculate total processing time */
do_gettimeofday(&now);
usec =
(now.tv_sec - tv_received.tv_sec) * 1000000 + now.tv_usec -
tv_received.tv_usec;
usec = ktime_us_delta(ktime_get(), kt_received);
if (usec > xbus->max_rx_process)
xbus->max_rx_process = usec;
return ret;