From dc228a61f57f12f036ae8b993aa3dc286493de67 Mon Sep 17 00:00:00 2001 From: Tzafrir Cohen Date: Wed, 11 Jan 2012 15:22:46 +0000 Subject: xpp: style - Run Lindent * Here it is: KERNEL_STYLE="-npro -kr -i8 -ts8 -sob -l80 -ss -ncs -cp1" TYPEDEFS=' -T gfp_t -T __user -T u_char -T __u8 -T byte -T bool -T charp -T xusb_t -T xbus_t -T xpd_t -T xproto_table_t -T xproto_entry_t -T xframe_t -T xpacket_t -T reg_cmd_t ' indent $TYPEDEFS $KERNEL_STYLE \ --ignore-newlines \ --indent-label0 \ --no-space-after-function-call-names \ "$@" Signed-off-by: Oron Peled Acked-By: Tzafrir Cohen git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@10428 a0bf4364-ded3-4de4-8d8a-66a801d63aff --- drivers/dahdi/xpp/xbus-pcm.c | 519 +++++++++++++++++++++++-------------------- 1 file changed, 284 insertions(+), 235 deletions(-) (limited to 'drivers/dahdi/xpp/xbus-pcm.c') diff --git a/drivers/dahdi/xpp/xbus-pcm.c b/drivers/dahdi/xpp/xbus-pcm.c index f597a47..2e24db4 100644 --- a/drivers/dahdi/xpp/xbus-pcm.c +++ b/drivers/dahdi/xpp/xbus-pcm.c @@ -22,7 +22,7 @@ #include #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) -# warning "This module is tested only with 2.6 kernels" +#warning "This module is tested only with 2.6 kernels" #endif #include @@ -37,29 +37,32 @@ static const char rcsid[] = "$Id$"; extern int debug; #ifdef OPTIMIZE_CHANMUTE -static DEF_PARM_BOOL(optimize_chanmute, 1, 0644, "Optimize by muting inactive channels"); +static DEF_PARM_BOOL(optimize_chanmute, 1, 0644, + "Optimize by muting inactive channels"); #endif static DEF_PARM(int, disable_pcm, 0, 0644, "Disable all PCM transmissions"); #ifdef DEBUG_PCMTX -DEF_PARM(int, pcmtx, -1, 0644, "Forced PCM value to transmit (negative to disable)"); +DEF_PARM(int, pcmtx, -1, 0644, + "Forced PCM value to transmit (negative to disable)"); DEF_PARM(int, pcmtx_chan, 0, 0644, "channel to force PCM value"); #endif -static DEF_PARM_BOOL(disable_pll_sync, 0, 0644, "Disable automatic adjustment of AB clocks"); +static DEF_PARM_BOOL(disable_pll_sync, 0, 0644, + "Disable automatic adjustment of AB clocks"); -static xbus_t *syncer; /* current syncer */ -static atomic_t xpp_tick_counter = ATOMIC_INIT(0); -static struct xpp_ticker dahdi_ticker; +static xbus_t *syncer; /* current syncer */ +static atomic_t xpp_tick_counter = ATOMIC_INIT(0); +static struct xpp_ticker dahdi_ticker; /* * The ref_ticker points to the current referece tick source. * I.e: one of our AB or dahdi_ticker */ -static struct xpp_ticker *ref_ticker; +static struct xpp_ticker *ref_ticker; static DEFINE_SPINLOCK(ref_ticker_lock); static DEFINE_SPINLOCK(elect_syncer_lock); -static bool force_dahdi_sync; /* from /sys/bus/astribanks/drivers/xppdrv/sync */ -static xbus_t *global_ticker; -static struct xpp_ticker global_ticks_series; +static bool force_dahdi_sync; /* from /sys/bus/astribanks/drivers/xppdrv/sync */ +static xbus_t *global_ticker; +static struct xpp_ticker global_ticks_series; #define PROC_SYNC "sync" #define SYNC_CYCLE 500 /* Sampling cycle in usec */ @@ -80,7 +83,7 @@ static struct xpp_ticker global_ticks_series; #define SYNC_ADJ_SLOW 10000 #ifdef DAHDI_SYNC_TICK -static unsigned int dahdi_tick_count; +static unsigned int dahdi_tick_count; #endif /*------------------------- SYNC Handling --------------------------*/ @@ -89,7 +92,7 @@ static void send_drift(xbus_t *xbus, int drift); static void ticker_set_cycle(struct xpp_ticker *ticker, int cycle) { - unsigned long flags; + unsigned long flags; spin_lock_irqsave(&ticker->lock, flags); if (cycle < SYNC_ADJ_QUICK) @@ -111,16 +114,16 @@ static void xpp_ticker_init(struct xpp_ticker *ticker) static int xpp_ticker_step(struct xpp_ticker *ticker, const struct timeval *t) { - unsigned long flags; - long usec; - bool cycled = 0; + unsigned long flags; + long usec; + bool cycled = 0; spin_lock_irqsave(&ticker->lock, flags); ticker->last_sample.tv = *t; if ((ticker->count % ticker->cycle) == ticker->cycle - 1) { /* rate adjust */ - usec = (long)usec_diff( - &ticker->last_sample.tv, - &ticker->first_sample.tv); + usec = + (long)usec_diff(&ticker->last_sample.tv, + &ticker->first_sample.tv); ticker->first_sample = ticker->last_sample; ticker->tick_period = usec / ticker->cycle; cycled = 1; @@ -137,12 +140,12 @@ static int xpp_ticker_step(struct xpp_ticker *ticker, const struct timeval *t) */ static inline void xbus_drift_clear(xbus_t *xbus) { - struct xpp_drift *di = &xbus->drift; + struct xpp_drift *di = &xbus->drift; do_gettimeofday(&di->last_lost_tick.tv); ticker_set_cycle(&xbus->ticker, SYNC_ADJ_QUICK); di->max_speed = -SYNC_ADJ_MAX; - di->min_speed = SYNC_ADJ_MAX; + di->min_speed = SYNC_ADJ_MAX; } void xpp_drift_init(xbus_t *xbus) @@ -184,9 +187,9 @@ static void sample_tick(xbus_t *xbus, int sample) */ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) { - struct xpp_drift *di = &xbus->drift; - struct xpp_ticker *ticker = &xbus->ticker; - unsigned long flags; + 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); @@ -194,14 +197,15 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) * Do we need to be synchronized and is there an established reference * ticker (another Astribank or another DAHDI device) already? */ - if (ref_ticker && ref_ticker != &xbus->ticker && syncer && 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; + if (ref_ticker && ref_ticker != &xbus->ticker && syncer + && 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; di->delta_tick = new_delta_tick; if (lost_ticks) { - static int rate_limit; + static int rate_limit; /* * We just lost some ticks. Just report it and don't @@ -215,8 +219,8 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) * startup. */ XBUS_DBG(SYNC, xbus, "Lost %d tick%s\n", - lost_ticks, - (abs(lost_ticks) > 1) ? "s": ""); + lost_ticks, + (abs(lost_ticks) > 1) ? "s" : ""); } if (abs(lost_ticks) > 100) { xbus_drift_clear(xbus); @@ -224,24 +228,28 @@ 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 = + (long)usec_diff(&ticker->last_sample.tv, + &ref_ticker->last_sample.tv); sample_tick(xbus, usec_delta); - if ((ticker->count % SYNC_CYCLE) > (SYNC_CYCLE - SYNC_CYCLE_SAMPLE)) - di->delta_sum += usec_delta; + if ((ticker->count % SYNC_CYCLE) > + (SYNC_CYCLE - SYNC_CYCLE_SAMPLE)) + di->delta_sum += usec_delta; if ((ticker->count % SYNC_CYCLE) == 0) { /* * Full sampling cycle passed. Let's calculate */ - int offset = di->delta_sum / SYNC_CYCLE_SAMPLE - SYNC_CENTER; - int offset_prev = di->offset_prev; - int speed = xbus->sync_adjustment; - int fix = 0; - int best_speed = (di->max_speed + di->min_speed) >> 1; - - if (offset > 0 && offset < SYNC_DELTA) { + int offset = + di->delta_sum / SYNC_CYCLE_SAMPLE - + SYNC_CENTER; + int offset_prev = di->offset_prev; + int speed = xbus->sync_adjustment; + int fix = 0; + int best_speed = + (di->max_speed + di->min_speed) >> 1; + + if (offset > 0 && offset < SYNC_DELTA) { speed = best_speed - 1; } else if (offset < 0 && offset > -SYNC_DELTA) { speed = best_speed + 1; @@ -258,26 +266,32 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) if (speed < -SYNC_ADJ_MAX) speed = -SYNC_ADJ_MAX; if (speed > SYNC_ADJ_MAX) - speed = SYNC_ADJ_MAX; + speed = SYNC_ADJ_MAX; if (speed < di->min_speed) - di->min_speed = speed; + di->min_speed = speed; if (speed > di->max_speed) - di->max_speed = speed; + di->max_speed = speed; if (offset > di->offset_max) di->offset_max = offset; if (offset < di->offset_min) di->offset_min = offset; - XBUS_DBG(SYNC, xbus, "offset: %d, min_speed=%d, max_speed=%d, usec_delta(last)=%ld\n", - offset_prev, di->min_speed, di->max_speed, usec_delta); - XBUS_DBG(SYNC, xbus, "ADJ: speed=%d (best_speed=%d) fix=%d\n", - speed, best_speed, fix); + XBUS_DBG(SYNC, xbus, + "offset: %d, min_speed=%d, max_speed=%d, usec_delta(last)=%ld\n", + offset_prev, di->min_speed, + di->max_speed, usec_delta); + XBUS_DBG(SYNC, xbus, + "ADJ: speed=%d (best_speed=%d) fix=%d\n", + speed, best_speed, fix); xbus->sync_adjustment_offset = speed; - if (xbus != syncer && xbus->sync_adjustment != speed) + if (xbus != syncer + && xbus->sync_adjustment != speed) send_drift(xbus, speed); - di->sync_inaccuracy = abs(offset) + abs(di->offset_range) / 2; + di->sync_inaccuracy = + abs(offset) + abs(di->offset_range) / 2; if (ticker->count >= SYNC_CYCLE * SYNC_CONVERGE) { - di->offset_range = di->offset_max - di->offset_min; + di->offset_range = + di->offset_max - di->offset_min; di->offset_min = INT_MAX; di->offset_max = -INT_MAX; if (di->max_speed > best_speed) @@ -286,7 +300,7 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) di->min_speed++; } di->offset_prev = offset; - di->delta_sum = 0; + di->delta_sum = 0; } } } @@ -295,11 +309,11 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) const char *sync_mode_name(enum sync_mode mode) { - static const char *sync_mode_names[] = { - [SYNC_MODE_AB] = "AB", - [SYNC_MODE_NONE] = "NONE", - [SYNC_MODE_PLL] = "PLL", - [SYNC_MODE_QUERY] = "QUERY", + static const char *sync_mode_names[] = { + [SYNC_MODE_AB] = "AB", + [SYNC_MODE_NONE] = "NONE", + [SYNC_MODE_PLL] = "PLL", + [SYNC_MODE_QUERY] = "QUERY", }; if (mode >= ARRAY_SIZE(sync_mode_names)) return NULL; @@ -311,7 +325,7 @@ const char *sync_mode_name(enum sync_mode mode) */ static void xpp_set_syncer(xbus_t *xbus, bool on) { - if (!xbus) { /* Special case, no more syncers */ + if (!xbus) { /* Special case, no more syncers */ DBG(SYNC, "No more syncers\n"); syncer = NULL; if (ref_ticker != &dahdi_ticker) @@ -328,14 +342,14 @@ static void xpp_set_syncer(xbus_t *xbus, bool on) ref_ticker = NULL; } else XBUS_DBG(SYNC, xbus, "ignore %s (current syncer: %s)\n", - (on)?"ON":"OFF", - (syncer) ? syncer->busname : "NO-SYNC"); + (on) ? "ON" : "OFF", + (syncer) ? syncer->busname : "NO-SYNC"); } static void xbus_command_timer(unsigned long param) { - xbus_t *xbus = (xbus_t *)param; - struct timeval now; + xbus_t *xbus = (xbus_t *)param; + struct timeval now; BUG_ON(!xbus); do_gettimeofday(&now); @@ -346,7 +360,7 @@ static void xbus_command_timer(unsigned long param) void xbus_set_command_timer(xbus_t *xbus, bool on) { - XBUS_DBG(SYNC, xbus, "%s\n", (on)?"ON":"OFF"); + XBUS_DBG(SYNC, xbus, "%s\n", (on) ? "ON" : "OFF"); if (on) { if (!timer_pending(&xbus->command_timer)) { XBUS_DBG(SYNC, xbus, "add_timer\n"); @@ -359,7 +373,7 @@ void xbus_set_command_timer(xbus_t *xbus, bool on) XBUS_DBG(SYNC, xbus, "del_timer\n"); del_timer(&xbus->command_timer); } - xbus->self_ticking = ! on; + xbus->self_ticking = !on; } /* @@ -367,19 +381,20 @@ void xbus_set_command_timer(xbus_t *xbus, bool on) */ void got_new_syncer(xbus_t *xbus, enum sync_mode mode, int drift) { - unsigned long flags; - unsigned long flags2; + unsigned long flags; + unsigned long flags2; spin_lock_irqsave(&xbus->lock, flags); spin_lock_irqsave(&ref_ticker_lock, flags2); xbus->sync_adjustment = (signed char)drift; if (xbus->sync_mode == mode) { XBUS_DBG(SYNC, xbus, "Already in mode '%s'. Ignored\n", - sync_mode_name(mode)); + sync_mode_name(mode)); goto out; } XBUS_DBG(SYNC, xbus, "Mode %s (%d), drift=%d (pcm_rx_counter=%d)\n", - sync_mode_name(mode), mode, drift, atomic_read(&xbus->pcm_rx_counter)); + sync_mode_name(mode), mode, drift, + atomic_read(&xbus->pcm_rx_counter)); switch (mode) { case SYNC_MODE_AB: xbus->sync_mode = mode; @@ -393,12 +408,12 @@ void got_new_syncer(xbus_t *xbus, enum sync_mode mode, int drift) xpp_set_syncer(xbus, 0); global_ticker = xbus; break; - case SYNC_MODE_NONE: /* lost sync source */ + case SYNC_MODE_NONE: /* lost sync source */ xbus->sync_mode = mode; xbus_set_command_timer(xbus, 1); xpp_set_syncer(xbus, 0); break; - case SYNC_MODE_QUERY: /* ignore */ + case SYNC_MODE_QUERY: /* ignore */ break; default: XBUS_ERR(xbus, "%s: unknown mode=0x%X\n", __func__, mode); @@ -410,7 +425,7 @@ out: void xbus_request_sync(xbus_t *xbus, enum sync_mode mode) { - unsigned long flags; + unsigned long flags; BUG_ON(!xbus); XBUS_DBG(SYNC, xbus, "sent request (mode=%d)\n", mode); @@ -436,11 +451,11 @@ void xbus_request_sync(xbus_t *xbus, enum sync_mode mode) static void reset_sync_counters(void) { - int i; + int i; //DBG(SYNC, "%d\n", atomic_read(&xpp_tick_counter)); for (i = 0; i < MAX_BUSES; i++) { - xbus_t *xbus = get_xbus(__func__, i); + xbus_t *xbus = get_xbus(__func__, i); if (xbus == NULL) continue; @@ -448,15 +463,16 @@ static void reset_sync_counters(void) * Don't send to non self_ticking Astribanks: * - Maybe they didn't finish initialization * - Or maybe they didn't answer us in the first place - (e.g: wrong firmware version, etc). + (e.g: wrong firmware version, etc). */ if (xbus->self_ticking) { if (!XBUS_FLAGS(xbus, CONNECTED)) { XBUS_DBG(GENERAL, xbus, - "Dropped packet. Is shutting down.\n"); + "Dropped packet. Is shutting down.\n"); } else { /* Reset sync LEDs once in a while */ - CALL_PROTO(GLOBAL, RESET_SYNC_COUNTERS, xbus, NULL); + CALL_PROTO(GLOBAL, RESET_SYNC_COUNTERS, xbus, + NULL); } } put_xbus(__func__, xbus); @@ -465,8 +481,8 @@ static void reset_sync_counters(void) static void send_drift(xbus_t *xbus, int drift) { - struct timeval now; - const char *msg; + struct timeval now; + const char *msg; BUG_ON(abs(drift) > SYNC_ADJ_MAX); do_gettimeofday(&now); @@ -474,17 +490,19 @@ static void send_drift(xbus_t *xbus, int drift) msg = "up"; else msg = "down"; - XBUS_DBG(SYNC, xbus, "%sDRIFT adjust %s (%d) (last update %ld seconds ago)\n", - (disable_pll_sync) ? "Fake " : "", - msg, drift, now.tv_sec - xbus->pll_updated_at); + XBUS_DBG(SYNC, xbus, + "%sDRIFT adjust %s (%d) (last update %ld seconds ago)\n", + (disable_pll_sync) ? "Fake " : "", msg, drift, + now.tv_sec - xbus->pll_updated_at); if (!disable_pll_sync) - CALL_PROTO(GLOBAL, SYNC_SOURCE, xbus, NULL, SYNC_MODE_PLL, drift); + CALL_PROTO(GLOBAL, SYNC_SOURCE, xbus, NULL, SYNC_MODE_PLL, + drift); xbus->pll_updated_at = now.tv_sec; } static void global_tick(void) { - struct timeval now; + struct timeval now; do_gettimeofday(&now); atomic_inc(&xpp_tick_counter); @@ -496,10 +514,10 @@ static void global_tick(void) #ifdef DAHDI_SYNC_TICK 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; + 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; if (!force_dahdi_sync) goto noop; @@ -509,25 +527,26 @@ void dahdi_sync_tick(struct dahdi_span *span, int is_master) * Detect if any of our spans is dahdi sync master */ if (is_master) { - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 10003) == 0) - XPD_NOTICE(xpd, "Is a DAHDI sync master: ignore sync from DAHDI\n"); + XPD_NOTICE(xpd, + "Is a DAHDI sync master: ignore sync from DAHDI\n"); goto noop; } /* Now we know for sure someone else is dahdi sync master */ if (syncer) { - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 5003) == 0) XBUS_DBG(SYNC, syncer, - "is a SYNCer: ignore sync from DAHDI\n"); + "is a SYNCer: ignore sync from DAHDI\n"); goto noop; } /* ignore duplicate calls from all our registered spans */ if ((redundant_ticks++ % total_registered_spans()) != 0) { #if 0 - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 1003) < 16) XPD_NOTICE(xpd, "boop (%d)\n", dahdi_tick_count); @@ -549,16 +568,15 @@ noop: */ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi) { - const char *msg; - int i; - unsigned long flags; + const char *msg; + int i; + unsigned long flags; WARN_ON(new_syncer && force_dahdi); /* Ambigous */ force_dahdi_sync = force_dahdi; msg = (force_dahdi_sync) ? "DAHDI" : "NO-SYNC"; - DBG(SYNC, "%s => %s\n", - (syncer) ? syncer->busname : msg, - (new_syncer) ? new_syncer->busname : msg); + DBG(SYNC, "%s => %s\n", (syncer) ? syncer->busname : msg, + (new_syncer) ? new_syncer->busname : msg); /* * This global locking protects: * - The ref_ticker so it won't be used while we change it. @@ -575,7 +593,7 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi) xbus_drift_clear(syncer); /* Clean old data */ if (new_syncer) { XBUS_DBG(SYNC, new_syncer, "pcm_rx_counter=%d\n", - atomic_read(&new_syncer->pcm_rx_counter)); + atomic_read(&new_syncer->pcm_rx_counter)); force_dahdi_sync = 0; ref_ticker = &new_syncer->ticker; xbus_drift_clear(new_syncer); /* Clean new data */ @@ -590,15 +608,16 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi) DBG(SYNC, "stop unwanted syncers\n"); /* Shut all down except the wanted sync master */ for (i = 0; i < MAX_BUSES; i++) { - xbus_t *xbus = get_xbus(__func__, i); + xbus_t *xbus = get_xbus(__func__, i); if (xbus == NULL) continue; if (XBUS_FLAGS(xbus, CONNECTED) && xbus != new_syncer) { if (xbus->self_ticking) xbus_request_sync(xbus, - xbus->sync_mode_default); + xbus->sync_mode_default); else - XBUS_DBG(SYNC, xbus, "Not self_ticking yet. Ignore\n"); + XBUS_DBG(SYNC, xbus, + "Not self_ticking yet. Ignore\n"); } put_xbus(__func__, xbus); } @@ -606,18 +625,18 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi) void elect_syncer(const char *msg) { - int i; - int j; - uint timing_priority = INT_MAX; - xpd_t *best_xpd = NULL; - xbus_t *the_xbus = NULL; - unsigned long flags; + int i; + int j; + uint timing_priority = INT_MAX; + xpd_t *best_xpd = NULL; + xbus_t *the_xbus = NULL; + unsigned long flags; spin_lock_irqsave(&elect_syncer_lock, flags); DBG(SYNC, "%s: %s syncer=%s\n", __func__, msg, - (syncer) ? syncer->busname : "NULL"); + (syncer) ? syncer->busname : "NULL"); for (i = 0; i < MAX_BUSES; i++) { - xbus_t *xbus = get_xbus(__func__, i); + xbus_t *xbus = get_xbus(__func__, i); if (xbus == NULL) continue; @@ -625,15 +644,18 @@ void elect_syncer(const char *msg) if (!the_xbus) the_xbus = xbus; /* First candidate */ for (j = 0; j < MAX_XPDS; j++) { - xpd_t *xpd = xpd_of(xbus, j); - int prio; + xpd_t *xpd = xpd_of(xbus, j); + int prio; - if (!xpd || !xpd->card_present || !IS_PHONEDEV(xpd)) + if (!xpd || !xpd->card_present + || !IS_PHONEDEV(xpd)) continue; - prio = CALL_PHONE_METHOD(card_timing_priority, xpd); + prio = + CALL_PHONE_METHOD(card_timing_priority, + xpd); if (prio < 0) { DBG(SYNC, "%s/%s: skip sync\n", - xbus->busname, xpd->xpdname); + xbus->busname, xpd->xpdname); continue; } if (prio > 0 && prio < timing_priority) { @@ -646,11 +668,12 @@ void elect_syncer(const char *msg) } if (best_xpd) { the_xbus = best_xpd->xbus; - XPD_DBG(SYNC, best_xpd, "%s: elected with priority %d\n", msg, timing_priority); + XPD_DBG(SYNC, best_xpd, "%s: elected with priority %d\n", msg, + timing_priority); } else if (the_xbus) { XBUS_DBG(SYNC, the_xbus, "%s: elected\n", msg); } else { - unsigned long flags; + unsigned long flags; DBG(SYNC, "%s: No more syncers\n", msg); spin_lock_irqsave(&ref_ticker_lock, flags); @@ -681,10 +704,10 @@ void update_wanted_pcm_mask(xpd_t *xpd, xpp_line_t new_mask, uint new_pcm_len) */ void generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask) { - int i; - int line_count = 0; - unsigned long flags; - uint pcm_len; + int i; + int line_count = 0; + unsigned long flags; + uint pcm_len; spin_lock_irqsave(&PHONEDEV(xpd).lock_recompute_pcm, flags); //XPD_DBG(SIGNAL, xpd, "pcm_mask=0x%X\n", pcm_mask); @@ -694,8 +717,8 @@ void generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask) pcm_mask &= ~(PHONEDEV(xpd).digital_inputs); pcm_mask &= ~(PHONEDEV(xpd).digital_outputs); for_each_line(xpd, i) - if (IS_SET(pcm_mask, i)) - line_count++; + if (IS_SET(pcm_mask, i)) + line_count++; /* * FIXME: Workaround a bug in sync code of the Astribank. * Send dummy PCM for sync. @@ -705,17 +728,17 @@ void generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask) line_count = 1; } pcm_len = (line_count) - ? RPACKET_HEADERSIZE + sizeof(xpp_line_t) + line_count * DAHDI_CHUNKSIZE - : 0L; + ? RPACKET_HEADERSIZE + sizeof(xpp_line_t) + + line_count * DAHDI_CHUNKSIZE : 0L; update_wanted_pcm_mask(xpd, pcm_mask, pcm_len); spin_unlock_irqrestore(&PHONEDEV(xpd).lock_recompute_pcm, flags); } void fill_beep(u_char *buf, int num, int duration) { - bool alternate = (duration) ? (jiffies/(duration*1000)) & 0x1 : 0; - int which; - u_char *snd; + bool alternate = (duration) ? (jiffies / (duration * 1000)) & 0x1 : 0; + int which; + u_char *snd; /* * debug tones @@ -739,18 +762,21 @@ void fill_beep(u_char *buf, int num, int duration) static void do_ec(xpd_t *xpd) { - int i; + int i; - for (i = 0;i < PHONEDEV(xpd).span.channels; i++) { - struct dahdi_chan *chan = XPD_CHAN(xpd, i); + for (i = 0; i < PHONEDEV(xpd).span.channels; i++) { + struct dahdi_chan *chan = XPD_CHAN(xpd, i); if (unlikely(IS_SET(PHONEDEV(xpd).digital_signalling, i))) /* Don't echo cancel BRI D-chans */ continue; - if (!IS_SET(PHONEDEV(xpd).wanted_pcm_mask, i)) /* No ec for unwanted PCM */ + if (!IS_SET(PHONEDEV(xpd).wanted_pcm_mask, i)) /* No ec for unwanted PCM */ continue; - dahdi_ec_chunk(chan, chan->readchunk, PHONEDEV(xpd).ec_chunk2[i]); - memcpy(PHONEDEV(xpd).ec_chunk2[i], PHONEDEV(xpd).ec_chunk1[i], DAHDI_CHUNKSIZE); - memcpy(PHONEDEV(xpd).ec_chunk1[i], chan->writechunk, DAHDI_CHUNKSIZE); + dahdi_ec_chunk(chan, chan->readchunk, + PHONEDEV(xpd).ec_chunk2[i]); + memcpy(PHONEDEV(xpd).ec_chunk2[i], PHONEDEV(xpd).ec_chunk1[i], + DAHDI_CHUNKSIZE); + memcpy(PHONEDEV(xpd).ec_chunk1[i], chan->writechunk, + DAHDI_CHUNKSIZE); } } @@ -762,26 +788,26 @@ static void do_ec(xpd_t *xpd) set the DAHDI_FLAG_RBS in this case. */ /* Opt: If the span uses A/B bits, set them here */ -int (*rbsbits)(struct dahdi_chan *chan, int bits); +int (*rbsbits) (struct dahdi_chan * chan, int bits); /* Option 2: If you don't know about sig bits, but do have their equivalents (i.e. you can disconnect battery, detect off hook, generate ring, etc directly) then you can just specify a sethook function, and we'll call you with appropriate hook states to set. Still set the DAHDI_FLAG_RBS in this case as well */ -int (*hooksig)(struct dahdi_chan *chan, enum dahdi_txsig hookstate); +int (*hooksig) (struct dahdi_chan * chan, enum dahdi_txsig hookstate); /* Option 3: If you can't use sig bits, you can write a function which handles the individual hook states */ -int (*sethook)(struct dahdi_chan *chan, int hookstate); +int (*sethook) (struct dahdi_chan * chan, int hookstate); #endif static bool pcm_valid(xpd_t *xpd, xpacket_t *pack) { - xpp_line_t lines = RPACKET_FIELD(pack, GLOBAL, PCM_READ, lines); - int i; - int count = 0; - uint16_t good_len; + xpp_line_t lines = RPACKET_FIELD(pack, GLOBAL, PCM_READ, lines); + int i; + int count = 0; + uint16_t good_len; BUG_ON(!pack); BUG_ON(XPACKET_OP(pack) != XPROTO_NAME(GLOBAL, PCM_READ)); @@ -799,8 +825,9 @@ static bool pcm_valid(xpd_t *xpd, xpacket_t *pack) XPD_COUNTER(xpd, RECV_ERRORS)++; if ((rate_limit++ % 1000) <= 10) { - XPD_ERR(xpd, "BAD PCM REPLY: packet_len=%d (should be %d), count=%d\n", - XPACKET_LEN(pack), good_len, count); + XPD_ERR(xpd, + "BAD PCM REPLY: packet_len=%d (should be %d), count=%d\n", + XPACKET_LEN(pack), good_len, count); dump_packet("BAD PCM REPLY", pack, 1); } return 0; @@ -808,13 +835,11 @@ static bool pcm_valid(xpd_t *xpd, xpacket_t *pack) return 1; } - - static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe) { - unsigned long flags; - struct timeval now; - unsigned long usec; + unsigned long flags; + struct timeval now; + unsigned long usec; spin_lock_irqsave(&xbus->lock, flags); do_gettimeofday(&now); @@ -824,13 +849,15 @@ static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe) usec = usec_diff(&now, &xbus->last_tx_sync); xbus->last_tx_sync = now; /* ignore startup statistics */ - if (likely(atomic_read(&xbus->pcm_rx_counter) > BIG_TICK_INTERVAL)) { + if (likely + (atomic_read(&xbus->pcm_rx_counter) > BIG_TICK_INTERVAL)) { if (abs(usec - 1000) > TICK_TOLERANCE) { - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 5003) == 0) - XBUS_DBG(SYNC, xbus, "Bad PCM TX timing(%d): usec=%ld.\n", - rate_limit, usec); + XBUS_DBG(SYNC, xbus, + "Bad PCM TX timing(%d): usec=%ld.\n", + rate_limit, usec); } if (usec > xbus->max_tx_sync) xbus->max_tx_sync = usec; @@ -840,7 +867,7 @@ static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe) } spin_unlock_irqrestore(&xbus->lock, flags); /* OK, really send it */ - if (debug & DBG_PCM ) + if (debug & DBG_PCM) dump_xframe("TX_XFRAME_PCM", xbus, xframe, debug); send_pcm_frame(xbus, xframe); XBUS_COUNTER(xbus, TX_XFRAME_PCM)++; @@ -856,10 +883,10 @@ dropit: */ void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) { - __u8 *pcm; - unsigned long flags; - xpp_line_t wanted_lines; - int i; + __u8 *pcm; + unsigned long flags; + xpp_line_t wanted_lines; + int i; BUG_ON(!xpd); BUG_ON(!pack); @@ -868,18 +895,20 @@ void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) pcm = RPACKET_FIELD(pack, GLOBAL, PCM_WRITE, pcm); spin_lock_irqsave(&xpd->lock, flags); for (i = 0; i < PHONEDEV(xpd).channels; i++) { - struct dahdi_chan *chan = XPD_CHAN(xpd, i); + struct dahdi_chan *chan = XPD_CHAN(xpd, i); if (IS_SET(wanted_lines, i)) { if (SPAN_REGISTERED(xpd)) { #ifdef DEBUG_PCMTX - int channo = chan->channo; + int channo = chan->channo; if (pcmtx >= 0 && pcmtx_chan == channo) - memset((u_char *)pcm, pcmtx, DAHDI_CHUNKSIZE); + memset((u_char *)pcm, pcmtx, + DAHDI_CHUNKSIZE); else #endif - memcpy((u_char *)pcm, chan->writechunk, DAHDI_CHUNKSIZE); + memcpy((u_char *)pcm, chan->writechunk, + DAHDI_CHUNKSIZE); } else memset((u_char *)pcm, 0x7F, DAHDI_CHUNKSIZE); pcm += DAHDI_CHUNKSIZE; @@ -891,11 +920,11 @@ void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) { - __u8 *pcm; - xpp_line_t pcm_mask; - xpp_line_t pcm_mute; - unsigned long flags; - int i; + __u8 *pcm; + xpp_line_t pcm_mask; + xpp_line_t pcm_mute; + unsigned long flags; + int i; pcm = RPACKET_FIELD(pack, GLOBAL, PCM_READ, pcm); pcm_mask = RPACKET_FIELD(pack, GLOBAL, PCM_READ, lines); @@ -908,14 +937,17 @@ void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) if (!SPAN_REGISTERED(xpd)) goto out; for (i = 0; i < PHONEDEV(xpd).channels; i++) { - volatile u_char *r = XPD_CHAN(xpd, i)->readchunk; - bool got_data = IS_SET(pcm_mask, i); + volatile u_char *r = XPD_CHAN(xpd, i)->readchunk; + bool got_data = IS_SET(pcm_mask, i); if (got_data && !IS_SET(pcm_mute, i)) { /* We have and want real data */ - // memset((u_char *)r, 0x5A, DAHDI_CHUNKSIZE); // DEBUG + // memset((u_char *)r, 0x5A, DAHDI_CHUNKSIZE); // DEBUG memcpy((u_char *)r, pcm, DAHDI_CHUNKSIZE); - } else if (IS_SET(PHONEDEV(xpd).wanted_pcm_mask | PHONEDEV(xpd).silence_pcm, i)) { + } else + if (IS_SET + (PHONEDEV(xpd).wanted_pcm_mask | PHONEDEV(xpd). + silence_pcm, i)) { /* Inject SILENCE */ memset((u_char *)r, 0x7F, DAHDI_CHUNKSIZE); if (IS_SET(PHONEDEV(xpd).silence_pcm, i)) { @@ -923,8 +955,10 @@ void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) * This will clear the EC buffers until next tick * So we don't have noise residues from the past. */ - memset(PHONEDEV(xpd).ec_chunk2[i], 0x7F, DAHDI_CHUNKSIZE); - memset(PHONEDEV(xpd).ec_chunk1[i], 0x7F, DAHDI_CHUNKSIZE); + memset(PHONEDEV(xpd).ec_chunk2[i], 0x7F, + DAHDI_CHUNKSIZE); + memset(PHONEDEV(xpd).ec_chunk1[i], 0x7F, + DAHDI_CHUNKSIZE); } } if (got_data) @@ -939,6 +973,7 @@ int generic_echocancel_timeslot(xpd_t *xpd, int pos) { return xpd->addr.unit * 32 + pos; } + EXPORT_SYMBOL(generic_echocancel_timeslot); int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask) @@ -949,7 +984,7 @@ int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask) XPD_DBG(GENERAL, xpd, "0x%8X\n", ec_mask); if (!ECHOOPS(xpd->xbus)) { XPD_DBG(GENERAL, xpd, - "No echo canceller in XBUS: Doing nothing.\n"); + "No echo canceller in XBUS: Doing nothing.\n"); return -EINVAL; } for (i = 0; i < PHONEDEV(xpd).channels; i++) { @@ -959,14 +994,15 @@ int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask) CALL_EC_METHOD(ec_update, xpd->xbus, xpd->xbus); return 0; } + EXPORT_SYMBOL(generic_echocancel_setmask); static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe) { - __u8 *xframe_end; - xpacket_t *pack; - __u8 *p; - int ret = -EPROTO; /* Assume error */ + __u8 *xframe_end; + xpacket_t *pack; + __u8 *p; + int ret = -EPROTO; /* Assume error */ if (debug & DBG_PCM) dump_xframe("RX_XFRAME_PCM", xbus, xframe, debug); @@ -975,42 +1011,48 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe) p = xframe->packets; xframe_end = p + XFRAME_LEN(xframe); do { - int len; - xpd_t *xpd; + int len; + xpd_t *xpd; pack = (xpacket_t *)p; len = XPACKET_LEN(pack); /* Sanity checks */ if (unlikely(XPACKET_OP(pack) != XPROTO_NAME(GLOBAL, PCM_READ))) { - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 1003) == 0) { XBUS_NOTICE(xbus, - "%s: Non-PCM packet within a PCM xframe. (%d)\n", - __func__, rate_limit); - dump_xframe("In PCM xframe", xbus, xframe, debug); + "%s: Non-PCM packet within a PCM xframe. (%d)\n", + __func__, rate_limit); + dump_xframe("In PCM xframe", xbus, xframe, + debug); } goto out; } p += len; if (p > xframe_end || len < RPACKET_HEADERSIZE) { - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 1003) == 0) { XBUS_NOTICE(xbus, - "%s: Invalid packet length %d. (%d)\n", - __func__, len, rate_limit); + "%s: Invalid packet length %d. (%d)\n", + __func__, len, rate_limit); dump_xframe("BAD LENGTH", xbus, xframe, debug); } goto out; } - xpd = xpd_byaddr(xbus, XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack)); + xpd = + xpd_byaddr(xbus, XPACKET_ADDR_UNIT(pack), + XPACKET_ADDR_SUBUNIT(pack)); if (unlikely(!xpd)) { - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 1003) == 0) { - notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), "RECEIVE PCM"); - dump_xframe("Unknown XPD addr", xbus, xframe, debug); + notify_bad_xpd(__func__, xbus, + XPACKET_ADDR(pack), + "RECEIVE PCM"); + dump_xframe("Unknown XPD addr", xbus, xframe, + debug); } goto out; } @@ -1021,7 +1063,7 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe) CALL_PHONE_METHOD(card_pcm_tospan, xpd, pack); } } while (p < xframe_end); - ret = 0; /* all good */ + ret = 0; /* all good */ XBUS_COUNTER(xbus, RX_XFRAME_PCM)++; out: FREE_RECV_XFRAME(xbus, xframe); @@ -1035,11 +1077,11 @@ int generic_timing_priority(xpd_t *xpd) static void xbus_tick(xbus_t *xbus) { - int i; - xpd_t *xpd; - xframe_t *xframe = NULL; - xpacket_t *pack = NULL; - bool sent_sync_bit = 0; + int i; + xpd_t *xpd; + xframe_t *xframe = NULL; + xpacket_t *pack = NULL; + bool sent_sync_bit = 0; /* * Update dahdi @@ -1048,15 +1090,15 @@ static void xbus_tick(xbus_t *xbus) xpd = xpd_of(xbus, i); if (xpd && SPAN_REGISTERED(xpd)) { #ifdef OPTIMIZE_CHANMUTE - int j; - xpp_line_t xmit_mask = PHONEDEV(xpd).wanted_pcm_mask; + int j; + xpp_line_t xmit_mask = PHONEDEV(xpd).wanted_pcm_mask; xmit_mask |= PHONEDEV(xpd).silence_pcm; xmit_mask |= PHONEDEV(xpd).digital_signalling; for_each_line(xpd, j) { XPD_CHAN(xpd, j)->chanmute = (optimize_chanmute) - ? !IS_SET(xmit_mask, j) - : 0; + ? !IS_SET(xmit_mask, j) + : 0; } #endif /* @@ -1075,31 +1117,36 @@ static void xbus_tick(xbus_t *xbus) if (!IS_PHONEDEV(xpd)) continue; if (SPAN_REGISTERED(xpd)) { - size_t pcm_len = PHONEDEV(xpd).pcm_len; + size_t pcm_len = PHONEDEV(xpd).pcm_len; if (pcm_len && xpd->card_present) { do { - // pack = NULL; /* FORCE single packet frames */ + // pack = NULL; /* FORCE single packet frames */ if (xframe && !pack) { /* FULL frame */ pcm_frame_out(xbus, xframe); xframe = NULL; - XBUS_COUNTER(xbus, TX_PCM_FRAG)++; + XBUS_COUNTER(xbus, + TX_PCM_FRAG)++; } - if (!xframe) { /* Alloc frame */ - xframe = ALLOC_SEND_XFRAME(xbus); + if (!xframe) { /* Alloc frame */ + xframe = + ALLOC_SEND_XFRAME(xbus); if (!xframe) { static int rate_limit; - if ((rate_limit++ % 3001) == 0) + if ((rate_limit++ % + 3001) == 0) XBUS_ERR(xbus, - "%s: failed to allocate new xframe\n", - __func__); + "%s: failed to allocate new xframe\n", + __func__); return; } } - pack = xframe_next_packet(xframe, pcm_len); + pack = + xframe_next_packet(xframe, pcm_len); } while (!pack); - XPACKET_INIT(pack, GLOBAL, PCM_WRITE, xpd->xbus_idx, 1, 0); + XPACKET_INIT(pack, GLOBAL, PCM_WRITE, + xpd->xbus_idx, 1, 0); XPACKET_LEN(pack) = pcm_len; if (!sent_sync_bit) { XPACKET_ADDR_SYNC(pack) = 1; @@ -1110,7 +1157,7 @@ static void xbus_tick(xbus_t *xbus) } } } - if (xframe) /* clean any leftovers */ + if (xframe) /* clean any leftovers */ pcm_frame_out(xbus, xframe); /* * Receive PCM @@ -1118,20 +1165,23 @@ 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; + struct timeval now; + unsigned long usec; do_gettimeofday(&now); usec = usec_diff(&now, &xbus->last_rx_sync); xbus->last_rx_sync = now; /* ignore startup statistics */ - if (likely(atomic_read(&xbus->pcm_rx_counter) > BIG_TICK_INTERVAL)) { + if (likely + (atomic_read(&xbus->pcm_rx_counter) > + BIG_TICK_INTERVAL)) { if (abs(usec - 1000) > TICK_TOLERANCE) { - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 5003) == 0) - XBUS_DBG(SYNC, xbus, "Bad PCM RX timing(%d): usec=%ld.\n", - rate_limit, usec); + XBUS_DBG(SYNC, xbus, + "Bad PCM RX timing(%d): usec=%ld.\n", + rate_limit, usec); } if (usec > xbus->max_rx_sync) xbus->max_rx_sync = usec; @@ -1162,8 +1212,8 @@ static void xbus_tick(xbus_t *xbus) static void do_tick(xbus_t *xbus, const struct timeval *tv_received) { - int counter = atomic_read(&xpp_tick_counter); - unsigned long flags; + int counter = atomic_read(&xpp_tick_counter); + unsigned long flags; xbus_command_queue_tick(xbus); if (global_ticker == xbus) @@ -1179,12 +1229,12 @@ static void do_tick(xbus_t *xbus, const struct timeval *tv_received) void xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe) { if (!xframe_enqueue(&xbus->pcm_tospan, xframe)) { - static int rate_limit; + static int rate_limit; if ((rate_limit++ % 1003) == 0) XBUS_DBG(SYNC, xbus, - "Failed to enqueue received pcm frame. (%d)\n", - rate_limit); + "Failed to enqueue received pcm frame. (%d)\n", + rate_limit); FREE_RECV_XFRAME(xbus, xframe); } /* @@ -1201,9 +1251,9 @@ void xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe) int exec_sync_command(const char *buf, size_t count) { - int ret = count; - int xbusno; - xbus_t *xbus; + int ret = count; + int xbusno; + xbus_t *xbus; if (strncmp("DAHDI", buf, 6) == 0) { /* Ignore the newline */ DBG(SYNC, "DAHDI"); @@ -1235,11 +1285,12 @@ int exec_sync_command(const char *buf, size_t count) int fill_sync_string(char *buf, size_t count) { - int len = 0; + int len = 0; if (!syncer) { - len += snprintf(buf, count, "%s\n", - (force_dahdi_sync) ? "DAHDI" : "NO-SYNC"); + len += + snprintf(buf, count, "%s\n", + (force_dahdi_sync) ? "DAHDI" : "NO-SYNC"); } else len += snprintf(buf, count, "SYNC=%02d\n", syncer->num); return len; @@ -1247,11 +1298,11 @@ int fill_sync_string(char *buf, size_t count) int xbus_pcm_init(void *toplevel) { - int ret = 0; + int ret = 0; #ifdef OPTIMIZE_CHANMUTE INFO("FEATURE: with CHANMUTE optimization (%sactivated)\n", - (optimize_chanmute)?"":"de"); + (optimize_chanmute) ? "" : "de"); #endif #ifdef DAHDI_SYNC_TICK INFO("FEATURE: with sync_tick() from DAHDI\n"); @@ -1267,7 +1318,6 @@ void xbus_pcm_shutdown(void) { } - EXPORT_SYMBOL(xbus_request_sync); EXPORT_SYMBOL(got_new_syncer); EXPORT_SYMBOL(elect_syncer); @@ -1283,4 +1333,3 @@ EXPORT_SYMBOL(generic_timing_priority); EXPORT_SYMBOL(pcmtx); EXPORT_SYMBOL(pcmtx_chan); #endif - -- cgit v1.2.3