From f56a75587b57b0b23d62bbd5c085c1b992152189 Mon Sep 17 00:00:00 2001 From: Tzafrir Cohen Date: Wed, 11 Jan 2012 15:20:05 +0000 Subject: xpp: style - insert space afer if/while/for/switch * Applied via: perl -pi -e 's/\b(if|while|for|switch)\b\(/$1 (/g' "$@" Signed-off-by: Oron Peled Acked-By: Tzafrir Cohen git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@10425 a0bf4364-ded3-4de4-8d8a-66a801d63aff --- drivers/dahdi/xpp/card_bri.c | 196 ++++++++++----------- drivers/dahdi/xpp/card_fxo.c | 210 +++++++++++----------- drivers/dahdi/xpp/card_fxs.c | 210 +++++++++++----------- drivers/dahdi/xpp/card_global.c | 126 ++++++------- drivers/dahdi/xpp/card_pri.c | 362 +++++++++++++++++++------------------- drivers/dahdi/xpp/dahdi_debug.c | 12 +- drivers/dahdi/xpp/dahdi_debug.h | 10 +- drivers/dahdi/xpp/mmapdrv.c | 6 +- drivers/dahdi/xpp/parport_debug.c | 10 +- drivers/dahdi/xpp/xbus-core.c | 254 +++++++++++++------------- drivers/dahdi/xpp/xbus-pcm.c | 242 ++++++++++++------------- drivers/dahdi/xpp/xbus-sysfs.c | 86 ++++----- drivers/dahdi/xpp/xdefs.h | 6 +- drivers/dahdi/xpp/xframe_queue.c | 40 ++--- drivers/dahdi/xpp/xpd.h | 4 +- drivers/dahdi/xpp/xpp_dahdi.c | 112 ++++++------ drivers/dahdi/xpp/xpp_usb.c | 126 ++++++------- drivers/dahdi/xpp/xproto.c | 98 +++++------ drivers/dahdi/xpp/xproto.h | 12 +- 19 files changed, 1061 insertions(+), 1061 deletions(-) (limited to 'drivers/dahdi/xpp') diff --git a/drivers/dahdi/xpp/card_bri.c b/drivers/dahdi/xpp/card_bri.c index 3d84694..e859d74 100644 --- a/drivers/dahdi/xpp/card_bri.c +++ b/drivers/dahdi/xpp/card_bri.c @@ -84,7 +84,7 @@ static const char *xhfc_state_name(bool is_nt, enum xhfc_states state) _E(NT_DEACTIVTING), }; #undef _E - if(is_nt) { + if (is_nt) { if (state > ST_NT_DEACTIVTING) p = "NT ???"; else @@ -242,7 +242,7 @@ static void dump_hex_buf(xpd_t *xpd, char *msg, byte *buf, size_t len) int n = 0; debug_buf[0] = '\0'; - for(i = 0; i < len && n < DEBUG_BUF_SIZE; i++) + for (i = 0; i < len && n < DEBUG_BUF_SIZE; i++) n += snprintf(&debug_buf[n], DEBUG_BUF_SIZE - n, "%02X ", buf[i]); XPD_NOTICE(xpd, "%s[0..%zd]: %s%s\n", msg, len-1, debug_buf, (n >= DEBUG_BUF_SIZE)?"...":""); @@ -258,19 +258,19 @@ static void dump_dchan_packet(xpd_t *xpd, bool transmit, byte *buf, int len) priv = xpd->priv; BUG_ON(!priv); - if(transmit) { + if (transmit) { direction = "TX"; frame_begin = priv->txframe_begin; } else { direction = "RX"; frame_begin = 1; } - if(frame_begin) { /* Packet start */ - if(!IS_SET(buf[0], 7)) + if (frame_begin) { /* Packet start */ + if (!IS_SET(buf[0], 7)) ftype = 'I'; /* Information */ - else if(IS_SET(buf[0], 7) && !IS_SET(buf[0], 6)) + else if (IS_SET(buf[0], 7) && !IS_SET(buf[0], 6)) ftype = 'S'; /* Supervisory */ - else if(IS_SET(buf[0], 7) && IS_SET(buf[0], 6)) + else if (IS_SET(buf[0], 7) && IS_SET(buf[0], 6)) ftype = 'U'; /* Unnumbered */ else XPD_NOTICE(xpd, "Unknown frame type 0x%X\n", buf[0]); @@ -284,7 +284,7 @@ static void dump_dchan_packet(xpd_t *xpd, bool transmit, byte *buf, int len) static void set_bri_timer(xpd_t *xpd, const char *name, int *bri_timer, int value) { - if(value == HFC_TIMER_OFF) + if (value == HFC_TIMER_OFF) XPD_DBG(SIGNAL, xpd, "Timer %s DISABLE\n", name); else XPD_DBG(SIGNAL, xpd, "Timer %s: set to %d\n", name, value); @@ -298,9 +298,9 @@ static void dchan_state(xpd_t *xpd, bool up) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(priv->dchan_alive == up) + if (priv->dchan_alive == up) return; - if(up) { + if (up) { XPD_DBG(SIGNAL, xpd, "STATE CHANGE: D-Channel RUNNING\n"); priv->dchan_alive = 1; } else { @@ -318,11 +318,11 @@ static void layer1_state(xpd_t *xpd, bool up) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(priv->layer1_up == up) + if (priv->layer1_up == up) return; priv->layer1_up = up; XPD_DBG(SIGNAL, xpd, "STATE CHANGE: Layer1 %s\n", (up)?"UP":"DOWN"); - if(!up) + if (!up) dchan_state(xpd, 0); } @@ -336,8 +336,8 @@ static void te_activation(xpd_t *xpd, bool on) BUG_ON(!priv); curr_state = priv->state_register.bits.v_su_sta; XPD_DBG(SIGNAL, xpd, "%s\n", (on)?"ON":"OFF"); - if(on) { - if(curr_state == ST_TE_DEACTIVATED) { + if (on) { + if (curr_state == ST_TE_DEACTIVATED) { XPD_DBG(SIGNAL, xpd, "HFC_L1_ACTIVATE_TE\n"); set_bit(HFC_L1_ACTIVATING, &priv->l1_flags); write_state_register(xpd, STA_ACTIVATE); @@ -379,8 +379,8 @@ static void nt_activation(xpd_t *xpd, bool on) BUG_ON(!priv); curr_state = priv->state_register.bits.v_su_sta; XPD_DBG(SIGNAL, xpd, "%s\n", (on)?"ON":"OFF"); - if(on) { - switch(curr_state) { + if (on) { + switch (curr_state) { case ST_RESET: /* F/G 0 */ case ST_NT_DEACTIVATED: /* G1 */ case ST_NT_DEACTIVTING: /* G4 */ @@ -397,7 +397,7 @@ static void nt_activation(xpd_t *xpd, bool on) break; } } else { - switch(curr_state) { + switch (curr_state) { case ST_RESET: /* F/G 0 */ case ST_NT_DEACTIVATED: /* G1 */ case ST_NT_DEACTIVTING: /* G4 */ @@ -428,16 +428,16 @@ static int bri_check_stat(xpd_t *xpd, struct dahdi_chan *dchan, byte *buf, int l priv = xpd->priv; BUG_ON(!priv); - if(len <= 0) { + if (len <= 0) { XPD_NOTICE(xpd, "D-Chan RX DROP: short frame (len=%d)\n", len); dahdi_hdlc_abort(dchan, DAHDI_EVENT_ABORT); return -EPROTO; } status = buf[len-1]; - if(status) { + if (status) { int event = DAHDI_EVENT_ABORT; - if(status == 0xFF) { + if (status == 0xFF) { XPD_NOTICE(xpd, "D-Chan RX DROP: ABORT: %d\n", status); } else { XPD_NOTICE(xpd, "D-Chan RX DROP: BADFCS: %d\n", status); @@ -462,31 +462,31 @@ static int rx_dchan(xpd_t *xpd, reg_cmd_t *regcmd) src = REG_XDATA(regcmd); len = regcmd->bytes; eoframe = regcmd->eoframe; - if(len <= 0) + if (len <= 0) return 0; - if(!SPAN_REGISTERED(xpd)) /* Nowhere to copy data */ + if (!SPAN_REGISTERED(xpd)) /* Nowhere to copy data */ return 0; BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); dchan = XPD_CHAN(xpd, 2); - if(!IS_OFFHOOK(xpd, 2)) { /* D-chan is used? */ + if (!IS_OFFHOOK(xpd, 2)) { /* D-chan is used? */ static int rate_limit; - if((rate_limit++ % 1000) == 0) + if ((rate_limit++ % 1000) == 0) XPD_DBG(SIGNAL, xpd, "D-Chan unused\n"); goto out; } XPD_DBG(GENERAL, xpd, "D-Chan RX: eoframe=%d len=%d\n", eoframe, len); dahdi_hdlc_putbuf(dchan, src, (eoframe) ? len - 1 : len); - if(!eoframe) + if (!eoframe) goto out; - if((ret = bri_check_stat(xpd, dchan, src, len)) < 0) + if ((ret = bri_check_stat(xpd, dchan, src, len)) < 0) goto out; /* * Tell Dahdi that we received len-1 bytes. They include the data and a 2-byte checksum. * The last byte (that we don't pass on) is 0 if the checksum is correct. If it were wrong, - * we would drop the packet in the "if(src[len-1])" above. + * we would drop the packet in the "if (src[len-1])" above. */ dahdi_hdlc_finish(dchan); priv->dchan_rx_counter++; @@ -645,7 +645,7 @@ static void bri_proc_remove(xbus_t *xbus, xpd_t *xpd) priv = xpd->priv; XPD_DBG(PROC, xpd, "\n"); #ifdef CONFIG_PROC_FS - if(priv->bri_info) { + if (priv->bri_info) { XPD_DBG(PROC, xpd, "Removing '%s'\n", PROC_BRI_INFO_FNAME); remove_proc_entry(PROC_BRI_INFO_FNAME, xpd->proc_xpd_dir); } @@ -662,7 +662,7 @@ static int bri_proc_create(xbus_t *xbus, xpd_t *xpd) #ifdef CONFIG_PROC_FS XPD_DBG(PROC, xpd, "Creating '%s'\n", PROC_BRI_INFO_FNAME); priv->bri_info = create_proc_read_entry(PROC_BRI_INFO_FNAME, 0444, xpd->proc_xpd_dir, proc_bri_info_read, xpd); - if(!priv->bri_info) { + if (!priv->bri_info) { XPD_ERR(xpd, "Failed to create proc file '%s'\n", PROC_BRI_INFO_FNAME); bri_proc_remove(xbus, xpd); return -EINVAL; @@ -678,17 +678,17 @@ static xpd_t *BRI_card_new(xbus_t *xbus, int unit, int subunit, const xproto_tab xpd_t *xpd = NULL; int channels = min(3, CHANNELS_PERXPD); - if(subunit_ports != 1) { + if (subunit_ports != 1) { XBUS_ERR(xbus, "Bad subunit_ports=%d\n", subunit_ports); return NULL; } XBUS_DBG(GENERAL, xbus, "\n"); xpd = xpd_alloc(xbus, unit, subunit, subtype, subunits, sizeof(struct BRI_priv_data), proto_table, channels); - if(!xpd) + if (!xpd) return NULL; PHONEDEV(xpd).direction = (to_phone) ? TO_PHONE : TO_PSTN; xpd->type_name = (to_phone) ? "BRI_NT" : "BRI_TE"; - if(bri_proc_create(xbus, xpd) < 0) + if (bri_proc_create(xbus, xpd) < 0) goto err; return xpd; err: @@ -753,7 +753,7 @@ static int BRI_card_dahdi_preregistration(xpd_t *xpd, bool on) priv = xpd->priv; BUG_ON(!xbus); XPD_DBG(GENERAL, xpd, "%s\n", (on)?"on":"off"); - if(!on) { + if (!on) { /* Nothing to do yet */ return 0; } @@ -770,7 +770,7 @@ static int BRI_card_dahdi_preregistration(xpd_t *xpd, bool on) xpd->addr.unit, xpd->addr.subunit, i); cur_chan->chanpos = i + 1; cur_chan->pvt = xpd; - if(i == 2) { /* D-CHAN */ + if (i == 2) { /* D-CHAN */ cur_chan->sigcap = BRI_DCHAN_SIGCAP; clear_bit(DAHDI_FLAGBIT_HDLC, &cur_chan->flags); priv->txframe_begin = 1; @@ -816,7 +816,7 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) int mod; BUG_ON(!xpd); - if(IS_NT(xpd)) { + if (IS_NT(xpd)) { which_led = RED_LED; other_led = GREEN_LED; } else { @@ -826,10 +826,10 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) priv = xpd->priv; BUG_ON(!priv); timer_count = xpd->timer_count; - if(xpd->blink_mode) { - if((timer_count % DEFAULT_LED_PERIOD) == 0) { + if (xpd->blink_mode) { + if ((timer_count % DEFAULT_LED_PERIOD) == 0) { // led state is toggled - if(priv->ledstate[which_led] == BRI_LED_OFF) { + if (priv->ledstate[which_led] == BRI_LED_OFF) { DO_LED(xpd, which_led, BRI_LED_ON); DO_LED(xpd, other_led, BRI_LED_ON); } else { @@ -839,11 +839,11 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) } return; } - if(priv->ledstate[other_led] != BRI_LED_OFF) + if (priv->ledstate[other_led] != BRI_LED_OFF) DO_LED(xpd, other_led, BRI_LED_OFF); - if(priv->dchan_alive) { + if (priv->dchan_alive) { mod = timer_count % 1000; - switch(mod) { + switch (mod) { case 0: DO_LED(xpd, which_led, BRI_LED_ON); break; @@ -851,9 +851,9 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) DO_LED(xpd, which_led, BRI_LED_OFF); break; } - } else if(priv->layer1_up) { + } else if (priv->layer1_up) { mod = timer_count % 1000; - switch(mod) { + switch (mod) { case 0: case 100: DO_LED(xpd, which_led, BRI_LED_ON); @@ -864,7 +864,7 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) break; } } else { - if(priv->ledstate[which_led] != BRI_LED_ON) + if (priv->ledstate[which_led] != BRI_LED_ON) DO_LED(xpd, which_led, BRI_LED_ON); } } @@ -876,12 +876,12 @@ static void handle_bri_timers(xpd_t *xpd) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(IS_NT(xpd)) { + if (IS_NT(xpd)) { if (priv->t1 > HFC_TIMER_OFF) { if (--priv->t1 == 0) { set_bri_timer(xpd, "T1", &priv->t1, HFC_TIMER_OFF); - if(!nt_keepalive) { - if(priv->state_register.bits.v_su_sta == ST_NT_ACTIVATING) { /* G2 */ + if (!nt_keepalive) { + if (priv->state_register.bits.v_su_sta == ST_NT_ACTIVATING) { /* G2 */ XPD_DBG(SIGNAL, xpd, "T1 Expired. Deactivate NT\n"); clear_bit(HFC_L1_ACTIVATING, &priv->l1_flags); nt_activation(xpd, 0); /* Deactivate NT */ @@ -915,9 +915,9 @@ static int BRI_card_tick(xbus_t *xbus, xpd_t *xpd) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(!priv->initialized || !xbus->self_ticking) + if (!priv->initialized || !xbus->self_ticking) return 0; - if(poll_interval != 0 && (priv->tick_counter % poll_interval) == 0) { + if (poll_interval != 0 && (priv->tick_counter % poll_interval) == 0) { // XPD_DBG(GENERAL, xpd, "%d\n", priv->tick_counter); priv->poll_counter++; xpp_register_request(xbus, xpd, @@ -932,7 +932,7 @@ static int BRI_card_tick(xbus_t *xbus, xpd_t *xpd) 0 /* should_reply */ ); - if(IS_NT(xpd) && nt_keepalive && + if (IS_NT(xpd) && nt_keepalive && !test_bit(HFC_L1_ACTIVATED, &priv->l1_flags) && !test_bit(HFC_L1_ACTIVATING, &priv->l1_flags)) { XPD_DBG(SIGNAL, xpd, "Kick NT D-Channel\n"); @@ -943,18 +943,18 @@ static int BRI_card_tick(xbus_t *xbus, xpd_t *xpd) priv->dchan_notx_ticks++; priv->dchan_norx_ticks++; priv->dchan_alive_ticks++; - if(priv->dchan_alive && (priv->dchan_notx_ticks > DCHAN_LOST || priv->dchan_norx_ticks > DCHAN_LOST)) { + if (priv->dchan_alive && (priv->dchan_notx_ticks > DCHAN_LOST || priv->dchan_norx_ticks > DCHAN_LOST)) { /* * No tx_dchan() or rx_dchan() for many ticks * This D-Channel is probabelly dead. */ dchan_state(xpd, 0); - } else if(priv->dchan_rx_counter > 1 && priv->dchan_tx_counter > 1) { - if(!priv->dchan_alive) + } else if (priv->dchan_rx_counter > 1 && priv->dchan_tx_counter > 1) { + if (!priv->dchan_alive) dchan_state(xpd, 1); } /* Detect Layer1 disconnect */ - if(priv->reg30_good && priv->reg30_ticks > poll_interval * REG30_LOST) { + if (priv->reg30_good && priv->reg30_ticks > poll_interval * REG30_LOST) { /* No reply for 1/2 a second */ XPD_ERR(xpd, "Lost state tracking for %d ticks\n", priv->reg30_ticks); priv->reg30_good = 0; @@ -971,7 +971,7 @@ static int BRI_card_tick(xbus_t *xbus, xpd_t *xpd) static int BRI_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long arg) { BUG_ON(!xpd); - if(!XBUS_IS(xpd->xbus, READY)) + if (!XBUS_IS(xpd->xbus, READY)) return -ENODEV; switch (cmd) { case DAHDI_TONEDETECT: @@ -991,7 +991,7 @@ static int BRI_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a static int BRI_card_open(xpd_t *xpd, lineno_t pos) { BUG_ON(!xpd); - if(pos == 2) { + if (pos == 2) { LINE_DBG(SIGNAL, xpd, pos, "OFFHOOK the whole span\n"); BIT_SET(PHONEDEV(xpd).offhook_state, 0); BIT_SET(PHONEDEV(xpd).offhook_state, 1); @@ -1004,7 +1004,7 @@ static int BRI_card_open(xpd_t *xpd, lineno_t pos) static int BRI_card_close(xpd_t *xpd, lineno_t pos) { /* Clear D-Channel pending data */ - if(pos == 2) { + if (pos == 2) { LINE_DBG(SIGNAL, xpd, pos, "ONHOOK the whole span\n"); BIT_CLR(PHONEDEV(xpd).offhook_state, 0); BIT_CLR(PHONEDEV(xpd).offhook_state, 1); @@ -1088,14 +1088,14 @@ static int bri_startup(struct file *file, struct dahdi_span *span) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(!XBUS_IS(xpd->xbus, READY)) { + if (!XBUS_IS(xpd->xbus, READY)) { XPD_DBG(GENERAL, xpd, "Startup called by dahdi. No Hardware. Ignored\n"); return -ENODEV; } XPD_DBG(GENERAL, xpd, "STARTUP\n"); // Turn on all channels CALL_PHONE_METHOD(card_state, xpd, 1); - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { dchan = XPD_CHAN(xpd, 2); span->flags |= DAHDI_FLAG_RUNNING; /* @@ -1121,7 +1121,7 @@ static int bri_shutdown(struct dahdi_span *span) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(!XBUS_IS(xpd->xbus, READY)) { + if (!XBUS_IS(xpd->xbus, READY)) { XPD_DBG(GENERAL, xpd, "Shutdown called by dahdi. No Hardware. Ignored\n"); return -ENODEV; } @@ -1143,7 +1143,7 @@ static void BRI_card_pcm_recompute(xpd_t *xpd, BUG_ON(!xpd); main_xpd = xpd_byaddr(xpd->xbus, xpd->addr.unit, 0); - if(!main_xpd) { + if (!main_xpd) { XPD_DBG(DEVICES, xpd, "Unit 0 is already gone. Ignore request\n"); return; } @@ -1154,19 +1154,19 @@ static void BRI_card_pcm_recompute(xpd_t *xpd, spin_lock_irqsave(&PHONEDEV(main_xpd).lock_recompute_pcm, flags); line_count = 0; pcm_mask = 0; - for(i = 0; i < MAX_SUBUNIT; i++) { + for (i = 0; i < MAX_SUBUNIT; i++) { xpd_t *sub_xpd = xpd_byaddr(xpd->xbus, main_xpd->addr.unit, i); - if(sub_xpd) { + if (sub_xpd) { xpp_line_t lines = PHONEDEV(sub_xpd).offhook_state & ~(PHONEDEV(sub_xpd).digital_signalling); - if(lines) { + if (lines) { pcm_mask |= PCM_SHIFT(lines, i); line_count += 2; } /* subunits have fake pcm_len and wanted_pcm_mask */ - if(i > 0) { + if (i > 0) { update_wanted_pcm_mask(sub_xpd, lines, 0); } } @@ -1175,7 +1175,7 @@ static void BRI_card_pcm_recompute(xpd_t *xpd, * FIXME: Workaround a bug in sync code of the Astribank. * Send dummy PCM for sync. */ - if(main_xpd->addr.unit == 0 && line_count == 0) { + if (main_xpd->addr.unit == 0 && line_count == 0) { pcm_mask = BIT(0); line_count = 1; } @@ -1202,23 +1202,23 @@ static void BRI_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) BUG_ON(!xpd); BUG_ON(!pack); pcm = RPACKET_FIELD(pack, GLOBAL, PCM_WRITE, pcm); - for(subunit = 0; subunit < MAX_SUBUNIT; subunit++) { + for (subunit = 0; subunit < MAX_SUBUNIT; subunit++) { xpd_t *tmp_xpd; tmp_xpd = xpd_byaddr(xpd->xbus, xpd->addr.unit, subunit); - if(!tmp_xpd || !tmp_xpd->card_present) + if (!tmp_xpd || !tmp_xpd->card_present) continue; spin_lock_irqsave(&tmp_xpd->lock, flags); wanted_lines = PHONEDEV(tmp_xpd).wanted_pcm_mask; for_each_line(tmp_xpd, i) { struct dahdi_chan *chan = XPD_CHAN(tmp_xpd, i); - if(IS_SET(wanted_lines, i)) { - if(SPAN_REGISTERED(tmp_xpd)) { + if (IS_SET(wanted_lines, i)) { + if (SPAN_REGISTERED(tmp_xpd)) { #ifdef DEBUG_PCMTX int channo = chan->channo; - if(pcmtx >= 0 && pcmtx_chan == channo) + if (pcmtx >= 0 && pcmtx_chan == channo) memset((u_char *)pcm, pcmtx, DAHDI_CHUNKSIZE); else #endif @@ -1246,26 +1246,26 @@ static void BRI_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) /* * Subunit 0 handle all other subunits */ - if(xpd->addr.subunit != 0) + if (xpd->addr.subunit != 0) return; - if(!SPAN_REGISTERED(xpd)) + if (!SPAN_REGISTERED(xpd)) return; pcm = RPACKET_FIELD(pack, GLOBAL, PCM_READ, pcm); pcm_mask = RPACKET_FIELD(pack, GLOBAL, PCM_WRITE, lines); - for(subunit = 0; subunit < MAX_SUBUNIT; subunit++, pcm_mask >>= SUBUNIT_PCM_SHIFT) { + for (subunit = 0; subunit < MAX_SUBUNIT; subunit++, pcm_mask >>= SUBUNIT_PCM_SHIFT) { xpd_t *tmp_xpd; - if(!pcm_mask) + if (!pcm_mask) break; /* optimize */ tmp_xpd = xpd_byaddr(xpd->xbus, xpd->addr.unit, subunit); - if(!tmp_xpd || !tmp_xpd->card_present || !SPAN_REGISTERED(tmp_xpd)) + if (!tmp_xpd || !tmp_xpd->card_present || !SPAN_REGISTERED(tmp_xpd)) continue; spin_lock_irqsave(&tmp_xpd->lock, flags); for (i = 0; i < 2; i++) { xpp_line_t tmp_mask = pcm_mask & (BIT(0) | BIT(1)); volatile u_char *r; - if(IS_SET(tmp_mask, i)) { + if (IS_SET(tmp_mask, i)) { r = XPD_CHAN(tmp_xpd, i)->readchunk; // memset((u_char *)r, 0x5A, DAHDI_CHUNKSIZE); // DEBUG memcpy((u_char *)r, pcm, DAHDI_CHUNKSIZE); @@ -1371,12 +1371,12 @@ static void su_new_state(xpd_t *xpd, byte reg_x30) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(!priv->initialized) { + if (!priv->initialized) { XPD_ERR(xpd, "%s called on uninitialized AB\n", __func__); return; } new_state.reg = reg_x30; - if(new_state.bits.v_su_t2_exp) { + if (new_state.bits.v_su_t2_exp) { XPD_NOTICE(xpd, "T2 Expired\n"); } priv->reg30_ticks = 0; @@ -1389,7 +1389,7 @@ static void su_new_state(xpd_t *xpd, byte reg_x30) new_state.bits.v_su_info0, IS_NT(xpd)?"G":"F", new_state.bits.v_su_sta); - if(!IS_NT(xpd)) { + if (!IS_NT(xpd)) { switch (new_state.bits.v_su_sta) { case ST_TE_DEACTIVATED: /* F3 */ XPD_DBG(SIGNAL, xpd, "State ST_TE_DEACTIVATED (F3)\n"); @@ -1436,7 +1436,7 @@ static void su_new_state(xpd_t *xpd, byte reg_x30) case ST_NT_ACTIVATING: /* G2 */ XPD_DBG(SIGNAL, xpd, "State ST_NT_ACTIVATING (G2)\n"); layer1_state(xpd, 0); - if(!test_bit(HFC_L1_ACTIVATED, &priv->l1_flags)) + if (!test_bit(HFC_L1_ACTIVATED, &priv->l1_flags)) nt_activation(xpd, 1); break; case ST_NT_ACTIVATED: /* G3 */ @@ -1473,17 +1473,17 @@ static int BRI_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) addr.unit = orig_xpd->addr.unit; addr.subunit = info->portnum; xpd = xpd_byaddr(xbus, addr.unit, addr.subunit); - if(!xpd) { + if (!xpd) { static int rate_limit; - if((rate_limit++ % 1003) < 5) + if ((rate_limit++ % 1003) < 5) notify_bad_xpd(__func__, xbus, addr , orig_xpd->xpdname); return -EPROTO; } spin_lock_irqsave(&xpd->lock, flags); priv = xpd->priv; BUG_ON(!priv); - if(REG_FIELD(info, do_subreg)) { + if (REG_FIELD(info, do_subreg)) { XPD_DBG(REGS, xpd, "RI %02X %02X %02X\n", REG_FIELD(info, regnum), REG_FIELD(info, subreg), REG_FIELD(info, data_low)); } else { @@ -1494,23 +1494,23 @@ static int BRI_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) XPD_DBG(REGS, xpd, "Got SU_RD_STA=%02X\n", REG_FIELD(info, data_low)); } - if(info->is_multibyte) { + if (info->is_multibyte) { XPD_DBG(REGS, xpd, "Got Multibyte: %d bytes, eoframe: %d\n", info->bytes, info->eoframe); ret = rx_dchan(xpd, info); if (ret < 0) { priv->dchan_rx_drops++; - if(atomic_read(&PHONEDEV(xpd).open_counter) > 0) + if (atomic_read(&PHONEDEV(xpd).open_counter) > 0) XPD_NOTICE(xpd, "Multibyte Drop: errno=%d\n", ret); } goto end; } - if(REG_FIELD(info, regnum) == A_SU_RD_STA) { + if (REG_FIELD(info, regnum) == A_SU_RD_STA) { su_new_state(xpd, REG_FIELD(info, data_low)); } /* Update /proc info only if reply relate to the last slic read request */ - if( + if ( REG_FIELD(&xpd->requested_reply, regnum) == REG_FIELD(info, regnum) && REG_FIELD(&xpd->requested_reply, do_subreg) == REG_FIELD(info, do_subreg) && REG_FIELD(&xpd->requested_reply, subreg) == REG_FIELD(info, subreg)) { @@ -1529,14 +1529,14 @@ static int BRI_card_state(xpd_t *xpd, bool on) BUG_ON(!xpd); priv = xpd->priv; XPD_DBG(GENERAL, xpd, "%s\n", (on)?"ON":"OFF"); - if(on) { - if(!test_bit(HFC_L1_ACTIVATED, &priv->l1_flags)) { - if( ! IS_NT(xpd)) + if (on) { + if (!test_bit(HFC_L1_ACTIVATED, &priv->l1_flags)) { + if ( ! IS_NT(xpd)) te_activation(xpd, 1); else nt_activation(xpd, 1); } - } else if(IS_NT(xpd)) + } else if (IS_NT(xpd)) nt_activation(xpd, 0); return 0; } @@ -1602,13 +1602,13 @@ static int proc_bri_info_read(char *page, char **start, off_t off, int count, in struct BRI_priv_data *priv; DBG(PROC, "\n"); - if(!xpd) + if (!xpd) return -ENODEV; spin_lock_irqsave(&xpd->lock, flags); priv = xpd->priv; BUG_ON(!priv); len += sprintf(page + len, "%05d Layer 1: ", priv->poll_counter); - if(priv->reg30_good) { + if (priv->reg30_good) { len += sprintf(page + len, "%-5s ", (priv->layer1_up) ? "UP" : "DOWN"); len += sprintf(page + len, "%c%d %-15s -- fr_sync=%d t2_exp=%d info0=%d g2_g3=%d\n", IS_NT(xpd)?'G':'F', @@ -1620,7 +1620,7 @@ static int proc_bri_info_read(char *page, char **start, off_t off, int count, in priv->state_register.bits.v_g2_g3); } else len += sprintf(page + len, "Unknown\n"); - if(IS_NT(xpd)) { + if (IS_NT(xpd)) { len += sprintf(page + len, "T1 Timer: %d\n", priv->t1); } else { len += sprintf(page + len, "T3 Timer: %d\n", priv->t3); @@ -1630,7 +1630,7 @@ static int proc_bri_info_read(char *page, char **start, off_t off, int count, in len += sprintf(page + len, "reg30_good=%d\n", priv->reg30_good); len += sprintf(page + len, "D-Channel: TX=[%5d] RX=[%5d] BAD=[%5d] ", priv->dchan_tx_counter, priv->dchan_rx_counter, priv->dchan_rx_drops); - if(priv->dchan_alive) { + if (priv->dchan_alive) { len += sprintf(page + len, "(alive %d K-ticks)\n", priv->dchan_alive_ticks/1000); } else { @@ -1661,7 +1661,7 @@ static int bri_xpd_probe(struct device *dev) xpd = dev_to_xpd(dev); /* Is it our device? */ - if(xpd->type != XPD_TYPE_BRI) { + if (xpd->type != XPD_TYPE_BRI) { XPD_ERR(xpd, "drop suggestion for %s (%d)\n", dev_name(dev), xpd->type); return -EINVAL; @@ -1695,7 +1695,7 @@ static int __init card_bri_startup(void) { int ret; - if((ret = xpd_driver_register(&bri_driver.driver)) < 0) + if ((ret = xpd_driver_register(&bri_driver.driver)) < 0) return ret; INFO("revision %s\n", XPP_VERSION); xproto_register(&PROTO_TABLE(BRI)); diff --git a/drivers/dahdi/xpp/card_fxo.c b/drivers/dahdi/xpp/card_fxo.c index 1b1c5ac..83778d5 100644 --- a/drivers/dahdi/xpp/card_fxo.c +++ b/drivers/dahdi/xpp/card_fxo.c @@ -160,8 +160,8 @@ struct FXO_priv_data { #define LED_COUNTER(priv,pos,color) ((priv)->led_counter[color][pos]) #define IS_BLINKING(priv,pos,color) (LED_COUNTER(priv,pos,color) > 0) #define MARK_BLINK(priv,pos,color,t) ((priv)->led_counter[color][pos] = (t)) -#define MARK_OFF(priv,pos,color) do { BIT_CLR((priv)->ledcontrol[color],(pos)); MARK_BLINK((priv),(pos),(color),0); } while(0) -#define MARK_ON(priv,pos,color) do { BIT_SET((priv)->ledcontrol[color],(pos)); MARK_BLINK((priv),(pos),(color),0); } while(0) +#define MARK_OFF(priv,pos,color) do { BIT_CLR((priv)->ledcontrol[color],(pos)); MARK_BLINK((priv),(pos),(color),0); } while (0) +#define MARK_ON(priv,pos,color) do { BIT_SET((priv)->ledcontrol[color],(pos)); MARK_BLINK((priv),(pos),(color),0); } while (0) #define LED_BLINK_RING (1000/8) /* in ticks */ @@ -169,7 +169,7 @@ struct FXO_priv_data { static const char *power2str(enum power_state pw) { - switch(pw) { + switch (pw) { case POWER_UNKNOWN: return "UNKNOWN"; case POWER_OFF: return "OFF"; case POWER_ON: return "ON"; @@ -213,12 +213,12 @@ static int do_led(xpd_t *xpd, lineno_t chan, byte which, bool on) xbus = xpd->xbus; priv = xpd->priv; which = which % NUM_LEDS; - if(IS_SET(PHONEDEV(xpd).digital_outputs, chan) || IS_SET(PHONEDEV(xpd).digital_inputs, chan)) + if (IS_SET(PHONEDEV(xpd).digital_outputs, chan) || IS_SET(PHONEDEV(xpd).digital_inputs, chan)) goto out; - if(chan == PORT_BROADCAST) { + if (chan == PORT_BROADCAST) { priv->ledstate[which] = (on) ? ~0 : 0; } else { - if(on) { + if (on) { BIT_SET(priv->ledstate[which], chan); } else { BIT_CLR(priv->ledstate[which], chan); @@ -247,27 +247,27 @@ static void handle_fxo_leds(xpd_t *xpd) spin_lock_irqsave(&xpd->lock, flags); priv = xpd->priv; timer_count = xpd->timer_count; - for(color = 0; color < ARRAY_SIZE(colors); color++) { + for (color = 0; color < ARRAY_SIZE(colors); color++) { for_each_line(xpd, i) { - if(IS_SET(PHONEDEV(xpd).digital_outputs, i) || IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (IS_SET(PHONEDEV(xpd).digital_outputs, i) || IS_SET(PHONEDEV(xpd).digital_inputs, i)) continue; - if((xpd->blink_mode & BIT(i)) || IS_BLINKING(priv, i, color)) { // Blinking + if ((xpd->blink_mode & BIT(i)) || IS_BLINKING(priv, i, color)) { // Blinking int mod_value = LED_COUNTER(priv, i, color); - if(!mod_value) + if (!mod_value) mod_value = DEFAULT_LED_PERIOD; /* safety value */ // led state is toggled - if((timer_count % mod_value) == 0) { + if ((timer_count % mod_value) == 0) { LINE_DBG(LEDS, xpd, i, "ledstate=%s\n", (IS_SET(priv->ledstate[color], i))?"ON":"OFF"); - if(!IS_SET(priv->ledstate[color], i)) { + if (!IS_SET(priv->ledstate[color], i)) { do_led(xpd, i, color, 1); } else { do_led(xpd, i, color, 0); } } - } else if(IS_SET(priv->ledcontrol[color], i) && !IS_SET(priv->ledstate[color], i)) { + } else if (IS_SET(priv->ledcontrol[color], i) && !IS_SET(priv->ledstate[color], i)) { do_led(xpd, i, color, 1); - } else if(!IS_SET(priv->ledcontrol[color], i) && IS_SET(priv->ledstate[color], i)) { + } else if (!IS_SET(priv->ledcontrol[color], i) && IS_SET(priv->ledstate[color], i)) { do_led(xpd, i, color, 0); } } @@ -278,7 +278,7 @@ static void handle_fxo_leds(xpd_t *xpd) static void update_dahdi_ring(xpd_t *xpd, int pos, bool on) { BUG_ON(!xpd); - if(caller_id_style == CID_STYLE_BELL) + if (caller_id_style == CID_STYLE_BELL) oht_pcm(xpd, pos, !on); /* * We should not spinlock before calling dahdi_hooksig() as @@ -300,20 +300,20 @@ static void mark_ring(xpd_t *xpd, lineno_t pos, bool on, bool update_dahdi) * due to voltage fluctuations. */ reset_battery_readings(xpd, pos); - if(on && !PHONEDEV(xpd).ringing[pos]) { + if (on && !PHONEDEV(xpd).ringing[pos]) { LINE_DBG(SIGNAL, xpd, pos, "START\n"); PHONEDEV(xpd).ringing[pos] = 1; priv->cidtimer[pos] = xpd->timer_count; MARK_BLINK(priv, pos, LED_GREEN, LED_BLINK_RING); - if(update_dahdi) + if (update_dahdi) update_dahdi_ring(xpd, pos, on); - } else if(!on && PHONEDEV(xpd).ringing[pos]) { + } else if (!on && PHONEDEV(xpd).ringing[pos]) { LINE_DBG(SIGNAL, xpd, pos, "STOP\n"); PHONEDEV(xpd).ringing[pos] = 0; priv->cidtimer[pos] = xpd->timer_count; - if(IS_BLINKING(priv, pos, LED_GREEN)) + if (IS_BLINKING(priv, pos, LED_GREEN)) MARK_BLINK(priv, pos, LED_GREEN, 0); - if(update_dahdi) + if (update_dahdi) update_dahdi_ring(xpd, pos, on); } } @@ -331,23 +331,23 @@ static int do_sethook(xpd_t *xpd, int pos, bool to_offhook) xbus = xpd->xbus; priv = xpd->priv; BUG_ON(!priv); - if(priv->battery[pos] != BATTERY_ON && to_offhook) { + if (priv->battery[pos] != BATTERY_ON && to_offhook) { LINE_NOTICE(xpd, pos, "Cannot take offhook while battery is off!\n"); return -EINVAL; } spin_lock_irqsave(&xpd->lock, flags); mark_ring(xpd, pos, 0, 0); // No more rings value = REG_DAA_CONTROL1_ONHM; /* Bit 3 is for CID */ - if(to_offhook) + if (to_offhook) value |= REG_DAA_CONTROL1_OH; LINE_DBG(SIGNAL, xpd, pos, "SETHOOK: value=0x%02X %s\n", value, (to_offhook)?"OFFHOOK":"ONHOOK"); - if(to_offhook) + if (to_offhook) MARK_ON(priv, pos, LED_GREEN); else MARK_OFF(priv, pos, LED_GREEN); ret = DAA_DIRECT_REQUEST(xbus, xpd, pos, DAA_WRITE, REG_DAA_CONTROL1, value); mark_offhook(xpd, pos, to_offhook); - if(caller_id_style != CID_STYLE_ETSI_DTMF) + if (caller_id_style != CID_STYLE_ETSI_DTMF) oht_pcm(xpd, pos, 0); #ifdef WITH_METERING priv->metering_count[pos] = 0; @@ -355,7 +355,7 @@ static int do_sethook(xpd_t *xpd, int pos, bool to_offhook) DAA_DIRECT_REQUEST(xbus, xpd, pos, DAA_WRITE, DAA_REG_METERING, 0x2D); #endif reset_battery_readings(xpd, pos); /* unstable during hook changes */ - if(to_offhook) { + if (to_offhook) { priv->power_denial_safezone[pos] = power_denial_safezone; } else { priv->power_denial_length[pos] = 0; @@ -377,14 +377,14 @@ static void fxo_proc_remove(xbus_t *xbus, xpd_t *xpd) XPD_DBG(PROC, xpd, "\n"); #ifdef CONFIG_PROC_FS #ifdef WITH_METERING - if(priv->meteringfile) { + if (priv->meteringfile) { XPD_DBG(PROC, xpd, "Removing xpd metering tone file\n"); priv->meteringfile->data = NULL; remove_proc_entry(PROC_METERING_FNAME, xpd->proc_xpd_dir); priv->meteringfile = NULL; } #endif - if(priv->fxo_info) { + if (priv->fxo_info) { XPD_DBG(PROC, xpd, "Removing xpd FXO_INFO file\n"); remove_proc_entry(PROC_FXO_INFO_FNAME, xpd->proc_xpd_dir); priv->fxo_info = NULL; @@ -401,7 +401,7 @@ static int fxo_proc_create(xbus_t *xbus, xpd_t *xpd) #ifdef CONFIG_PROC_FS XPD_DBG(PROC, xpd, "Creating FXO_INFO file\n"); priv->fxo_info = create_proc_read_entry(PROC_FXO_INFO_FNAME, 0444, xpd->proc_xpd_dir, proc_fxo_info_read, xpd); - if(!priv->fxo_info) { + if (!priv->fxo_info) { XPD_ERR(xpd, "Failed to create proc file '%s'\n", PROC_FXO_INFO_FNAME); fxo_proc_remove(xbus, xpd); return -EINVAL; @@ -411,7 +411,7 @@ static int fxo_proc_create(xbus_t *xbus, xpd_t *xpd) XPD_DBG(PROC, xpd, "Creating Metering tone file\n"); priv->meteringfile = create_proc_read_entry(PROC_METERING_FNAME, 0444, xpd->proc_xpd_dir, proc_xpd_metering_read, xpd); - if(!priv->meteringfile) { + if (!priv->meteringfile) { XPD_ERR(xpd, "Failed to create proc file '%s'\n", PROC_METERING_FNAME); fxo_proc_remove(xbus, xpd); return -EINVAL; @@ -428,22 +428,22 @@ static xpd_t *FXO_card_new(xbus_t *xbus, int unit, int subunit, const xproto_tab xpd_t *xpd = NULL; int channels; - if(to_phone) { + if (to_phone) { XBUS_NOTICE(xbus, "XPD=%d%d: try to instanciate FXO with reverse direction\n", unit, subunit); return NULL; } - if(subtype == 2) + if (subtype == 2) channels = min(2, subunit_ports); else channels = min(8, subunit_ports); xpd = xpd_alloc(xbus, unit, subunit, subtype, subunits, sizeof(struct FXO_priv_data), proto_table, channels); - if(!xpd) + if (!xpd) return NULL; PHONEDEV(xpd).direction = TO_PSTN; xpd->type_name = "FXO"; - if(fxo_proc_create(xbus, xpd) < 0) + if (fxo_proc_create(xbus, xpd) < 0) goto err; return xpd; err: @@ -465,7 +465,7 @@ static int FXO_card_init(xbus_t *xbus, xpd_t *xpd) priv->polarity_debounce[i] = 0; priv->battery[i] = BATTERY_UNKNOWN; /* will be updated on next battery sample */ priv->power[i] = POWER_UNKNOWN; /* will be updated on next battery sample */ - if(caller_id_style == CID_STYLE_ETSI_DTMF) + if (caller_id_style == CID_STYLE_ETSI_DTMF) oht_pcm(xpd, i, 1); } XPD_DBG(GENERAL, xpd, "done\n"); @@ -560,7 +560,7 @@ static int FXO_card_hooksig(xpd_t *xpd, int pos, enum dahdi_txsig txsig) LINE_DBG(SIGNAL, xpd, pos, "%s\n", txsig2str(txsig)); BUG_ON(PHONEDEV(xpd).direction != TO_PSTN); /* XXX Enable hooksig for FXO XXX */ - switch(txsig) { + switch (txsig) { case DAHDI_TXSIG_START: case DAHDI_TXSIG_OFFHOOK: ret = do_sethook(xpd, pos, 1); @@ -582,8 +582,8 @@ static void dahdi_report_battery(xpd_t *xpd, lineno_t chan) BUG_ON(!xpd); priv = xpd->priv; - if(SPAN_REGISTERED(xpd)) { - switch(priv->battery[chan]) { + if (SPAN_REGISTERED(xpd)) { + switch (priv->battery[chan]) { case BATTERY_UNKNOWN: /* no-op */ break; @@ -633,13 +633,13 @@ static void handle_fxo_ring(xpd_t *xpd) priv = xpd->priv; for_each_line(xpd, i) { - if(atomic_read(&priv->ring_debounce[i]) > 0) { + if (atomic_read(&priv->ring_debounce[i]) > 0) { /* Maybe start ring */ - if(atomic_dec_and_test(&priv->ring_debounce[i])) + if (atomic_dec_and_test(&priv->ring_debounce[i])) mark_ring(xpd, i, 1, 1); } else if (atomic_read(&priv->ring_debounce[i]) < 0) { /* Maybe stop ring */ - if(atomic_inc_and_test(&priv->ring_debounce[i])) + if (atomic_inc_and_test(&priv->ring_debounce[i])) mark_ring(xpd, i, 0, 1); } } @@ -650,16 +650,16 @@ static void handle_fxo_power_denial(xpd_t *xpd) struct FXO_priv_data *priv; int i; - if(!power_denial_safezone) + if (!power_denial_safezone) return; /* Ignore power denials */ priv = xpd->priv; for_each_line(xpd, i) { - if(PHONEDEV(xpd).ringing[i] || !IS_OFFHOOK(xpd, i)) { + if (PHONEDEV(xpd).ringing[i] || !IS_OFFHOOK(xpd, i)) { priv->power_denial_delay[i] = 0; continue; } - if(priv->power_denial_safezone[i] > 0) { - if(--priv->power_denial_safezone[i] == 0) { + if (priv->power_denial_safezone[i] > 0) { + if (--priv->power_denial_safezone[i] == 0) { /* * Poll current, previous answers are meaningless */ @@ -667,9 +667,9 @@ static void handle_fxo_power_denial(xpd_t *xpd) } continue; } - if(priv->power_denial_length[i] > 0) { + if (priv->power_denial_length[i] > 0) { priv->power_denial_length[i]--; - if(priv->power_denial_length[i] <= 0) { + if (priv->power_denial_length[i] <= 0) { /* * But maybe the FXS started to ring (and the firmware haven't * detected it yet). This would cause false power denials. @@ -712,17 +712,17 @@ static void check_etsi_dtmf(xpd_t *xpd) int portno; unsigned int timer_count; - if(!SPAN_REGISTERED(xpd)) + if (!SPAN_REGISTERED(xpd)) return; priv = xpd->priv; BUG_ON(!priv); timer_count = xpd->timer_count; for_each_line(xpd, portno) { /* Skip offhook and ringing ports */ - if(IS_OFFHOOK(xpd, portno) || PHONEDEV(xpd).ringing[portno]) + if (IS_OFFHOOK(xpd, portno) || PHONEDEV(xpd).ringing[portno]) continue; - if(IS_SET(priv->cidfound, portno)) { - if(timer_count > priv->cidtimer[portno] + 4000) { + if (IS_SET(priv->cidfound, portno)) { + if (timer_count > priv->cidtimer[portno] + 4000) { /* reset flags if it's been a while */ priv->cidtimer[portno] = timer_count; BIT_CLR(priv->cidfound, portno); @@ -730,14 +730,14 @@ static void check_etsi_dtmf(xpd_t *xpd) } continue; } - if(timer_count > priv->cidtimer[portno] + 400) { + if (timer_count > priv->cidtimer[portno] + 400) { struct dahdi_chan *chan = XPD_CHAN(xpd, portno); int sample; int i; - for(i = 0; i < DAHDI_CHUNKSIZE; i++) { + for (i = 0; i < DAHDI_CHUNKSIZE; i++) { sample = DAHDI_XLAW(chan->readchunk[i], chan); - if(sample > 16000 || sample < -16000) { + if (sample > 16000 || sample < -16000) { priv->cidtimer[portno] = timer_count; BIT_SET(priv->cidfound, portno); LINE_DBG(SIGNAL, xpd, portno, "Found DTMF CLIP (%d)\n", i); @@ -756,16 +756,16 @@ static int FXO_card_tick(xbus_t *xbus, xpd_t *xpd) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(poll_battery_interval != 0 && (priv->poll_counter % poll_battery_interval) == 0) + if (poll_battery_interval != 0 && (priv->poll_counter % poll_battery_interval) == 0) poll_battery(xbus, xpd); #ifdef WITH_METERING - if(poll_metering_interval != 0 && (priv->poll_counter % poll_metering_interval) == 0) + if (poll_metering_interval != 0 && (priv->poll_counter % poll_metering_interval) == 0) poll_metering(xbus, xpd); #endif handle_fxo_leds(xpd); handle_fxo_ring(xpd); handle_fxo_power_denial(xpd); - if(caller_id_style == CID_STYLE_ETSI_DTMF && likely(xpd->card_present)) + if (caller_id_style == CID_STYLE_ETSI_DTMF && likely(xpd->card_present)) check_etsi_dtmf(xpd); priv->poll_counter++; return 0; @@ -785,7 +785,7 @@ static int FXO_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a unsigned char echotune_data[ARRAY_SIZE(echotune_regs)]; BUG_ON(!xpd); - if(!XBUS_IS(xpd->xbus, READY)) + if (!XBUS_IS(xpd->xbus, READY)) return -ENODEV; switch (cmd) { case WCTDM_SET_ECHOTUNE: @@ -834,7 +834,7 @@ HANDLER_DEF(FXO, SIG_CHANGED) int i; struct FXO_priv_data *priv; - if(!xpd) { + if (!xpd) { notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), cmd->name); return -EPROTO; } @@ -845,8 +845,8 @@ HANDLER_DEF(FXO, SIG_CHANGED) for_each_line(xpd, i) { int debounce; - if(IS_SET(sig_toggles, i)) { - if(priv->battery[i] == BATTERY_OFF) { + if (IS_SET(sig_toggles, i)) { + if (priv->battery[i] == BATTERY_OFF) { /* * With poll_battery_interval==0 we cannot have BATTERY_OFF * so we won't get here @@ -856,7 +856,7 @@ HANDLER_DEF(FXO, SIG_CHANGED) } /* First report false ring alarms */ debounce = atomic_read(&priv->ring_debounce[i]); - if(debounce) + if (debounce) LINE_NOTICE(xpd, i, "debounced false ring (only %d ticks)\n", debounce); /* * Now set a new ring alarm. @@ -880,18 +880,18 @@ static void update_battery_voltage(xpd_t *xpd, byte data_low, xportno_t portno) priv = xpd->priv; BUG_ON(!priv); priv->battery_voltage[portno] = volts; - if(PHONEDEV(xpd).ringing[portno]) + if (PHONEDEV(xpd).ringing[portno]) goto ignore_reading; /* ring voltage create false alarms */ - if(abs(volts) < battery_threshold) { + if (abs(volts) < battery_threshold) { /* * Check for battery voltage fluctuations */ - if(priv->battery[portno] != BATTERY_OFF) { + if (priv->battery[portno] != BATTERY_OFF) { int milliseconds; milliseconds = priv->nobattery_debounce[portno]++ * poll_battery_interval; - if(milliseconds > battery_debounce) { + if (milliseconds > battery_debounce) { LINE_DBG(SIGNAL, xpd, portno, "BATTERY OFF voltage=%d\n", volts); priv->battery[portno] = BATTERY_OFF; dahdi_report_battery(xpd, portno); @@ -909,7 +909,7 @@ static void update_battery_voltage(xpd_t *xpd, byte data_low, xportno_t portno) } } else { priv->nobattery_debounce[portno] = 0; - if(priv->battery[portno] != BATTERY_ON) { + if (priv->battery[portno] != BATTERY_ON) { LINE_DBG(SIGNAL, xpd, portno, "BATTERY ON voltage=%d\n", volts); priv->battery[portno] = BATTERY_ON; dahdi_report_battery(xpd, portno); @@ -919,25 +919,25 @@ static void update_battery_voltage(xpd_t *xpd, byte data_low, xportno_t portno) /* * Mark FXO ports without battery! */ - if(priv->battery[portno] != BATTERY_ON) + if (priv->battery[portno] != BATTERY_ON) MARK_ON(priv, portno, LED_RED); else MARK_OFF(priv, portno, LED_RED); #endif - if(priv->battery[portno] != BATTERY_ON) { + if (priv->battery[portno] != BATTERY_ON) { priv->polarity[portno] = POL_UNKNOWN; /* What's the polarity ? */ return; } /* * Handle reverse polarity */ - if(volts == 0) + if (volts == 0) pol = POL_UNKNOWN; - else if(volts < 0) + else if (volts < 0) pol = POL_NEGATIVE; else pol = POL_POSITIVE; - if(priv->polarity[portno] == pol) { + if (priv->polarity[portno] == pol) { /* * Same polarity, reset debounce counter */ @@ -951,12 +951,12 @@ static void update_battery_voltage(xpd_t *xpd, byte data_low, xportno_t portno) msec = priv->polarity_debounce[portno]++ * poll_battery_interval; if (msec >= POLREV_THRESHOLD) { priv->polarity_debounce[portno] = 0; - if(pol != POL_UNKNOWN && priv->polarity[portno] != POL_UNKNOWN) { + if (pol != POL_UNKNOWN && priv->polarity[portno] != POL_UNKNOWN) { char *polname = NULL; - if(pol == POL_POSITIVE) + if (pol == POL_POSITIVE) polname = "Positive"; - else if(pol == POL_NEGATIVE) + else if (pol == POL_NEGATIVE) polname = "Negative"; else BUG(); @@ -968,9 +968,9 @@ static void update_battery_voltage(xpd_t *xpd, byte data_low, xportno_t portno) * 2. In some countries used to report caller-id during onhook * but before first ring. */ - if(caller_id_style == CID_STYLE_ETSI_FSK) + if (caller_id_style == CID_STYLE_ETSI_FSK) oht_pcm(xpd, portno, 1); /* will be cleared on ring/offhook */ - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { LINE_DBG(SIGNAL, xpd, portno, "Send DAHDI_EVENT_POLARITY: %s\n", polname); dahdi_qevent_lock(XPD_CHAN(xpd, portno), DAHDI_EVENT_POLARITY); @@ -997,23 +997,23 @@ static void update_battery_current(xpd_t *xpd, byte data_low, xportno_t portno) * During ringing, current is not stable. * During onhook there should not be current anyway. */ - if(PHONEDEV(xpd).ringing[portno] || !IS_OFFHOOK(xpd, portno)) + if (PHONEDEV(xpd).ringing[portno] || !IS_OFFHOOK(xpd, portno)) goto ignore_it; /* * Power denial with no battery voltage is meaningless */ - if(priv->battery[portno] != BATTERY_ON) + if (priv->battery[portno] != BATTERY_ON) goto ignore_it; /* Safe zone after offhook */ - if(priv->power_denial_safezone[portno] > 0) + if (priv->power_denial_safezone[portno] > 0) goto ignore_it; - if(data_low < POWER_DENIAL_CURRENT) { - if(priv->power[portno] == POWER_ON) { + if (data_low < POWER_DENIAL_CURRENT) { + if (priv->power[portno] == POWER_ON) { power_change(xpd, portno, POWER_OFF); priv->power_denial_length[portno] = power_denial_minlen; } } else { - if(priv->power[portno] != POWER_ON) { + if (priv->power[portno] != POWER_ON) { power_change(xpd, portno, POWER_ON); priv->power_denial_length[portno] = 0; /* We are now OFFHOOK */ @@ -1040,13 +1040,13 @@ static void update_metering_state(xpd_t *xpd, byte data_low, lineno_t portno) LINE_DBG(SIGNAL, xpd, portno, "METERING: %s [dL=0x%X] (%d)\n", (metering_tone) ? "ON" : "OFF", data_low, priv->metering_count[portno]); - if(metering_tone && !old_metering_tone) { + if (metering_tone && !old_metering_tone) { /* Rising edge */ priv->metering_count[portno]++; BIT_SET(priv->metering_tone_state, portno); - } else if(!metering_tone && old_metering_tone) + } else if (!metering_tone && old_metering_tone) BIT_CLR(priv->metering_tone_state, portno); - if(metering_tone) { + if (metering_tone) { /* Clear the BTD bit */ data_low &= ~BTD_BIT; DAA_DIRECT_REQUEST(xpd->xbus, xpd, portno, DAA_WRITE, DAA_REG_METERING, data_low); @@ -1062,7 +1062,7 @@ static int FXO_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) priv = xpd->priv; BUG_ON(!priv); portno = info->portnum; - switch(REG_FIELD(info, regnum)) { + switch (REG_FIELD(info, regnum)) { case DAA_REG_VBAT: update_battery_voltage(xpd, REG_FIELD(info, data_low), portno); break; @@ -1081,7 +1081,7 @@ static int FXO_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) REG_FIELD(info, data_low), REG_FIELD(info, data_high)); /* Update /proc info only if reply relate to the last slic read request */ - if( + if ( REG_FIELD(&xpd->requested_reply, regnum) == REG_FIELD(info, regnum) && REG_FIELD(&xpd->requested_reply, do_subreg) == REG_FIELD(info, do_subreg) && REG_FIELD(&xpd->requested_reply, subreg) == REG_FIELD(info, subreg)) { @@ -1165,27 +1165,27 @@ static int proc_fxo_info_read(char *page, char **start, off_t off, int count, in struct FXO_priv_data *priv; int i; - if(!xpd) + if (!xpd) return -ENODEV; spin_lock_irqsave(&xpd->lock, flags); priv = xpd->priv; BUG_ON(!priv); len += sprintf(page + len, "\t%-17s: ", "Channel"); for_each_line(xpd, i) { - if(!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) len += sprintf(page + len, "%4d ", i % 10); } len += sprintf(page + len, "\nLeds:"); len += sprintf(page + len, "\n\t%-17s: ", "state"); for_each_line(xpd, i) { - if(!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) len += sprintf(page + len, " %d%d ", IS_SET(priv->ledstate[LED_GREEN], i), IS_SET(priv->ledstate[LED_RED], i)); } len += sprintf(page + len, "\n\t%-17s: ", "blinking"); for_each_line(xpd, i) { - if(!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) len += sprintf(page + len, " %d%d ", IS_BLINKING(priv,i,LED_GREEN), IS_BLINKING(priv,i,LED_RED)); @@ -1204,9 +1204,9 @@ static int proc_fxo_info_read(char *page, char **start, off_t off, int count, in for_each_line(xpd, i) { char *bat; - if(priv->battery[i] == BATTERY_ON) + if (priv->battery[i] == BATTERY_ON) bat = "+"; - else if(priv->battery[i] == BATTERY_OFF) + else if (priv->battery[i] == BATTERY_OFF) bat = "-"; else bat = "."; @@ -1221,9 +1221,9 @@ static int proc_fxo_info_read(char *page, char **start, off_t off, int count, in for_each_line(xpd, i) { char *polname; - if(priv->polarity[i] == POL_POSITIVE) + if (priv->polarity[i] == POL_POSITIVE) polname = "+"; - else if(priv->polarity[i] == POL_NEGATIVE) + else if (priv->polarity[i] == POL_NEGATIVE) polname = "-"; else polname = "."; @@ -1238,9 +1238,9 @@ static int proc_fxo_info_read(char *page, char **start, off_t off, int count, in for_each_line(xpd, i) { char *curr; - if(priv->power[i] == POWER_ON) + if (priv->power[i] == POWER_ON) curr = "+"; - else if(priv->power[i] == POWER_OFF) + else if (priv->power[i] == POWER_OFF) curr = "-"; else curr = "."; @@ -1284,7 +1284,7 @@ static int proc_xpd_metering_read(char *page, char **start, off_t off, int count struct FXO_priv_data *priv; int i; - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); @@ -1320,7 +1320,7 @@ static DEVICE_ATTR_READER(fxo_battery_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); @@ -1328,9 +1328,9 @@ static DEVICE_ATTR_READER(fxo_battery_show, dev, buf) for_each_line(xpd, i) { char bat; - if(priv->battery[i] == BATTERY_ON) + if (priv->battery[i] == BATTERY_ON) bat = '+'; - else if(priv->battery[i] == BATTERY_OFF) + else if (priv->battery[i] == BATTERY_OFF) bat = '-'; else bat = '.'; @@ -1351,14 +1351,14 @@ static int fxo_xpd_probe(struct device *dev) xpd = dev_to_xpd(dev); /* Is it our device? */ - if(xpd->type != XPD_TYPE_FXO) { + if (xpd->type != XPD_TYPE_FXO) { XPD_ERR(xpd, "drop suggestion for %s (%d)\n", dev_name(dev), xpd->type); return -EINVAL; } XPD_DBG(DEVICES, xpd, "SYSFS\n"); ret = device_create_file(dev, &dev_attr_fxo_battery); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_create_file(fxo_battery) failed: %d\n", __func__, ret); goto fail_fxo_battery; } @@ -1393,11 +1393,11 @@ static int __init card_fxo_startup(void) { int ret; - if(ring_debounce <= 0) { + if (ring_debounce <= 0) { ERR("ring_debounce=%d. Must be positive number of ticks\n", ring_debounce); return -EINVAL; } - if((ret = xpd_driver_register(&fxo_driver.driver)) < 0) + if ((ret = xpd_driver_register(&fxo_driver.driver)) < 0) return ret; INFO("revision %s\n", XPP_VERSION); #ifdef WITH_METERING diff --git a/drivers/dahdi/xpp/card_fxs.c b/drivers/dahdi/xpp/card_fxs.c index cb13821..4f322cb 100644 --- a/drivers/dahdi/xpp/card_fxs.c +++ b/drivers/dahdi/xpp/card_fxs.c @@ -151,8 +151,8 @@ struct FXS_priv_data { #define LED_COUNTER(priv,pos,color) ((priv)->led_counter[color][pos]) #define IS_BLINKING(priv,pos,color) (LED_COUNTER(priv,pos,color) > 0) #define MARK_BLINK(priv,pos,color,t) ((priv)->led_counter[color][pos] = (t)) -#define MARK_OFF(priv,pos,color) do { BIT_CLR((priv)->ledcontrol[color],(pos)); MARK_BLINK((priv),(pos),(color),0); } while(0) -#define MARK_ON(priv,pos,color) do { BIT_SET((priv)->ledcontrol[color],(pos)); MARK_BLINK((priv),(pos),(color),0); } while(0) +#define MARK_OFF(priv,pos,color) do { BIT_CLR((priv)->ledcontrol[color],(pos)); MARK_BLINK((priv),(pos),(color),0); } while (0) +#define MARK_ON(priv,pos,color) do { BIT_SET((priv)->ledcontrol[color],(pos)); MARK_BLINK((priv),(pos),(color),0); } while (0) #define LED_BLINK_RING (1000/8) /* in ticks */ @@ -236,12 +236,12 @@ static int do_led(xpd_t *xpd, lineno_t chan, byte which, bool on) xbus = xpd->xbus; priv = xpd->priv; which = which % NUM_LEDS; - if(IS_SET(PHONEDEV(xpd).digital_outputs, chan) || IS_SET(PHONEDEV(xpd).digital_inputs, chan)) + if (IS_SET(PHONEDEV(xpd).digital_outputs, chan) || IS_SET(PHONEDEV(xpd).digital_inputs, chan)) goto out; - if(chan == PORT_BROADCAST) { + if (chan == PORT_BROADCAST) { priv->ledstate[which] = (on) ? ~0 : 0; } else { - if(on) { + if (on) { BIT_SET(priv->ledstate[which], chan); } else { BIT_CLR(priv->ledstate[which], chan); @@ -250,7 +250,7 @@ static int do_led(xpd_t *xpd, lineno_t chan, byte which, bool on) LINE_DBG(LEDS, xpd, chan, "LED: which=%d -- %s\n", which, (on) ? "on" : "off"); value = BIT(2) | BIT(3); value |= ((BIT(5) | BIT(6) | BIT(7)) & ~led_register_mask[which]); - if(on) + if (on) value |= led_register_vals[which]; ret = SLIC_DIRECT_REQUEST(xbus, xpd, chan, SLIC_WRITE, REG_DIGITAL_IOCTRL, value); @@ -269,27 +269,27 @@ static void handle_fxs_leds(xpd_t *xpd) BUG_ON(!xpd); priv = xpd->priv; timer_count = xpd->timer_count; - for(color = 0; color < ARRAY_SIZE(colors); color++) { + for (color = 0; color < ARRAY_SIZE(colors); color++) { for_each_line(xpd, i) { - if(IS_SET(PHONEDEV(xpd).digital_outputs | PHONEDEV(xpd).digital_inputs, i)) + if (IS_SET(PHONEDEV(xpd).digital_outputs | PHONEDEV(xpd).digital_inputs, i)) continue; - if((xpd->blink_mode & BIT(i)) || IS_BLINKING(priv, i, color)) { // Blinking + if ((xpd->blink_mode & BIT(i)) || IS_BLINKING(priv, i, color)) { // Blinking int mod_value = LED_COUNTER(priv, i, color); - if(!mod_value) + if (!mod_value) mod_value = DEFAULT_LED_PERIOD; /* safety value */ // led state is toggled - if((timer_count % mod_value) == 0) { + if ((timer_count % mod_value) == 0) { LINE_DBG(LEDS, xpd, i, "ledstate=%s\n", (IS_SET(priv->ledstate[color], i))?"ON":"OFF"); - if(!IS_SET(priv->ledstate[color], i)) { + if (!IS_SET(priv->ledstate[color], i)) { do_led(xpd, i, color, 1); } else { do_led(xpd, i, color, 0); } } - } else if(IS_SET(priv->ledcontrol[color] & ~priv->ledstate[color], i)) { + } else if (IS_SET(priv->ledcontrol[color] & ~priv->ledstate[color], i)) { do_led(xpd, i, color, 1); - } else if(IS_SET(~priv->ledcontrol[color] & priv->ledstate[color], i)) { + } else if (IS_SET(~priv->ledcontrol[color] & priv->ledstate[color], i)) { do_led(xpd, i, color, 0); } @@ -304,7 +304,7 @@ static void restore_leds(xpd_t *xpd) priv = xpd->priv; for_each_line(xpd, i) { - if(IS_OFFHOOK(xpd, i)) + if (IS_OFFHOOK(xpd, i)) MARK_ON(priv, i, LED_GREEN); else MARK_OFF(priv, i, LED_GREEN); @@ -331,14 +331,14 @@ static void fxs_proc_remove(xbus_t *xbus, xpd_t *xpd) priv = xpd->priv; #ifdef CONFIG_PROC_FS #ifdef WITH_METERING - if(priv->meteringfile) { + if (priv->meteringfile) { XPD_DBG(PROC, xpd, "Removing xpd metering tone file\n"); priv->meteringfile->data = NULL; remove_proc_entry(PROC_METERING_FNAME, xpd->proc_xpd_dir); priv->meteringfile = NULL; } #endif - if(priv->fxs_info) { + if (priv->fxs_info) { XPD_DBG(PROC, xpd, "Removing xpd FXS_INFO file\n"); remove_proc_entry(PROC_FXS_INFO_FNAME, xpd->proc_xpd_dir); priv->fxs_info = NULL; @@ -356,7 +356,7 @@ static int fxs_proc_create(xbus_t *xbus, xpd_t *xpd) #ifdef CONFIG_PROC_FS XPD_DBG(PROC, xpd, "Creating FXS_INFO file\n"); priv->fxs_info = create_proc_read_entry(PROC_FXS_INFO_FNAME, 0444, xpd->proc_xpd_dir, proc_fxs_info_read, xpd); - if(!priv->fxs_info) { + if (!priv->fxs_info) { XPD_ERR(xpd, "Failed to create proc file '%s'\n", PROC_FXS_INFO_FNAME); fxs_proc_remove(xbus, xpd); return -EINVAL; @@ -365,7 +365,7 @@ static int fxs_proc_create(xbus_t *xbus, xpd_t *xpd) #ifdef WITH_METERING XPD_DBG(PROC, xpd, "Creating Metering tone file\n"); priv->meteringfile = create_proc_entry(PROC_METERING_FNAME, 0200, xpd->proc_xpd_dir); - if(!priv->meteringfile) { + if (!priv->meteringfile) { XPD_ERR(xpd, "Failed to create proc file '%s'\n", PROC_METERING_FNAME); fxs_proc_remove(xbus, xpd); return -EINVAL; @@ -390,25 +390,25 @@ static xpd_t *FXS_card_new(xbus_t *xbus, int unit, int subunit, const xproto_tab int d_inputs = 0; int d_outputs = 0; - if(!to_phone) { + if (!to_phone) { XBUS_NOTICE(xbus, "XPD=%d%d: try to instanciate FXS with reverse direction\n", unit, subunit); return NULL; } - if(subtype == 2) + if (subtype == 2) regular_channels = min(6, subunit_ports); else regular_channels = min(8, subunit_ports); channels = regular_channels; /* Calculate digital inputs/outputs */ - if(unit == 0 && subtype != 4) { + if (unit == 0 && subtype != 4) { channels += 6; /* 2 DIGITAL OUTPUTS, 4 DIGITAL INPUTS */ d_inputs = LINES_DIGI_INP; d_outputs = LINES_DIGI_OUT; } xpd = xpd_alloc(xbus, unit, subunit, subtype, subunits, sizeof(struct FXS_priv_data), proto_table, channels); - if(!xpd) + if (!xpd) return NULL; /* Initialize digital inputs/outputs */ if (d_inputs) { @@ -427,7 +427,7 @@ static xpd_t *FXS_card_new(xbus_t *xbus, int unit, int subunit, const xproto_tab XBUS_DBG(GENERAL, xbus, "No digital outputs\n"); PHONEDEV(xpd).direction = TO_PHONE; xpd->type_name = "FXS"; - if(fxs_proc_create(xbus, xpd) < 0) + if (fxs_proc_create(xbus, xpd) < 0) goto err; priv = xpd->priv; for_each_line(xpd, i) { @@ -450,7 +450,7 @@ static int FXS_card_init(xbus_t *xbus, xpd_t *xpd) */ /* Software controled ringing (for CID) */ ret = SLIC_DIRECT_REQUEST(xbus, xpd, PORT_BROADCAST, SLIC_WRITE, 0x22, 0x00); /* Ringing Oscilator Control */ - if(ret < 0) + if (ret < 0) goto err; for_each_line(xpd, i) { linefeed_control(xbus, xpd, i, FXS_LINE_POL_ACTIVE); @@ -476,7 +476,7 @@ static int FXS_card_init(xbus_t *xbus, xpd_t *xpd) * So we do this after the LEDs */ for_each_line(xpd, i) { - if(IS_SET(PHONEDEV(xpd).digital_outputs | PHONEDEV(xpd).digital_inputs, i)) + if (IS_SET(PHONEDEV(xpd).digital_outputs | PHONEDEV(xpd).digital_inputs, i)) continue; SLIC_DIRECT_REQUEST(xbus, xpd, i, SLIC_READ, REG_LOOPCLOSURE, 0); } @@ -512,10 +512,10 @@ static int FXS_card_dahdi_preregistration(xpd_t *xpd, bool on) struct dahdi_chan *cur_chan = XPD_CHAN(xpd, i); XPD_DBG(GENERAL, xpd, "setting FXS channel %d\n", i); - if(IS_SET(PHONEDEV(xpd).digital_outputs, i)) { + if (IS_SET(PHONEDEV(xpd).digital_outputs, i)) { snprintf(cur_chan->name, MAX_CHANNAME, "XPP_OUT/%02d/%1d%1d/%d", xbus->num, xpd->addr.unit, xpd->addr.subunit, i); - } else if(IS_SET(PHONEDEV(xpd).digital_inputs, i)) { + } else if (IS_SET(PHONEDEV(xpd).digital_inputs, i)) { snprintf(cur_chan->name, MAX_CHANNAME, "XPP_IN/%02d/%1d%1d/%d", xbus->num, xpd->addr.unit, xpd->addr.subunit, i); } else { @@ -569,7 +569,7 @@ static void __do_mute_dtmf(xpd_t *xpd, int pos, bool muteit) priv = xpd->priv; LINE_DBG(SIGNAL, xpd, pos, "%s\n", (muteit) ? "MUTE" : "UNMUTE"); - if(muteit) + if (muteit) BIT_SET(PHONEDEV(xpd).mute_dtmf, pos); else BIT_CLR(PHONEDEV(xpd).mute_dtmf, pos); @@ -672,7 +672,7 @@ static int relay_out(xpd_t *xpd, int pos, bool on) which = which % ARRAY_SIZE(relay_channels); value = BIT(2) | BIT(3); value |= ((BIT(5) | BIT(6) | BIT(7)) & ~led_register_mask[OUTPUT_RELAY]); - if(on) + if (on) value |= led_register_vals[OUTPUT_RELAY]; return SLIC_DIRECT_REQUEST(xpd->xbus, xpd, relay_channels[which], SLIC_WRITE, REG_DIGITAL_IOCTRL, value); @@ -693,10 +693,10 @@ static int send_ring(xpd_t *xpd, lineno_t chan, bool on) set_vm_led_mode(xbus, xpd, chan, 0); do_chan_power(xbus, xpd, chan, on); // Power up (for ring) ret = linefeed_control(xbus, xpd, chan, value); - if(on) { + if (on) { MARK_BLINK(priv, chan, LED_GREEN, LED_BLINK_RING); } else { - if(IS_BLINKING(priv, chan, LED_GREEN)) + if (IS_BLINKING(priv, chan, LED_GREEN)) MARK_BLINK(priv, chan, LED_GREEN, 0); } return ret; @@ -717,9 +717,9 @@ static int FXS_card_hooksig(xpd_t *xpd, int pos, enum dahdi_txsig txsig) LINE_DBG(SIGNAL, xpd, pos, "Ignoring signal sent to digital input line\n"); return 0; } - if(SPAN_REGISTERED(xpd)) + if (SPAN_REGISTERED(xpd)) chan = XPD_CHAN(xpd, pos); - switch(txsig) { + switch (txsig) { case DAHDI_TXSIG_ONHOOK: spin_lock_irqsave(&xpd->lock, flags); PHONEDEV(xpd).ringing[pos] = 0; @@ -729,7 +729,7 @@ static int FXS_card_hooksig(xpd_t *xpd, int pos, enum dahdi_txsig txsig) BIT_CLR(priv->want_dtmf_mute, pos); __do_mute_dtmf(xpd, pos, 0); spin_unlock_irqrestore(&xpd->lock, flags); - if(IS_SET(PHONEDEV(xpd).digital_outputs, pos)) { + if (IS_SET(PHONEDEV(xpd).digital_outputs, pos)) { LINE_DBG(SIGNAL, xpd, pos, "%s -> digital output OFF\n", txsig2str(txsig)); ret = relay_out(xpd, pos, 0); return ret; @@ -740,15 +740,15 @@ static int FXS_card_hooksig(xpd_t *xpd, int pos, enum dahdi_txsig txsig) */ LINE_DBG(SIGNAL, xpd, pos, "KEWL STOP\n"); linefeed_control(xpd->xbus, xpd, pos, FXS_LINE_POL_ACTIVE); - if(IS_OFFHOOK(xpd, pos)) + if (IS_OFFHOOK(xpd, pos)) MARK_ON(priv, pos, LED_GREEN); } ret = send_ring(xpd, pos, 0); // RING off if (!IS_OFFHOOK(xpd, pos)) start_stop_vm_led(xpd->xbus, xpd, pos); txhook = priv->lasttxhook[pos]; - if(chan) { - switch(chan->sig) { + if (chan) { + switch (chan->sig) { case DAHDI_SIG_EM: case DAHDI_SIG_FXOKS: case DAHDI_SIG_FXOLS: @@ -762,18 +762,18 @@ static int FXS_card_hooksig(xpd_t *xpd, int pos, enum dahdi_txsig txsig) ret = linefeed_control(xpd->xbus, xpd, pos, txhook); break; case DAHDI_TXSIG_OFFHOOK: - if(IS_SET(PHONEDEV(xpd).digital_outputs, pos)) { + if (IS_SET(PHONEDEV(xpd).digital_outputs, pos)) { LINE_NOTICE(xpd, pos, "%s -> Is digital output. Ignored\n", txsig2str(txsig)); return -EINVAL; } txhook = priv->lasttxhook[pos]; - if(PHONEDEV(xpd).ringing[pos]) { + if (PHONEDEV(xpd).ringing[pos]) { oht_pcm(xpd, pos, 1); txhook = FXS_LINE_OHTRANS; } PHONEDEV(xpd).ringing[pos] = 0; - if(chan) { - switch(chan->sig) { + if (chan) { + switch (chan->sig) { case DAHDI_SIG_EM: txhook = FXS_LINE_POL_ACTIVE; break; @@ -788,7 +788,7 @@ static int FXS_card_hooksig(xpd_t *xpd, int pos, enum dahdi_txsig txsig) PHONEDEV(xpd).ringing[pos] = 1; oht_pcm(xpd, pos, 0); vmwi_search(xpd, pos, 0); - if(IS_SET(PHONEDEV(xpd).digital_outputs, pos)) { + if (IS_SET(PHONEDEV(xpd).digital_outputs, pos)) { LINE_DBG(SIGNAL, xpd, pos, "%s -> digital output ON\n", txsig2str(txsig)); ret = relay_out(xpd, pos, 1); return ret; @@ -796,7 +796,7 @@ static int FXS_card_hooksig(xpd_t *xpd, int pos, enum dahdi_txsig txsig) ret = send_ring(xpd, pos, 1); // RING on break; case DAHDI_TXSIG_KEWL: - if(IS_SET(PHONEDEV(xpd).digital_outputs, pos)) { + if (IS_SET(PHONEDEV(xpd).digital_outputs, pos)) { LINE_DBG(SIGNAL, xpd, pos, "%s -> Is digital output. Ignored\n", txsig2str(txsig)); return -EINVAL; } @@ -868,7 +868,7 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a BUG_ON(!priv); xbus = xpd->xbus; BUG_ON(!xbus); - if(!XBUS_IS(xbus, READY)) + if (!XBUS_IS(xbus, READY)) return -ENODEV; if (pos < 0 || pos >= PHONEDEV(xpd).channels) { XPD_NOTICE(xpd, "Bad channel number %d in %s(), cmd=%u\n", @@ -902,9 +902,9 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a (val & DAHDI_TONEDETECT_ON) ? "ON" : "OFF", (val & DAHDI_TONEDETECT_MUTE) ? "MUTE" : "NO-MUTE", (dtmf_detection ? "YES" : "NO")); - if(!dtmf_detection) { + if (!dtmf_detection) { spin_lock_irqsave(&xpd->lock, flags); - if(IS_SET(priv->want_dtmf_events, pos)) { + if (IS_SET(priv->want_dtmf_events, pos)) { /* Detection mode changed: Disable DTMF interrupts */ SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x17, 0); } @@ -920,8 +920,8 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a * dtmf events. Check the requested state. */ spin_lock_irqsave(&xpd->lock, flags); - if(val & DAHDI_TONEDETECT_ON) { - if(!IS_SET(priv->want_dtmf_events, pos)) { + if (val & DAHDI_TONEDETECT_ON) { + if (!IS_SET(priv->want_dtmf_events, pos)) { /* Detection mode changed: Enable DTMF interrupts */ LINE_DBG(SIGNAL, xpd, pos, "DAHDI_TONEDETECT: Enable Hardware DTMF\n"); @@ -929,7 +929,7 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a } BIT_SET(priv->want_dtmf_events, pos); } else { - if(IS_SET(priv->want_dtmf_events, pos)) { + if (IS_SET(priv->want_dtmf_events, pos)) { /* Detection mode changed: Disable DTMF interrupts */ LINE_DBG(SIGNAL, xpd, pos, "DAHDI_TONEDETECT: Disable Hardware DTMF\n"); @@ -937,7 +937,7 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a } BIT_CLR(priv->want_dtmf_events, pos); } - if(val & DAHDI_TONEDETECT_MUTE) { + if (val & DAHDI_TONEDETECT_MUTE) { BIT_SET(priv->want_dtmf_mute, pos); } else { BIT_CLR(priv->want_dtmf_mute, pos); @@ -983,10 +983,10 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a case DAHDI_VMWI: /* message-waiting led control */ if (get_user(val, (int __user *)arg)) return -EFAULT; - if(!vmwi_ioctl) { + if (!vmwi_ioctl) { static bool notified; - if(!notified++) + if (!notified++) LINE_NOTICE(xpd, pos, "Got DAHDI_VMWI notification but vmwi_ioctl parameter is off. Ignoring.\n"); return 0; @@ -1010,7 +1010,7 @@ static int FXS_card_open(xpd_t *xpd, lineno_t chan) BUG_ON(!xpd); priv = xpd->priv; - if(IS_OFFHOOK(xpd, chan)) + if (IS_OFFHOOK(xpd, chan)) LINE_NOTICE(xpd, chan, "Already offhook during open. OK.\n"); else LINE_DBG(SIGNAL, xpd, chan, "is onhook\n"); @@ -1051,7 +1051,7 @@ static void poll_inputs(xpd_t *xpd) int i; BUG_ON(xpd->xbus_idx != 0); // Only unit #0 has digital inputs - for(i = 0; i < ARRAY_SIZE(input_channels); i++) { + for (i = 0; i < ARRAY_SIZE(input_channels); i++) { byte pos = input_channels[i]; SLIC_DIRECT_REQUEST(xpd->xbus, xpd, pos, SLIC_READ, 0x06, 0); @@ -1099,8 +1099,8 @@ static inline bool mem_equal(const char a[], const char b[], size_t len) { int i; - for(i = 0; i < len; i++) - if(a[i] != b[i]) + for (i = 0; i < len; i++) + if (a[i] != b[i]) return 0; return 1; } @@ -1132,32 +1132,32 @@ static void detect_vmwi(xpd_t *xpd) struct dahdi_chan *chan = XPD_CHAN(xpd, i); byte *writechunk = chan->writechunk; - if(IS_SET(ignore_mask, i)) + if (IS_SET(ignore_mask, i)) continue; #if 0 - if(writechunk[0] != 0x7F && writechunk[0] != 0) { + if (writechunk[0] != 0x7F && writechunk[0] != 0) { int j; LINE_DBG(GENERAL, xpd, pos, "MSG:"); - for(j = 0; j < DAHDI_CHUNKSIZE; j++) { - if(debug) + for (j = 0; j < DAHDI_CHUNKSIZE; j++) { + if (debug) printk(" %02X", writechunk[j]); } - if(debug) + if (debug) printk("\n"); } #endif - if(unlikely(mem_equal(writechunk, FSK_COMMON_PATTERN, DAHDI_CHUNKSIZE))) { + if (unlikely(mem_equal(writechunk, FSK_COMMON_PATTERN, DAHDI_CHUNKSIZE))) { LINE_DBG(SIGNAL, xpd, i, "Found common FSK pattern. Start looking for ON/OFF patterns.\n"); BIT_SET(priv->found_fsk_pattern, i); - } else if(unlikely(IS_SET(priv->found_fsk_pattern, i))) { + } else if (unlikely(IS_SET(priv->found_fsk_pattern, i))) { BIT_CLR(priv->found_fsk_pattern, i); oht_pcm(xpd, i, 0); - if(unlikely(mem_equal(writechunk, FSK_ON_PATTERN, DAHDI_CHUNKSIZE))) { + if (unlikely(mem_equal(writechunk, FSK_ON_PATTERN, DAHDI_CHUNKSIZE))) { LINE_DBG(SIGNAL, xpd, i, "MSG WAITING ON\n"); PHONEDEV(xpd).msg_waiting[i] = 1; start_stop_vm_led(xbus, xpd, i); - } else if(unlikely(mem_equal(writechunk, FSK_OFF_PATTERN, DAHDI_CHUNKSIZE))) { + } else if (unlikely(mem_equal(writechunk, FSK_OFF_PATTERN, DAHDI_CHUNKSIZE))) { LINE_DBG(SIGNAL, xpd, i, "MSG WAITING OFF\n"); PHONEDEV(xpd).msg_waiting[i] = 0; start_stop_vm_led(xbus, xpd, i); @@ -1165,7 +1165,7 @@ static void detect_vmwi(xpd_t *xpd) int j; LINE_NOTICE(xpd, i, "MSG WAITING Unexpected:"); - for(j = 0; j < DAHDI_CHUNKSIZE; j++) { + for (j = 0; j < DAHDI_CHUNKSIZE; j++) { printk(" %02X", writechunk[j]); } printk("\n"); @@ -1183,7 +1183,7 @@ static int FXS_card_tick(xbus_t *xbus, xpd_t *xpd) BUG_ON(!priv); #ifdef POLL_DIGITAL_INPUTS if (poll_digital_inputs && PHONEDEV(xpd).digital_inputs) { - if((xpd->timer_count % poll_digital_inputs) == 0) + if ((xpd->timer_count % poll_digital_inputs) == 0) poll_inputs(xpd); } #endif @@ -1196,19 +1196,19 @@ static int FXS_card_tick(xbus_t *xbus, xpd_t *xpd) * so we marked it in the priv->update_offhook_state mask and * now we take care of notification to dahdi and Asterisk */ - if(priv->update_offhook_state) { + if (priv->update_offhook_state) { enum dahdi_rxsig rxsig; int i; for_each_line(xpd, i) { - if(!IS_SET(priv->update_offhook_state, i)) + if (!IS_SET(priv->update_offhook_state, i)) continue; rxsig = IS_OFFHOOK(xpd, i) ? DAHDI_RXSIG_OFFHOOK : DAHDI_RXSIG_ONHOOK; notify_rxsig(xpd, i, rxsig); /* Notify after open() */ BIT_CLR(priv->update_offhook_state, i); } } - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { if (!vmwi_ioctl && priv->search_fsk_pattern) detect_vmwi(xpd); /* Detect via FSK modulation */ } @@ -1234,9 +1234,9 @@ static void process_hookstate(xpd_t *xpd, xpp_line_t offhook, xpp_line_t change_ priv = xpd->priv; XPD_DBG(SIGNAL, xpd, "offhook=0x%X change_mask=0x%X\n", offhook, change_mask); for_each_line(xpd, i) { - if(IS_SET(PHONEDEV(xpd).digital_outputs, i) || IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (IS_SET(PHONEDEV(xpd).digital_outputs, i) || IS_SET(PHONEDEV(xpd).digital_inputs, i)) continue; - if(IS_SET(change_mask, i)) { + if (IS_SET(change_mask, i)) { PHONEDEV(xpd).ringing[i] = 0; /* No more ringing... */ #ifdef WITH_METERING metering_gen(xpd, i, 0); /* Stop metering... */ @@ -1247,7 +1247,7 @@ static void process_hookstate(xpd_t *xpd, xpp_line_t offhook, xpp_line_t change_ */ BIT_CLR(priv->prev_key_down, i); priv->prev_key_time[i].tv_sec = priv->prev_key_time[i].tv_usec = 0L; - if(IS_SET(offhook, i)) { + if (IS_SET(offhook, i)) { LINE_DBG(SIGNAL, xpd, i, "OFFHOOK\n"); MARK_ON(priv, i, LED_GREEN); hookstate_changed(xpd, i, 1); @@ -1277,7 +1277,7 @@ HANDLER_DEF(FXS, SIG_CHANGED) #if 0 Is this needed? for_each_line(xpd, i) { - if(IS_SET(sig_toggles, i)) + if (IS_SET(sig_toggles, i)) do_chan_power(xpd->xbus, xpd, BIT(i), 0); // Power down (prevent overheating!!!) } #endif @@ -1302,19 +1302,19 @@ static void process_digital_inputs(xpd_t *xpd, const reg_cmd_t *info) return; } /* Map SLIC number into line number */ - for(i = 0; i < ARRAY_SIZE(input_channels); i++) { + for (i = 0; i < ARRAY_SIZE(input_channels); i++) { int channo = input_channels[i]; int newchanno; - if(IS_SET(lines, channo)) { + if (IS_SET(lines, channo)) { newchanno = PHONEDEV(xpd).channels - LINES_DIGI_INP + i; BIT_CLR(lines, channo); BIT_SET(lines, newchanno); PHONEDEV(xpd).ringing[newchanno] = 0; // Stop ringing. No leds for digital inputs. - if(offhook && !IS_OFFHOOK(xpd, newchanno)) { // OFFHOOK + if (offhook && !IS_OFFHOOK(xpd, newchanno)) { // OFFHOOK LINE_DBG(SIGNAL, xpd, newchanno, "OFFHOOK\n"); hookstate_changed(xpd, newchanno, 1); - } else if(!offhook && IS_OFFHOOK(xpd, newchanno)) { // ONHOOK + } else if (!offhook && IS_OFFHOOK(xpd, newchanno)) { // ONHOOK LINE_DBG(SIGNAL, xpd, newchanno, "ONHOOK\n"); hookstate_changed(xpd, newchanno, 0); } @@ -1341,24 +1341,24 @@ static void process_dtmf(xpd_t *xpd, uint portnum, byte val) struct timeval now; int msec = 0; - if(!dtmf_detection) + if (!dtmf_detection) return; - if(!SPAN_REGISTERED(xpd)) + if (!SPAN_REGISTERED(xpd)) return; priv = xpd->priv; val &= 0xF; digit = dtmf_digits[val]; want_mute = IS_SET(priv->want_dtmf_mute, portnum); want_event = IS_SET(priv->want_dtmf_events, portnum); - if(!IS_SET(priv->prev_key_down, portnum) && !key_down) { + if (!IS_SET(priv->prev_key_down, portnum) && !key_down) { LINE_NOTICE(xpd, portnum, "DTMF: duplicate UP (%c)\n", digit); } - if(key_down) + if (key_down) 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) + if (priv->prev_key_time[portnum].tv_sec != 0) msec = usec_diff(&now, &priv->prev_key_time[portnum]) / 1000; priv->prev_key_time[portnum] = now; LINE_DBG(SIGNAL, xpd, portnum, @@ -1373,11 +1373,11 @@ static void process_dtmf(xpd_t *xpd, uint portnum, byte val) * we are sure about the logic in Asterisk native bridging. * Meanwhile, simply mute it on button press. */ - if(key_down && want_mute) + if (key_down && want_mute) __do_mute_dtmf(xpd, portnum, 1); else __do_mute_dtmf(xpd, portnum, 0); - if(want_event) { + if (want_event) { int event = (key_down) ? DAHDI_EVENT_DTMFDOWN : DAHDI_EVENT_DTMFUP; dahdi_qevent_lock(XPD_CHAN(xpd, portnum), event | digit); @@ -1399,7 +1399,7 @@ static int FXS_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) XPD_DBG(REGS, xpd, "%s reg_num=0x%X, dataL=0x%X dataH=0x%X\n", (indirect)?"I":"D", regnum, REG_FIELD(info, data_low), REG_FIELD(info, data_high)); - if(!indirect && regnum == REG_DTMF_DECODE) { + if (!indirect && regnum == REG_DTMF_DECODE) { byte val = REG_FIELD(info, data_low); process_dtmf(xpd, info->portnum, val); @@ -1412,7 +1412,7 @@ static int FXS_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) process_digital_inputs(xpd, info); } #endif - else if(!indirect && regnum == REG_LOOPCLOSURE) { /* OFFHOOK ? */ + else if (!indirect && regnum == REG_LOOPCLOSURE) { /* OFFHOOK ? */ byte val = REG_FIELD(info, data_low); xpp_line_t mask = BIT(info->portnum); xpp_line_t offhook; @@ -1421,7 +1421,7 @@ static int FXS_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) * Validate reply. Non-existing/disabled ports * will reply with 0xFF. Ignore these. */ - if((val & REG_LOOPCLOSURE_ZERO) == 0) { + if ((val & REG_LOOPCLOSURE_ZERO) == 0) { offhook = (val & REG_LOOPCLOSURE_LCR) ? mask : 0; LINE_DBG(SIGNAL, xpd, info->portnum, "REG_LOOPCLOSURE: dataL=0x%X (offhook=0x%X mask=0x%X\n", @@ -1436,7 +1436,7 @@ static int FXS_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) #endif } /* Update /proc info only if reply relate to the last slic read request */ - if( + if ( REG_FIELD(&xpd->requested_reply, regnum) == REG_FIELD(info, regnum) && REG_FIELD(&xpd->requested_reply, do_subreg) == REG_FIELD(info, do_subreg) && REG_FIELD(&xpd->requested_reply, subreg) == REG_FIELD(info, subreg)) { @@ -1518,7 +1518,7 @@ static int proc_fxs_info_read(char *page, char **start, off_t off, int count, in int i; int led; - if(!xpd) + if (!xpd) return -ENODEV; spin_lock_irqsave(&xpd->lock, flags); priv = xpd->priv; @@ -1534,9 +1534,9 @@ static int proc_fxs_info_read(char *page, char **start, off_t off, int count, in for_each_line(xpd, i) { char pref; - if(IS_SET(PHONEDEV(xpd).digital_outputs, i)) + if (IS_SET(PHONEDEV(xpd).digital_outputs, i)) pref = 'O'; - else if(IS_SET(PHONEDEV(xpd).digital_inputs, i)) + else if (IS_SET(PHONEDEV(xpd).digital_inputs, i)) pref = 'I'; else pref = ' '; @@ -1551,21 +1551,21 @@ static int proc_fxs_info_read(char *page, char **start, off_t off, int count, in ); } len += sprintf(page + len, "\n"); - for(led = 0; led < NUM_LEDS; led++) { + for (led = 0; led < NUM_LEDS; led++) { len += sprintf(page + len, "LED #%d", led); len += sprintf(page + len, "\n\t%-17s: ", "ledstate"); for_each_line(xpd, i) { - if(!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) len += sprintf(page + len, "%d ", IS_SET(priv->ledstate[led], i)); } len += sprintf(page + len, "\n\t%-17s: ", "ledcontrol"); for_each_line(xpd, i) { - if(!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) len += sprintf(page + len, "%d ", IS_SET(priv->ledcontrol[led], i)); } len += sprintf(page + len, "\n\t%-17s: ", "led_counter"); for_each_line(xpd, i) { - if(!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (!IS_SET(PHONEDEV(xpd).digital_outputs, i) && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) len += sprintf(page + len, "%d ", LED_COUNTER(priv,i,led)); } len += sprintf(page + len, "\n"); @@ -1592,26 +1592,26 @@ static int proc_xpd_metering_write(struct file *file, const char __user *buffer, int num; int ret; - if(!xpd) + if (!xpd) return -ENODEV; - if(count >= MAX_PROC_WRITE - 1) { + if (count >= MAX_PROC_WRITE - 1) { XPD_ERR(xpd, "Metering string too long (%lu)\n", count); return -EINVAL; } - if(copy_from_user(&buf, buffer, count)) + if (copy_from_user(&buf, buffer, count)) return -EFAULT; buf[count] = '\0'; ret = sscanf(buf, "%d", &num); - if(ret != 1) { + if (ret != 1) { XPD_ERR(xpd, "Metering value should be number. Got '%s'\n", buf); return -EINVAL; } chan = num; - if(chan != PORT_BROADCAST && chan > xpd->channels) { + if (chan != PORT_BROADCAST && chan > xpd->channels) { XPD_ERR(xpd, "Metering tone: bad channel number %d\n", chan); return -EINVAL; } - if((ret = metering_gen(xpd, chan, 1)) < 0) { + if ((ret = metering_gen(xpd, chan, 1)) < 0) { XPD_ERR(xpd, "Failed sending metering tone\n"); return ret; } @@ -1625,7 +1625,7 @@ static int fxs_xpd_probe(struct device *dev) xpd = dev_to_xpd(dev); /* Is it our device? */ - if(xpd->type != XPD_TYPE_FXS) { + if (xpd->type != XPD_TYPE_FXS) { XPD_ERR(xpd, "drop suggestion for %s (%d)\n", dev_name(dev), xpd->type); return -EINVAL; @@ -1659,7 +1659,7 @@ static int __init card_fxs_startup(void) { int ret; - if((ret = xpd_driver_register(&fxs_driver.driver)) < 0) + if ((ret = xpd_driver_register(&fxs_driver.driver)) < 0) return ret; INFO("revision %s\n", XPP_VERSION); diff --git a/drivers/dahdi/xpp/card_global.c b/drivers/dahdi/xpp/card_global.c index 51edd7d..fc5b61d 100644 --- a/drivers/dahdi/xpp/card_global.c +++ b/drivers/dahdi/xpp/card_global.c @@ -76,7 +76,7 @@ static int parse_hexbyte(const char *buf) unsigned val; val = simple_strtoul(buf, &endp, 16); - if(*endp != '\0' || val > 0xFF) + if (*endp != '\0' || val > 0xFF) return -EBADR; return (byte)val; } @@ -98,7 +98,7 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) int ret = -EBADR; num_args = 2; /* port + operation */ - if(argc < num_args) { + if (argc < num_args) { XPD_ERR(xpd, "Not enough arguments (%d)\n", argc); XPD_ERR(xpd, "Any Command is composed of at least %d words (got only %d)\n", @@ -107,24 +107,24 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) } /* Process the arguments */ argno = 0; - if(strcmp(argv[argno], "*") == 0) { + if (strcmp(argv[argno], "*") == 0) { portno = PORT_BROADCAST; //XPD_DBG(REGS, xpd, "Port broadcast\n"); } else { portno = parse_hexbyte(argv[argno]); - if(portno < 0 || portno >= 8) { + if (portno < 0 || portno >= 8) { XPD_ERR(xpd, "Illegal port number '%s'\n", argv[argno]); goto out; } //XPD_DBG(REGS, xpd, "Port is %d\n", portno); } argno++; - if(strlen(argv[argno]) != 2) { + if (strlen(argv[argno]) != 2) { XPD_ERR(xpd, "Wrong operation codes '%s'\n", argv[argno]); goto out; } op = argv[argno][0]; - switch(op) { + switch (op) { case 'W': writing = 1; num_args++; /* data low */ @@ -139,7 +139,7 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) goto out; } addr_mode = argv[argno][1]; - switch(addr_mode) { + switch (addr_mode) { case 'I': XPD_NOTICE(xpd, "'I' is deprecated in register commands. Use 'S' instead.\n"); /* fall through */ @@ -155,7 +155,7 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) break; case 'M': case 'm': - if(op != 'W') { + if (op != 'W') { XPD_ERR(xpd, "Can use Multibyte (%c) only with op 'W'\n", addr_mode); goto out; @@ -167,19 +167,19 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) XPD_ERR(xpd, "Unknown addressing type '%c'\n", addr_mode); goto out; } - if(argv[argno][2] != '\0') { + if (argv[argno][2] != '\0') { XPD_ERR(xpd, "Bad operation field '%s'\n", argv[argno]); goto out; } - if(argc < num_args) { + if (argc < num_args) { XPD_ERR(xpd, "Command \"%s\" is composed of at least %d words (got only %d)\n", argv[argno], num_args, argc); goto out; } argno++; - if(addr_mode == 'M' || addr_mode == 'm') { - if(argno < argc) { + if (addr_mode == 'M' || addr_mode == 'm') { + if (argno < argc) { XPD_ERR(xpd, "Magic-Multibyte(%c) with %d extra arguments\n", addr_mode, argc - argno); @@ -191,24 +191,24 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) } /* Normal (non-Magic) register commands */ do_datah = 0; - if(argno >= argc) { + if (argno >= argc) { XPD_ERR(xpd, "Missing register number\n"); goto out; } regnum = parse_hexbyte(argv[argno]); - if(regnum < 0) { + if (regnum < 0) { XPD_ERR(xpd, "Illegal register number '%s'\n", argv[argno]); goto out; } //XPD_DBG(REGS, xpd, "Register is %X\n", regnum); argno++; - if(do_subreg) { - if(argno >= argc) { + if (do_subreg) { + if (argno >= argc) { XPD_ERR(xpd, "Missing subregister number\n"); goto out; } subreg = parse_hexbyte(argv[argno]); - if(subreg < 0) { + if (subreg < 0) { XPD_ERR(xpd, "Illegal subregister number '%s'\n", argv[argno]); goto out; } @@ -216,13 +216,13 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) argno++; } else subreg = 0; - if(writing) { - if(argno >= argc) { + if (writing) { + if (argno >= argc) { XPD_ERR(xpd, "Missing data low number\n"); goto out; } data_low = parse_hexbyte(argv[argno]); - if(data_low < 0) { + if (data_low < 0) { XPD_ERR(xpd, "Illegal data_low number '%s'\n", argv[argno]); goto out; } @@ -230,14 +230,14 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) argno++; } else data_low = 0; - if(argno < argc) { + if (argno < argc) { do_datah = 1; - if(!argv[argno]) { + if (!argv[argno]) { XPD_ERR(xpd, "Missing data high number\n"); goto out; } data_high = parse_hexbyte(argv[argno]); - if(data_high < 0) { + if (data_high < 0) { XPD_ERR(xpd, "Illegal data_high number '%s'\n", argv[argno]); goto out; } @@ -245,7 +245,7 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[]) argno++; } else data_high = 0; - if(argno < argc) { + if (argno < argc) { XPD_ERR(xpd, "Command contains an extra %d argument\n", argc - argno); @@ -284,22 +284,22 @@ int parse_chip_command(xpd_t *xpd, char *cmdline) BUG_ON(!xpd); xbus = xpd->xbus; - if(!XBUS_FLAGS(xbus, CONNECTED)) { + if (!XBUS_FLAGS(xbus, CONNECTED)) { XBUS_DBG(GENERAL, xbus, "Dropped packet. Disconnected.\n"); return -EBUSY; } strlcpy(buf, cmdline, MAX_PROC_WRITE); /* Save a copy */ - if(buf[0] == '#' || buf[0] == ';') + if (buf[0] == '#' || buf[0] == ';') XPD_DBG(REGS, xpd, "Note: '%s'\n", buf); - if((p = strchr(buf, '#')) != NULL) /* Truncate comments */ + if ((p = strchr(buf, '#')) != NULL) /* Truncate comments */ *p = '\0'; - if((p = strchr(buf, ';')) != NULL) /* Truncate comments */ + if ((p = strchr(buf, ';')) != NULL) /* Truncate comments */ *p = '\0'; - for(p = buf; *p && (*p == ' ' || *p == '\t'); p++) /* Trim leading whitespace */ + for (p = buf; *p && (*p == ' ' || *p == '\t'); p++) /* Trim leading whitespace */ ; str = p; - for(i = 0; (p = strsep(&str, " \t")) != NULL && i < MAX_ARGS; ) { - if(*p != '\0') { + for (i = 0; (p = strsep(&str, " \t")) != NULL && i < MAX_ARGS; ) { + if (*p != '\0') { argv[i] = p; // XPD_DBG(REGS, xpd, "ARG %d = '%s'\n", i, p); i++; @@ -307,11 +307,11 @@ int parse_chip_command(xpd_t *xpd, char *cmdline) } argv[i] = NULL; argc = i; - if(p) { + if (p) { XPD_ERR(xpd, "Too many words (%d) to process. Last was '%s'\n", i, p); goto out; } - if(argc) + if (argc) ret = execute_chip_command(xpd, argc, argv); else ret = 0; /* empty command - no op */ @@ -332,7 +332,7 @@ static void global_packet_dump(const char *msg, xpacket_t *pack); xframe_t *xframe; xpacket_t *pack; - if(!xbus) { + if (!xbus) { DBG(DEVICES, "NO XBUS\n"); return -EINVAL; } @@ -342,7 +342,7 @@ static void global_packet_dump(const char *msg, xpacket_t *pack); RPACKET_FIELD(pack, GLOBAL, AB_REQUEST, rev) = XPP_PROTOCOL_VERSION; RPACKET_FIELD(pack, GLOBAL, AB_REQUEST, reserved) = 0; XBUS_DBG(DEVICES, xbus, "Protocol Version %d\n", XPP_PROTOCOL_VERSION); - if(xbus_setstate(xbus, XBUS_STATE_SENT_REQUEST)) + if (xbus_setstate(xbus, XBUS_STATE_SENT_REQUEST)) ret = send_cmd_frame(xbus, xframe); return ret; } @@ -356,7 +356,7 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno, xpacket_t *pack; reg_cmd_t *reg_cmd; - if(!xbus) { + if (!xbus) { DBG(REGS, "NO XBUS\n"); return -EINVAL; } @@ -368,7 +368,7 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno, reg_cmd = &RPACKET_FIELD(pack, GLOBAL, REGISTER_REQUEST, reg_cmd); reg_cmd->bytes = sizeof(*reg_cmd) - 1; // do not count the 'bytes' field reg_cmd->is_multibyte = 0; - if(portno == PORT_BROADCAST) { + if (portno == PORT_BROADCAST) { reg_cmd->portnum = 0; REG_FIELD(reg_cmd, all_ports_broadcast) = 1; } else { @@ -384,14 +384,14 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno, REG_FIELD(reg_cmd, do_datah) = do_datah; REG_FIELD(reg_cmd, data_low) = data_low; REG_FIELD(reg_cmd, data_high) = data_high; - if(should_reply) + if (should_reply) xpd->requested_reply = *reg_cmd; - if(debug & DBG_REGS) { + if (debug & DBG_REGS) { dump_reg_cmd("REG_REQ", 1, xbus, xpd->addr.unit, reg_cmd->portnum, reg_cmd); dump_packet("REG_REQ", pack, 1); } - if(!xframe->usec_towait) { /* default processing time of SPI */ - if(subreg) + if (!xframe->usec_towait) { /* default processing time of SPI */ + if (subreg) xframe->usec_towait = 2000; else xframe->usec_towait = 1000; @@ -410,7 +410,7 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno, const char *mode_name; BUG_ON(!xbus); - if((mode_name = sync_mode_name(mode)) == NULL) { + if ((mode_name = sync_mode_name(mode)) == NULL) { XBUS_ERR(xbus, "SYNC_SOURCE: bad sync_mode=0x%X\n", mode); return -EINVAL; } @@ -460,25 +460,25 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION) /* 0x08 */ units = RPACKET_FIELD(pack, GLOBAL, AB_DESCRIPTION, unit_descriptor); count_units = XPACKET_LEN(pack) - ((byte *)units - (byte *)pack); count_units /= sizeof(*units); - if(rev != XPP_PROTOCOL_VERSION) { + if (rev != XPP_PROTOCOL_VERSION) { XBUS_NOTICE(xbus, "Bad protocol version %d (should be %d)\n", rev, XPP_PROTOCOL_VERSION); ret = -EPROTO; goto proto_err; } - if(count_units > NUM_UNITS) { + if (count_units > NUM_UNITS) { XBUS_NOTICE(xbus, "Too many units %d (should be %d)\n", count_units, NUM_UNITS); ret = -EPROTO; goto proto_err; } - if(count_units <= 0) { + if (count_units <= 0) { XBUS_NOTICE(xbus, "Empty astribank? (%d units)\n", count_units); ret = -EPROTO; goto proto_err; } - if(!xbus_setstate(xbus, XBUS_STATE_RECVD_DESC)) { + if (!xbus_setstate(xbus, XBUS_STATE_RECVD_DESC)) { ret = -EPROTO; goto proto_err; } @@ -492,12 +492,12 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION) /* 0x08 */ ret = -ENODEV; goto out; } - for(i = 0; i < count_units; i++) { + for (i = 0; i < count_units; i++) { struct unit_descriptor *this_unit = &units[i]; struct card_desc_struct *card_desc; unsigned long flags; - if((card_desc = KZALLOC(sizeof(struct card_desc_struct), GFP_ATOMIC)) == NULL) { + if ((card_desc = KZALLOC(sizeof(struct card_desc_struct), GFP_ATOMIC)) == NULL) { XBUS_ERR(xbus, "Card description allocation failed.\n"); ret = -ENOMEM; goto out; @@ -541,14 +541,14 @@ HANDLER_DEF(GLOBAL, REGISTER_REPLY) { reg_cmd_t *reg = &RPACKET_FIELD(pack, GLOBAL, REGISTER_REPLY, regcmd); - if(!xpd) { + if (!xpd) { static int rate_limit; - if((rate_limit++ % 1003) < 5) + if ((rate_limit++ % 1003) < 5) notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), ""); return -EPROTO; } - if(debug & DBG_REGS) { + if (debug & DBG_REGS) { dump_reg_cmd("REG_REPLY", 0, xbus, xpd->addr.unit, reg->portnum, reg); dump_packet("REG_REPLY", pack, 1); } @@ -566,7 +566,7 @@ HANDLER_DEF(GLOBAL, SYNC_REPLY) const char *mode_name; BUG_ON(!xbus); - if((mode_name = sync_mode_name(mode)) == NULL) { + if ((mode_name = sync_mode_name(mode)) == NULL) { XBUS_ERR(xbus, "SYNC_REPLY: bad sync_mode=0x%X\n", mode); return -EINVAL; } @@ -586,11 +586,11 @@ HANDLER_DEF(GLOBAL, ERROR_CODE) byte errorbits; BUG_ON(!xbus); - if((rate_limit++ % 5003) > 200) + if ((rate_limit++ % 5003) > 200) return 0; category_code = RPACKET_FIELD(pack, GLOBAL, ERROR_CODE, category_code); errorbits = RPACKET_FIELD(pack, GLOBAL, ERROR_CODE, errorbits); - if(!xpd) { + if (!xpd) { snprintf(tmp_name, TMP_NAME_LEN, "%s(%1d%1d)", xbus->busname, XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack)); } else { @@ -673,20 +673,20 @@ int run_initialize_registers(xpd_t *xpd) BUG_ON(!xpd); xbus = xpd->xbus; - if(!initdir || !initdir[0]) { + if (!initdir || !initdir[0]) { XPD_NOTICE(xpd, "Missing initdir parameter\n"); ret = -EINVAL; goto err; } - if(!xpd_setstate(xpd, XPD_STATE_INIT_REGS)) { + if (!xpd_setstate(xpd, XPD_STATE_INIT_REGS)) { ret = -EINVAL; goto err; } direction_mask = 0; - for(i = 0; i < xpd->subunits; i++) { + for (i = 0; i < xpd->subunits; i++) { xpd_t *su = xpd_byaddr(xbus, xpd->addr.unit, i); - if(!su) { + if (!su) { XPD_ERR(xpd, "Have %d subunits, but not subunit #%d\n", xpd->subunits, i); @@ -704,13 +704,13 @@ int run_initialize_registers(xpd_t *xpd) snprintf(revstr, MAX_ENV_STR, "XBUS_REVISION=%d", xbus->revision); snprintf(connectorstr, MAX_ENV_STR, "XBUS_CONNECTOR=%s", xbus->connector); snprintf(xbuslabel, MAX_ENV_STR, "XBUS_LABEL=%s", xbus->label); - if(snprintf(init_card, MAX_PATH_STR, "%s/init_card_%d_%d", + if (snprintf(init_card, MAX_PATH_STR, "%s/init_card_%d_%d", initdir, xpd->type, xbus->revision) > MAX_PATH_STR) { XPD_NOTICE(xpd, "Cannot initialize. pathname is longer than %d characters.\n", MAX_PATH_STR); ret = -E2BIG; goto err; } - if(!XBUS_IS(xbus, RECVD_DESC)) { + if (!XBUS_IS(xbus, RECVD_DESC)) { XBUS_ERR(xbus, "Skipped register initialization. In state %s.\n", xbus_statename(XBUS_STATE(xbus))); ret = -ENODEV; @@ -722,15 +722,15 @@ int run_initialize_registers(xpd_t *xpd) /* * Carefully report results */ - if(ret == 0) + if (ret == 0) XPD_DBG(DEVICES, xpd, "'%s' finished OK\n", init_card); - else if(ret < 0) { + else if (ret < 0) { XPD_ERR(xpd, "Failed running '%s' (errno %d)\n", init_card, ret); } else { byte exitval = ((unsigned)ret >> 8) & 0xFF; byte sigval = ret & 0xFF; - if(!exitval) { + if (!exitval) { XPD_ERR(xpd, "'%s' killed by signal %d\n", init_card, sigval); } else { XPD_ERR(xpd, "'%s' aborted with exitval %d\n", init_card, exitval); diff --git a/drivers/dahdi/xpp/card_pri.c b/drivers/dahdi/xpp/card_pri.c index 286c348..e2d6f72 100644 --- a/drivers/dahdi/xpp/card_pri.c +++ b/drivers/dahdi/xpp/card_pri.c @@ -57,11 +57,11 @@ static DEF_PARM(uint, poll_interval, 500, 0644, "Poll channel state interval in static bool is_sigtype_dchan(int sigtype) { - if((sigtype & DAHDI_SIG_HDLCRAW) == DAHDI_SIG_HDLCRAW) + if ((sigtype & DAHDI_SIG_HDLCRAW) == DAHDI_SIG_HDLCRAW) return 1; - if((sigtype & DAHDI_SIG_HDLCFCS) == DAHDI_SIG_HDLCFCS) + if ((sigtype & DAHDI_SIG_HDLCFCS) == DAHDI_SIG_HDLCFCS) return 1; - if((sigtype & DAHDI_SIG_HARDHDLC) == DAHDI_SIG_HARDHDLC) + if ((sigtype & DAHDI_SIG_HARDHDLC) == DAHDI_SIG_HARDHDLC) return 1; return 0; } @@ -331,7 +331,7 @@ struct PRI_priv_data { #define NO_DCHAN (0) #define DCHAN(p) ((p)->chanconfig_dchan) #define VALID_DCHAN(p) (DCHAN(p) != NO_DCHAN) -#define SET_DCHAN(p,d) do { DCHAN(p) = (d); } while(0); +#define SET_DCHAN(p,d) do { DCHAN(p) = (d); } while (0); byte cas_rs_e[NUM_CAS_RS_E]; byte cas_ts_e[NUM_CAS_RS_E]; @@ -503,7 +503,7 @@ static bool valid_pri_modes(const xpd_t *xpd) BUG_ON(!xpd); priv = xpd->priv; - if( + if ( priv->pri_protocol != PRI_PROTO_E1 && priv->pri_protocol != PRI_PROTO_T1 && priv->pri_protocol != PRI_PROTO_J1) @@ -529,8 +529,8 @@ static void PRI_card_pcm_recompute(xpd_t *xpd, for_each_line(xpd, i) if (IS_SET(pcm_mask, i)) line_count++; - if(priv->is_cas) { - if(priv->pri_protocol == PRI_PROTO_E1) { + if (priv->is_cas) { + if (priv->pri_protocol == PRI_PROTO_E1) { /* CAS: Don't send PCM to D-Channel */ line_count--; pcm_mask &= ~BIT(PRI_DCHAN_IDX(priv)); @@ -574,8 +574,8 @@ static int set_pri_proto(xpd_t *xpd, enum pri_protocol set_proto) __func__, phonedev->span.name, phonedev->span.spanno); return -EBUSY; } - if(priv->pri_protocol != PRI_PROTO_0) { - if(priv->pri_protocol == set_proto) { + if (priv->pri_protocol != PRI_PROTO_0) { + if (priv->pri_protocol == set_proto) { XPD_NOTICE(xpd, "Already in protocol %s. Ignored\n", pri_protocol_name(set_proto)); return 0; } else { @@ -584,7 +584,7 @@ static int set_pri_proto(xpd_t *xpd, enum pri_protocol set_proto) pri_protocol_name(set_proto)); } } - switch(set_proto) { + switch (set_proto) { case PRI_PROTO_E1: deflaw = DAHDI_LAW_ALAW; dchan_num = 16; @@ -629,7 +629,7 @@ static int set_pri_proto(xpd_t *xpd, enum pri_protocol set_proto) * give reliable results. */ ret = pri_lineconfig(xpd, default_lineconfig); - if(ret) { + if (ret) { XPD_NOTICE(xpd, "Failed setting PRI default line config\n"); return ret; } @@ -643,24 +643,24 @@ static void dahdi_update_syncsrc(xpd_t *xpd) int best_spanno = 0; int i; - if(!SPAN_REGISTERED(xpd)) + if (!SPAN_REGISTERED(xpd)) return; - for(i = 0; i < MAX_SLAVES; i++) { + for (i = 0; i < MAX_SLAVES; i++) { subxpd = xpd_byaddr(xpd->xbus, xpd->addr.unit, i); - if(!subxpd) + if (!subxpd) continue; priv = subxpd->priv; - if(priv->clock_source && priv->alarms == 0) { - if(best_spanno) + if (priv->clock_source && priv->alarms == 0) { + if (best_spanno) XPD_ERR(xpd, "Duplicate XPD's with clock_source=1\n"); best_spanno = PHONEDEV(subxpd).span.spanno; } } - for(i = 0; i < MAX_SLAVES; i++) { + for (i = 0; i < MAX_SLAVES; i++) { subxpd = xpd_byaddr(xpd->xbus, xpd->addr.unit, i); - if(!subxpd) + if (!subxpd) continue; - if(PHONEDEV(subxpd).span.syncsrc == best_spanno) + if (PHONEDEV(subxpd).span.syncsrc == best_spanno) XPD_DBG(SYNC, xpd, "Setting SyncSource to span %d\n", best_spanno); else XPD_DBG(SYNC, xpd, "Slaving to span %d\n", best_spanno); @@ -685,27 +685,27 @@ static void set_clocking(xpd_t *xpd) xbus = xpd->xbus; /* Find subunit with best timing priority */ - for(i = 0; i < MAX_SLAVES; i++) { + for (i = 0; i < MAX_SLAVES; i++) { struct PRI_priv_data *priv; xpd_t *subxpd; subxpd = xpd_byaddr(xbus, xpd->addr.unit, i); - if(!subxpd) + if (!subxpd) continue; priv = subxpd->priv; - if(priv->alarms != 0) + if (priv->alarms != 0) continue; - if(PHONEDEV(subxpd).timing_priority > 0 && PHONEDEV(subxpd).timing_priority < best_subunit_prio) { + if (PHONEDEV(subxpd).timing_priority > 0 && PHONEDEV(subxpd).timing_priority < best_subunit_prio) { best_xpd = subxpd; best_subunit = i; best_subunit_prio = PHONEDEV(subxpd).timing_priority; } } /* Now set it */ - if(best_xpd && ((struct PRI_priv_data *)(best_xpd->priv))->clock_source == 0) { + if (best_xpd && ((struct PRI_priv_data *)(best_xpd->priv))->clock_source == 0) { byte reg_pc_init[] = { VAL_PC_GPI, VAL_PC_GPI, VAL_PC_GPI }; - for(i = 0; i < ARRAY_SIZE(reg_pc_init); i++) { + for (i = 0; i < ARRAY_SIZE(reg_pc_init); i++) { byte reg_pc = reg_pc_init[i]; reg_pc |= (best_subunit & (1 << i)) ? VAL_PC_GPOH : VAL_PC_GPOL; @@ -716,12 +716,12 @@ static void set_clocking(xpd_t *xpd) ((struct PRI_priv_data *)(best_xpd->priv))->clock_source = 1; } /* clear old clock sources */ - for(i = 0; i < MAX_SLAVES; i++) { + for (i = 0; i < MAX_SLAVES; i++) { struct PRI_priv_data *priv; xpd_t *subxpd; subxpd = xpd_byaddr(xbus, xpd->addr.unit, i); - if(subxpd && subxpd != best_xpd) { + if (subxpd && subxpd != best_xpd) { XPD_DBG(SYNC, subxpd, "Clearing clock source\n"); priv = subxpd->priv; priv->clock_source = 0; @@ -743,7 +743,7 @@ static void set_reg_lim0(const char *msg, xpd_t *xpd) is_master_mode = PHONEDEV(xpd).timing_priority == 0; localloop = priv->local_loopback; lim0 |= (localloop) ? REG_LIM0_LL : 0; - if(is_master_mode) + if (is_master_mode) lim0 |= REG_LIM0_MAS; else lim0 &= ~REG_LIM0_MAS; @@ -775,7 +775,7 @@ static int set_localloop(xpd_t *xpd, bool localloop) BUG_ON(!xpd); priv = xpd->priv; - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { XPD_NOTICE(xpd, "Registered as span %d. Cannot do %s\n", PHONEDEV(xpd).span.spanno, __func__); return -EBUSY; @@ -822,7 +822,7 @@ static void set_rbslines(xpd_t *xpd, int channo) for_each_line(xpd, i) { struct dahdi_chan *chan = XPD_CHAN(xpd, i); - if(chan->flags & DAHDI_FLAG_CLEAR) + if (chan->flags & DAHDI_FLAG_CLEAR) BIT_CLR(new_rbslines, i); else BIT_SET(new_rbslines, i); @@ -831,7 +831,7 @@ static void set_rbslines(xpd_t *xpd, int channo) modified_lines = priv->rbslines ^ new_rbslines; XPD_DBG(DEVICES, xpd, "RBSLINES-%d(%s): 0x%X\n", channo, pri_protocol_name(priv->pri_protocol), new_rbslines); - if((priv->pri_protocol == PRI_PROTO_T1) || (priv->pri_protocol == PRI_PROTO_J1)) { + if ((priv->pri_protocol == PRI_PROTO_T1) || (priv->pri_protocol == PRI_PROTO_J1)) { byte clear_lines = 0; /* Mark clear lines */ bool reg_changed = 0; @@ -839,13 +839,13 @@ static void set_rbslines(xpd_t *xpd, int channo) int bytenum = i / 8; int bitnum = i % 8; - if(!IS_SET(new_rbslines, i)) { + if (!IS_SET(new_rbslines, i)) { BIT_SET(clear_lines, (7 - bitnum)); } - if(IS_SET(modified_lines, i)) + if (IS_SET(modified_lines, i)) reg_changed = 1; - if(bitnum == 7) { - if(channo == 0 || reg_changed) { + if (bitnum == 7) { + if (channo == 0 || reg_changed) { bytenum += REG_CCB1_T; XPD_DBG(DEVICES, xpd, "RBS(%s): modified=0x%X rbslines=0x%X reg=0x%X clear_lines=0x%X\n", pri_protocol_name(priv->pri_protocol), @@ -866,7 +866,7 @@ static int set_mode_cas(xpd_t *xpd, bool want_cas) priv = xpd->priv; XPD_INFO(xpd, "Setting TDM to %s\n", (want_cas) ? "CAS" : "PRI"); - if(want_cas) { + if (want_cas) { priv->is_cas = 1; priv->dchan_alive = 0; } else { @@ -902,11 +902,11 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig) */ bad_bits = lineconfig & pri_linecompat(priv->pri_protocol); bad_bits = bad_bits ^ lineconfig; - for(i = 0; i < ARRAY_SIZE(valid_spanconfigs); i++) { + for (i = 0; i < ARRAY_SIZE(valid_spanconfigs); i++) { unsigned int flags = valid_spanconfigs[i].flags; - if(bad_bits & BIT(i)) { - if(flags) { + if (bad_bits & BIT(i)) { + if (flags) { XPD_ERR(xpd, "Bad config item '%s' for %s. Ignore\n", valid_spanconfigs[i].name, @@ -919,26 +919,26 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig) pri_protocol_name(priv->pri_protocol)); } } - if(flags && flags != BIT(i)) { + if (flags && flags != BIT(i)) { ERR("%s: BUG: i=%d flags=0x%X\n", __func__, i, flags); // BUG(); } } - if(bad_bits) + if (bad_bits) goto bad_lineconfig; - if(priv->pri_protocol == PRI_PROTO_E1) { + if (priv->pri_protocol == PRI_PROTO_E1) { fmr1 |= REG_FMR1_AFR; fmr2 = REG_FMR2_E_AXRA | REG_FMR2_E_ALMF; /* 0x03 */ fmr4 = 0x9F; /* E1.XSW: All spare bits = 1*/ xsp |= REG_XSP_E_EBP | REG_XSP_E_AXS | REG_XSP_E_XSIF; - } else if(priv->pri_protocol == PRI_PROTO_T1) { + } else if (priv->pri_protocol == PRI_PROTO_T1) { fmr1 |= REG_FMR1_PMOD | REG_FMR1_T_CRC; fmr2 = REG_FMR2_T_SSP | REG_FMR2_T_AXRA; /* 0x22 */ fmr4 = 0x0C; xsp &= ~REG_FMR5_T_XTM; force_cas = 1; /* T1 - Chip always in CAS mode */ - } else if(priv->pri_protocol == PRI_PROTO_J1) { + } else if (priv->pri_protocol == PRI_PROTO_J1) { fmr1 |= REG_FMR1_PMOD; fmr4 = 0x1C; xsp &= ~REG_FMR5_T_XTM; @@ -946,7 +946,7 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig) XPD_ERR(xpd, "J1 unsupported yet\n"); return -ENOSYS; } - if(priv->local_loopback) + if (priv->local_loopback) fmr2 |= REG_FMR2_E_PLB; /* framing first */ if (lineconfig & DAHDI_CONFIG_B8ZS) { @@ -967,7 +967,7 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig) * configure the Rx side to B8ZS coding" * For both cases this is the same bit in FMR0 */ - if(priv->pri_protocol == PRI_PROTO_J1) + if (priv->pri_protocol == PRI_PROTO_J1) XPD_NOTICE(xpd, "J1 is not supported yet\n"); else fmr0 |= REG_FMR0_E_RC0; @@ -1021,20 +1021,20 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig) write_subunit(xpd, REG_FMR0, fmr0); XPD_DBG(GENERAL, xpd, "%s: fmr4(0x%02X) = 0x%02X\n", __func__, REG_FMR4, fmr4); write_subunit(xpd, REG_FMR4, fmr4); - if(fmr3) { + if (fmr3) { XPD_DBG(GENERAL, xpd, "%s: fmr3(0x%02X) = 0x%02X\n", __func__, REG_FMR3, fmr3); write_subunit(xpd, REG_FMR3, fmr3); } XPD_DBG(GENERAL, xpd, "%s: cmdr(0x%02X) = 0x%02X\n", __func__, REG_CMDR_E, cmdr); write_subunit(xpd, REG_CMDR_E, cmdr); #ifdef JAPANEZE_SUPPORT - if(rc0) { + if (rc0) { XPD_DBG(GENERAL, xpd, "%s: rc0(0x%02X) = 0x%02X\n", __func__, REG_RC0, rc0); write_subunit(xpd, REG_RC0, rc0); } #endif - if(force_cas) { - if(priv->pri_protocol == PRI_PROTO_E1) { + if (force_cas) { + if (priv->pri_protocol == PRI_PROTO_E1) { int rs1 = 0x0B; /* @@ -1080,7 +1080,7 @@ static int pri_spanconfig(struct file *file, struct dahdi_span *span, BUG_ON(!xpd); priv = xpd->priv; - if(lc->span != PHONEDEV(xpd).span.spanno) { + if (lc->span != PHONEDEV(xpd).span.spanno) { XPD_ERR(xpd, "I am span %d but got spanconfig for span %d\n", PHONEDEV(xpd).span.spanno, lc->span); return -EINVAL; @@ -1092,7 +1092,7 @@ static int pri_spanconfig(struct file *file, struct dahdi_span *span, XPD_DBG(GENERAL, xpd, "[%s] lbo=%d lineconfig=0x%X sync=%d\n", (priv->clock_source)?"MASTER":"SLAVE", lc->lbo, lc->lineconfig, lc->sync); ret = pri_lineconfig(xpd, lc->lineconfig); - if(!ret) { + if (!ret) { span->lineconfig = lc->lineconfig; PHONEDEV(xpd).timing_priority = lc->sync; set_master_mode("spanconfig", xpd); @@ -1121,7 +1121,7 @@ static int pri_chanconfig(struct file *file, struct dahdi_chan *chan, * FIXME: actually use this to prevent duplicate DChan definitions * and prevent DChan definitions with CAS. */ - if(is_sigtype_dchan(sigtype)) { + if (is_sigtype_dchan(sigtype)) { if (VALID_DCHAN(priv) && DCHAN(priv) != chan->channo) { ERR("channel %d (%s) marked DChan but also channel %d.\n", chan->channo, chan->name, DCHAN(priv)); @@ -1130,19 +1130,19 @@ static int pri_chanconfig(struct file *file, struct dahdi_chan *chan, XPD_DBG(GENERAL, xpd, "channel %d (%s) marked as DChan\n", chan->channo, chan->name); SET_DCHAN(priv, chan->channo); /* In T1, we don't know before-hand */ - if(priv->pri_protocol != PRI_PROTO_E1 && priv->is_cas != 0) { + if (priv->pri_protocol != PRI_PROTO_E1 && priv->is_cas != 0) { set_mode_cas(xpd, 0); } } else { - if(chan->channo == 1) { + if (chan->channo == 1) { XPD_DBG(GENERAL, xpd, "channel %d (%s) marked a not DChan\n", chan->channo, chan->name); SET_DCHAN(priv, NO_DCHAN); } /* In T1, we don't know before-hand */ - if(priv->pri_protocol != PRI_PROTO_E1 && priv->is_cas != 1) + if (priv->pri_protocol != PRI_PROTO_E1 && priv->is_cas != 1) set_mode_cas(xpd, 1); } - if(PHONEDEV(xpd).span.flags & DAHDI_FLAG_RUNNING) { + if (PHONEDEV(xpd).span.flags & DAHDI_FLAG_RUNNING) { XPD_DBG(DEVICES, xpd, "Span is RUNNING. Updating rbslines.\n"); set_rbslines(xpd, chan->channo); } @@ -1159,13 +1159,13 @@ static xpd_t *PRI_card_new(xbus_t *xbus, int unit, int subunit, const xproto_tab struct PRI_priv_data *priv; int channels = min(31, CHANNELS_PERXPD); /* worst case */ - if(subunit_ports != 1) { + if (subunit_ports != 1) { XBUS_ERR(xbus, "Bad subunit_ports=%d\n", subunit_ports); return NULL; } XBUS_DBG(GENERAL, xbus, "\n"); xpd = xpd_alloc(xbus, unit, subunit, subtype, subunits, sizeof(struct PRI_priv_data), proto_table, channels); - if(!xpd) + if (!xpd) return NULL; priv = xpd->priv; priv->pri_protocol = PRI_PROTO_0; /* Default, changes in set_pri_proto() */ @@ -1184,13 +1184,13 @@ static int PRI_card_init(xbus_t *xbus, xpd_t *xpd) XPD_DBG(GENERAL, xpd, "\n"); xpd->type = XPD_TYPE_PRI; priv = xpd->priv; - if(priv->pri_protocol == PRI_PROTO_0) { + if (priv->pri_protocol == PRI_PROTO_0) { /* * init_card_* script didn't set pri protocol * Let's have a default E1 */ ret = set_pri_proto(xpd, PRI_PROTO_E1); - if(ret < 0) + if (ret < 0) goto err; } SET_DCHAN(priv, NO_DCHAN); @@ -1198,7 +1198,7 @@ static int PRI_card_init(xbus_t *xbus, xpd_t *xpd) * initialization script should have set correct * operating modes. */ - if(!valid_pri_modes(xpd)) { + if (!valid_pri_modes(xpd)) { XPD_NOTICE(xpd, "PRI protocol not set\n"); goto err; } @@ -1207,7 +1207,7 @@ static int PRI_card_init(xbus_t *xbus, xpd_t *xpd) XPD_DBG(DEVICES, xpd, "%s\n", xpd->type_name); PHONEDEV(xpd).timing_priority = 1; /* High priority SLAVE */ set_master_mode(__func__, xpd); - for(ret = 0; ret < NUM_LEDS; ret++) { + for (ret = 0; ret < NUM_LEDS; ret++) { DO_LED(xpd, ret, PRI_LED_ON); msleep(20); DO_LED(xpd, ret, PRI_LED_OFF); @@ -1292,7 +1292,7 @@ static int apply_pri_protocol(xpd_t *xpd) cur_chan->chanpos = i + 1; cur_chan->pvt = xpd; cur_chan->sigcap = PRI_SIGCAP; - if(is_dchan && !priv->is_cas) { /* D-CHAN */ + if (is_dchan && !priv->is_cas) { /* D-CHAN */ //FIXME: cur_chan->flags |= DAHDI_FLAG_PRIDCHAN; cur_chan->flags &= ~DAHDI_FLAG_HDLC; } @@ -1318,7 +1318,7 @@ static int PRI_card_dahdi_preregistration(xpd_t *xpd, bool on) pri_protocol_name(priv->pri_protocol), PHONEDEV(xpd).channels, priv->deflaw); - if(!on) { + if (!on) { /* Nothing to do yet */ return 0; } @@ -1344,20 +1344,20 @@ static void dchan_state(xpd_t *xpd, bool up) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(priv->is_cas) { + if (priv->is_cas) { return; } - if(priv->dchan_alive == up) + if (priv->dchan_alive == up) return; - if(!priv->layer1_up) /* No layer1, kill dchan */ + if (!priv->layer1_up) /* No layer1, kill dchan */ up = 0; - if(up) { + if (up) { XPD_DBG(SIGNAL, xpd, "STATE CHANGE: D-Channel RUNNING\n"); priv->dchan_alive = 1; } else { int d = PRI_DCHAN_IDX(priv); - if(SPAN_REGISTERED(xpd) && d >= 0 && d < PHONEDEV(xpd).channels) { + if (SPAN_REGISTERED(xpd) && d >= 0 && d < PHONEDEV(xpd).channels) { byte *pcm; pcm = (byte *)XPD_CHAN(xpd, d)->readchunk; @@ -1391,7 +1391,7 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(PHONEDEV(xpd).timing_priority == 0) { + if (PHONEDEV(xpd).timing_priority == 0) { which_led = TOP_RED_LED; other_led = BOTTOM_GREEN_LED; } else { @@ -1400,10 +1400,10 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) } ledstate = priv->ledstate[which_led]; timer_count = xpd->timer_count; - if(xpd->blink_mode) { - if((timer_count % DEFAULT_LED_PERIOD) == 0) { + if (xpd->blink_mode) { + if ((timer_count % DEFAULT_LED_PERIOD) == 0) { // led state is toggled - if(ledstate == PRI_LED_OFF) { + if (ledstate == PRI_LED_OFF) { DO_LED(xpd, which_led, PRI_LED_ON); DO_LED(xpd, other_led, PRI_LED_ON); } else { @@ -1413,11 +1413,11 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) } return; } - if(priv->ledstate[other_led] != PRI_LED_OFF) + if (priv->ledstate[other_led] != PRI_LED_OFF) DO_LED(xpd, other_led, PRI_LED_OFF); - if(priv->dchan_alive) { + if (priv->dchan_alive) { mod = timer_count % 1000; - switch(mod) { + switch (mod) { case 0: DO_LED(xpd, which_led, PRI_LED_ON); break; @@ -1425,9 +1425,9 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) DO_LED(xpd, which_led, PRI_LED_OFF); break; } - } else if(priv->layer1_up) { + } else if (priv->layer1_up) { mod = timer_count % 1000; - switch(mod) { + switch (mod) { case 0: case 100: DO_LED(xpd, which_led, PRI_LED_ON); @@ -1438,7 +1438,7 @@ static void handle_leds(xbus_t *xbus, xpd_t *xpd) break; } } else { - if(priv->ledstate[which_led] != PRI_LED_ON) + if (priv->ledstate[which_led] != PRI_LED_ON) DO_LED(xpd, which_led, PRI_LED_ON); } } @@ -1450,18 +1450,18 @@ static int PRI_card_tick(xbus_t *xbus, xpd_t *xpd) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(!priv->initialized || !xbus->self_ticking) + if (!priv->initialized || !xbus->self_ticking) return 0; /* * Poll layer1 status (cascade subunits) */ - if(poll_interval != 0 && + if (poll_interval != 0 && ((xpd->timer_count % poll_interval) == 0)) { priv->poll_noreplies++; query_subunit(xpd, REG_FRS0); //query_subunit(xpd, REG_FRS1); } - if(priv->dchan_tx_counter >= 1 && priv->dchan_rx_counter > 1) { + if (priv->dchan_tx_counter >= 1 && priv->dchan_rx_counter > 1) { dchan_state(xpd, 1); priv->dchan_alive_ticks++; } @@ -1474,7 +1474,7 @@ static int PRI_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a struct dahdi_chan *chan; BUG_ON(!xpd); - if(!XBUS_IS(xpd->xbus, READY)) + if (!XBUS_IS(xpd->xbus, READY)) return -ENODEV; chan = XPD_CHAN(xpd, pos); switch (cmd) { @@ -1529,7 +1529,7 @@ static int pri_startup(struct file *file, struct dahdi_span *span) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(!XBUS_IS(xpd->xbus, READY)) { + if (!XBUS_IS(xpd->xbus, READY)) { XPD_DBG(GENERAL, xpd, "Startup called by dahdi. No Hardware. Ignored\n"); return -ENODEV; } @@ -1553,7 +1553,7 @@ static int pri_shutdown(struct dahdi_span *span) BUG_ON(!xpd); priv = xpd->priv; BUG_ON(!priv); - if(!XBUS_IS(xpd->xbus, READY)) { + if (!XBUS_IS(xpd->xbus, READY)) { XPD_DBG(GENERAL, xpd, "Shutdown called by dahdi. No Hardware. Ignored\n"); return -ENODEV; } @@ -1573,13 +1573,13 @@ static int encode_rbsbits_e1(xpd_t *xpd, int pos, int bits) priv = xpd->priv; BUG_ON(!priv); BUG_ON(priv->pri_protocol != PRI_PROTO_E1); - if(pos == 15) + if (pos == 15) return 0; /* Don't write dchan in CAS */ - if(pos < 0 || pos > 31) { + if (pos < 0 || pos > 31) { XPD_NOTICE(xpd, "%s: pos=%d out of range. Ignore\n", __func__, pos); return 0; } - if(pos >= 16) { + if (pos >= 16) { /* Low nibble */ rsnum = pos - 16; val = (priv->cas_ts_e[rsnum] & 0xF0) | (bits & 0x0F); @@ -1608,7 +1608,7 @@ static int encode_rbsbits_t1(xpd_t *xpd, int pos, int bits) priv = xpd->priv; BUG_ON(!priv); BUG_ON(priv->pri_protocol != PRI_PROTO_T1); - if(pos < 0 || pos >= PHONEDEV(xpd).channels) { + if (pos < 0 || pos >= PHONEDEV(xpd).channels) { XPD_ERR(xpd, "%s: Bad pos=%d\n", __func__, pos); return 0; } @@ -1680,7 +1680,7 @@ static int pri_rbsbits(struct dahdi_chan *chan, int bits) pos = chan->chanpos - 1; priv = xpd->priv; BUG_ON(!priv); - if(!priv->is_cas) { + if (!priv->is_cas) { XPD_DBG(SIGNAL, xpd, "RBS: TX: not in CAS mode. Ignore.\n"); return 0; } @@ -1690,14 +1690,14 @@ static int pri_rbsbits(struct dahdi_chan *chan, int bits) sig2str(chan->sig), bits); return 0; } - if(!priv->layer1_up) { + if (!priv->layer1_up) { XPD_DBG(SIGNAL, xpd, "RBS: TX: No layer1 yet. Keep going.\n"); } - if(priv->pri_protocol == PRI_PROTO_E1) { - if(encode_rbsbits_e1(xpd, pos, bits) < 0) + if (priv->pri_protocol == PRI_PROTO_E1) { + if (encode_rbsbits_e1(xpd, pos, bits) < 0) return -EINVAL; - } else if(priv->pri_protocol == PRI_PROTO_T1) { - if(encode_rbsbits_t1(xpd, pos, bits) < 0) + } else if (priv->pri_protocol == PRI_PROTO_T1) { + if (encode_rbsbits_t1(xpd, pos, bits) < 0) return -EINVAL; } else { XPD_NOTICE(xpd, "%s: protocol %s is not supported yet with CAS\n", @@ -1739,33 +1739,33 @@ static void PRI_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) for_each_line(xpd, i) { struct dahdi_chan *chan = XPD_CHAN(xpd, i); - if(priv->pri_protocol == PRI_PROTO_E1) { + if (priv->pri_protocol == PRI_PROTO_E1) { /* In E1 - Only 0'th channel is unused */ - if(i == 0) { + if (i == 0) { physical_chan++; } - } else if(priv->pri_protocol == PRI_PROTO_T1) { + } else if (priv->pri_protocol == PRI_PROTO_T1) { /* In T1 - Every 4'th channel is unused */ - if((i % 3) == 0) { + if ((i % 3) == 0) { physical_chan++; } } - if(IS_SET(wanted_lines, i)) { + if (IS_SET(wanted_lines, i)) { physical_mask |= BIT(physical_chan); - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { #ifdef DEBUG_PCMTX int channo = XPD_CHAN(xpd, i)->channo; - if(pcmtx >= 0 && pcmtx_chan == channo) + if (pcmtx >= 0 && pcmtx_chan == channo) memset((u_char *)pcm, pcmtx, DAHDI_CHUNKSIZE); else #endif memcpy((u_char *)pcm, chan->writechunk, DAHDI_CHUNKSIZE); - if(i == PRI_DCHAN_IDX(priv)) { - if(priv->dchan_tx_sample != chan->writechunk[0]) { + if (i == PRI_DCHAN_IDX(priv)) { + if (priv->dchan_tx_sample != chan->writechunk[0]) { priv->dchan_tx_sample = chan->writechunk[0]; priv->dchan_tx_counter++; - } else if(chan->writechunk[0] == 0xFF) + } else if (chan->writechunk[0] == 0xFF) dchan_state(xpd, 0); else chan->writechunk[0] = 0xFF; /* Clobber for next tick */ @@ -1800,7 +1800,7 @@ static void PRI_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) int i; int logical_chan; - if(!SPAN_REGISTERED(xpd)) + if (!SPAN_REGISTERED(xpd)) return; priv = xpd->priv; BUG_ON(!priv); @@ -1811,28 +1811,28 @@ static void PRI_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) for (i = 0; i < CHANNELS_PERXPD; i++) { volatile u_char *r; - if(priv->pri_protocol == PRI_PROTO_E1) { + if (priv->pri_protocol == PRI_PROTO_E1) { /* In E1 - Only 0'th channel is unused */ - if(i == 0) + if (i == 0) continue; - } else if(priv->pri_protocol == PRI_PROTO_T1) { + } else if (priv->pri_protocol == PRI_PROTO_T1) { /* In T1 - Every 4'th channel is unused */ - if((i % 4) == 0) + if ((i % 4) == 0) continue; } - if(logical_chan == PRI_DCHAN_IDX(priv) && !priv->is_cas) { - if(priv->dchan_rx_sample != pcm[0]) { - if(debug & DBG_PCM) { + if (logical_chan == PRI_DCHAN_IDX(priv) && !priv->is_cas) { + if (priv->dchan_rx_sample != pcm[0]) { + if (debug & DBG_PCM) { XPD_INFO(xpd, "RX-D-Chan: prev=0x%X now=0x%X\n", priv->dchan_rx_sample, pcm[0]); dump_packet("RX-D-Chan", pack, 1); } priv->dchan_rx_sample = pcm[0]; priv->dchan_rx_counter++; - } else if(pcm[0] == 0xFF) + } else if (pcm[0] == 0xFF) dchan_state(xpd, 0); } - if(IS_SET(physical_mask, i)) { + if (IS_SET(physical_mask, i)) { r = XPD_CHAN(xpd, logical_chan)->readchunk; // memset((u_char *)r, 0x5A, DAHDI_CHUNKSIZE); // DEBUG memcpy((u_char *)r, pcm, DAHDI_CHUNKSIZE); @@ -1926,11 +1926,11 @@ static void layer1_state(xpd_t *xpd, byte data_low) priv = xpd->priv; BUG_ON(!priv); priv->poll_noreplies = 0; - if(data_low & REG_FRS0_LOS) + if (data_low & REG_FRS0_LOS) alarms |= DAHDI_ALARM_RED; - if(data_low & REG_FRS0_AIS) + if (data_low & REG_FRS0_AIS) alarms |= DAHDI_ALARM_BLUE; - if(data_low & REG_FRS0_RRA) + if (data_low & REG_FRS0_RRA) alarms |= DAHDI_ALARM_YELLOW; layer1_up_prev = priv->layer1_up; priv->layer1_up = alarms == DAHDI_ALARM_NONE; @@ -1940,11 +1940,11 @@ static void layer1_state(xpd_t *xpd, byte data_low) * associated. However, layer1 is still not working if they are set. * FIXME: These behave differently in E1/T1, so ignore them for while. */ - if(data_low & (REG_FRS0_LMFA | REG_FRS0_E1_NMF)) + if (data_low & (REG_FRS0_LMFA | REG_FRS0_E1_NMF)) priv->layer1_up = 0; #endif priv->alarms = alarms; - if(!priv->layer1_up) { + if (!priv->layer1_up) { dchan_state(xpd, 0); } else if (priv->is_cas && !layer1_up_prev) { int regbase = cas_regbase(xpd); @@ -1956,7 +1956,7 @@ static void layer1_state(xpd_t *xpd, byte data_low) query_subunit(xpd, regbase + i); } - if(SPAN_REGISTERED(xpd) && PHONEDEV(xpd).span.alarms != alarms) { + if (SPAN_REGISTERED(xpd) && PHONEDEV(xpd).span.alarms != alarms) { char str1[MAX_PROC_WRITE]; char str2[MAX_PROC_WRITE]; @@ -1995,18 +1995,18 @@ static int decode_cas_e1(xpd_t *xpd, byte regnum, byte data_low) BUG_ON(!priv->is_cas); BUG_ON(priv->pri_protocol != PRI_PROTO_E1); XPD_DBG(SIGNAL, xpd, "RBS: RX: data_low=0x%02X\n", data_low); - if(pos >= NUM_CAS_RS_E) { + if (pos >= NUM_CAS_RS_E) { XPD_ERR(xpd, "%s: got bad pos=%d [0-%d]\n", __func__, pos, NUM_CAS_RS_E); return -EINVAL; } - if(chan1 < 0 || chan1 > PHONEDEV(xpd).channels) { + if (chan1 < 0 || chan1 > PHONEDEV(xpd).channels) { XPD_NOTICE(xpd, "%s: %s CAS: Bad chan1 number (%d)\n", __func__, pri_protocol_name(priv->pri_protocol), chan1); return -EINVAL; } - if(chan2 < 0 || chan2 > PHONEDEV(xpd).channels) { + if (chan2 < 0 || chan2 > PHONEDEV(xpd).channels) { XPD_NOTICE(xpd, "%s: %s CAS: Bad chan2 number (%d)\n", __func__, pri_protocol_name(priv->pri_protocol), @@ -2015,7 +2015,7 @@ static int decode_cas_e1(xpd_t *xpd, byte regnum, byte data_low) } XPD_DBG(SIGNAL, xpd, "RBS: RX: RS%02d (channel %2d, channel %2d): 0x%02X -> 0x%02X\n", rsnum, chan1+1, chan2+1, priv->cas_rs_e[pos], data_low); - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { dahdi_rbsbits(XPD_CHAN(xpd, chan1), val1); dahdi_rbsbits(XPD_CHAN(xpd, chan2), val2); } @@ -2036,11 +2036,11 @@ static int decode_cas_t1(xpd_t *xpd, byte regnum, byte data_low) BUG_ON(!priv->is_cas); BUG_ON(priv->pri_protocol != PRI_PROTO_T1); rsnum = regnum - REG_RS1_E; - if(rsnum >= 12) { + if (rsnum >= 12) { XPD_ERR(xpd, "Bad rsnum=%d\n", rsnum); return 0; } - if(!priv->is_esf) + if (!priv->is_esf) rsnum = rsnum % 6; /* 2 identical banks of 6 registers */ chan_per_reg = CHAN_PER_REGS(priv); width = 8 / chan_per_reg; @@ -2049,7 +2049,7 @@ static int decode_cas_t1(xpd_t *xpd, byte regnum, byte data_low) (priv->is_esf) ? "esf" : "d4", chan_per_reg, rsnum+1, data_low); - for(i = 0; i < chan_per_reg; i++) { + for (i = 0; i < chan_per_reg; i++) { uint rxsig = (data_low >> (i * width)) & BITMASK(width); int pos; struct dahdi_chan *chan; @@ -2057,16 +2057,16 @@ static int decode_cas_t1(xpd_t *xpd, byte regnum, byte data_low) if (!priv->is_esf) rxsig <<= 2; pos = rsnum * chan_per_reg + chan_per_reg - i - 1; - if(pos < 0 || pos >= PHONEDEV(xpd).channels) { + if (pos < 0 || pos >= PHONEDEV(xpd).channels) { XPD_ERR(xpd, "%s: Bad pos=%d\n", __func__, pos); continue; } chan = XPD_CHAN(xpd, pos); - if(!chan) { + if (!chan) { XPD_ERR(xpd, "%s: Null channel in pos=%d\n", __func__, pos); continue; } - if(chan->rxsig != rxsig) { + if (chan->rxsig != rxsig) { LINE_DBG(SIGNAL, xpd, pos, "i=%d rxsig=0x%02X\n", i, rxsig); dahdi_rbsbits(chan, rxsig); } @@ -2080,30 +2080,30 @@ static void process_cas_dchan(xpd_t *xpd, byte regnum, byte data_low) struct PRI_priv_data *priv; priv = xpd->priv; - if(!priv->is_cas) { + if (!priv->is_cas) { static int rate_limit; - if((rate_limit++ % 10003) == 0) + if ((rate_limit++ % 10003) == 0) XPD_NOTICE(xpd, "RBS: RX: not in CAS mode. Ignore.\n"); return; } - if(!priv->layer1_up) { + if (!priv->layer1_up) { static int rate_limit; - if((rate_limit++ % 10003) == 0) + if ((rate_limit++ % 10003) == 0) XPD_DBG(SIGNAL, xpd, "RBS: RX: No layer1.\n"); } - if(!SPAN_REGISTERED(xpd)) { + if (!SPAN_REGISTERED(xpd)) { static int rate_limit; - if((rate_limit++ % 10003) == 0) + if ((rate_limit++ % 10003) == 0) XPD_DBG(SIGNAL, xpd, "RBS: RX: Span not registered. Ignore.\n"); return; } - if(priv->pri_protocol == PRI_PROTO_E1) { - if(regnum == REG_RS1_E) + if (priv->pri_protocol == PRI_PROTO_E1) { + if (regnum == REG_RS1_E) return; /* Time slot 0: Ignored for E1 */ - if(regnum < REG_RS2_E) { + if (regnum < REG_RS2_E) { /* Should not happen, but harmless. Ignore */ if (regnum == REG_RS1_E) return; @@ -2113,16 +2113,16 @@ static void process_cas_dchan(xpd_t *xpd, byte regnum, byte data_low) __func__, regnum, pri_protocol_name(priv->pri_protocol)); return; } - if(decode_cas_e1(xpd, regnum, data_low) < 0) + if (decode_cas_e1(xpd, regnum, data_low) < 0) return; - } else if(priv->pri_protocol == PRI_PROTO_T1) { - if(regnum > REG_RS12_E) { + } else if (priv->pri_protocol == PRI_PROTO_T1) { + if (regnum > REG_RS12_E) { XPD_NOTICE(xpd, "%s: received register 0x%X in protocol %s. Ignore\n", __func__, regnum, pri_protocol_name(priv->pri_protocol)); return; } - if(decode_cas_t1(xpd, regnum, data_low) < 0) + if (decode_cas_t1(xpd, regnum, data_low) < 0) return; } else { XPD_NOTICE(xpd, "%s: protocol %s is not supported yet with CAS\n", @@ -2147,32 +2147,32 @@ static int PRI_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info) regnum = REG_FIELD(info, regnum); data_low = REG_FIELD(info, data_low); xpd = xpd_byaddr(xbus, addr.unit, addr.subunit); - if(!xpd) { + if (!xpd) { static int rate_limit; - if((rate_limit++ % 1003) < 5) + if ((rate_limit++ % 1003) < 5) notify_bad_xpd(__func__, xbus, addr , orig_xpd->xpdname); return -EPROTO; } spin_lock_irqsave(&xpd->lock, flags); priv = xpd->priv; BUG_ON(!priv); - if(info->is_multibyte) { + if (info->is_multibyte) { XPD_NOTICE(xpd, "Got Multibyte: %d bytes, eoframe: %d\n", info->bytes, info->eoframe); goto end; } - if(regnum == REG_FRS0 && !REG_FIELD(info, do_subreg)) + if (regnum == REG_FRS0 && !REG_FIELD(info, do_subreg)) layer1_state(xpd, data_low); - else if(regnum == REG_FRS1 && !REG_FIELD(info, do_subreg)) + else if (regnum == REG_FRS1 && !REG_FIELD(info, do_subreg)) priv->reg_frs1 = data_low; - if(priv->is_cas && !REG_FIELD(info, do_subreg)) { - if(regnum >= REG_RS1_E && regnum <= REG_RS16_E) { + if (priv->is_cas && !REG_FIELD(info, do_subreg)) { + if (regnum >= REG_RS1_E && regnum <= REG_RS16_E) { process_cas_dchan(xpd, regnum, data_low); } } /* Update /proc info only if reply relate to the last slic read request */ - if( + if ( REG_FIELD(&xpd->requested_reply, regnum) == REG_FIELD(info, regnum) && REG_FIELD(&xpd->requested_reply, do_subreg) == REG_FIELD(info, do_subreg) && REG_FIELD(&xpd->requested_reply, subreg) == REG_FIELD(info, subreg)) { @@ -2251,7 +2251,7 @@ static DEVICE_ATTR_READER(pri_protocol_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); @@ -2308,7 +2308,7 @@ static DEVICE_ATTR_READER(pri_localloop_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); @@ -2329,17 +2329,17 @@ static DEVICE_ATTR_WRITER(pri_localloop_store, dev, buf, count) BUG_ON(!dev); xpd = dev_to_xpd(dev); XPD_DBG(GENERAL, xpd, "%s\n", buf); - if(!xpd) + if (!xpd) return -ENODEV; - if((i = strcspn(buf, " \r\n")) != 1) { + if ((i = strcspn(buf, " \r\n")) != 1) { XPD_NOTICE(xpd, "Value '%s' has %d characters (should be 1). Ignored.\n", buf, i); return -EINVAL; } - if(strchr("1Yy", buf[0]) != NULL) + if (strchr("1Yy", buf[0]) != NULL) ll = 1; - else if(strchr("0Nn", buf[0]) != NULL) + else if (strchr("0Nn", buf[0]) != NULL) ll = 0; else { XPD_NOTICE(xpd, @@ -2362,12 +2362,12 @@ static DEVICE_ATTR_READER(pri_layer1_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); spin_lock_irqsave(&xpd->lock, flags); - if(priv->poll_noreplies > 1) + if (priv->poll_noreplies > 1) len += sprintf(buf + len, "Unknown[%d]", priv->poll_noreplies); else len += sprintf(buf + len, "%-10s", ((priv->layer1_up) ? "UP" : "DOWN")); @@ -2395,18 +2395,18 @@ static DEVICE_ATTR_READER(pri_alarms_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); spin_lock_irqsave(&xpd->lock, flags); - if(priv->poll_noreplies > 1) + if (priv->poll_noreplies > 1) len += sprintf(buf + len, "Unknown[%d]", priv->poll_noreplies); else { int i; - for(i = 0; i < ARRAY_SIZE(alarm_types); i++) { - if(priv->reg_frs0 & alarm_types[i].bits) + for (i = 0; i < ARRAY_SIZE(alarm_types); i++) { + if (priv->reg_frs0 & alarm_types[i].bits) len += sprintf(buf + len, "%s ", alarm_types[i].name); } } @@ -2426,23 +2426,23 @@ static DEVICE_ATTR_READER(pri_cas_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); spin_lock_irqsave(&xpd->lock, flags); - if(priv->is_cas) { + if (priv->is_cas) { int i; len += sprintf(buf + len, "CAS: replies=%d\n", priv->cas_replies); len += sprintf(buf + len, " CAS-TS: "); - for(i = 0; i < NUM_CAS_RS_E; i++) { + for (i = 0; i < NUM_CAS_RS_E; i++) { len += sprintf(buf + len, " %02X", priv->cas_ts_e[i]); } len += sprintf(buf + len, "\n"); len += sprintf(buf + len, " CAS-RS: "); - for(i = 0; i < NUM_CAS_RS_E; i++) { + for (i = 0; i < NUM_CAS_RS_E; i++) { len += sprintf(buf + len, " %02X", priv->cas_rs_e[i]); } len += sprintf(buf + len, "\n"); @@ -2462,7 +2462,7 @@ static DEVICE_ATTR_READER(pri_dchan_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); @@ -2470,7 +2470,7 @@ static DEVICE_ATTR_READER(pri_dchan_show, dev, buf) len += sprintf(buf + len, "D-Channel: TX=[%5d] (0x%02X) RX=[%5d] (0x%02X) ", priv->dchan_tx_counter, priv->dchan_tx_sample, priv->dchan_rx_counter, priv->dchan_rx_sample); - if(priv->dchan_alive) { + if (priv->dchan_alive) { len += sprintf(buf + len, "(alive %d K-ticks)\n", priv->dchan_alive_ticks/1000); } else { @@ -2491,7 +2491,7 @@ static DEVICE_ATTR_READER(pri_clocking_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; priv = xpd->priv; BUG_ON(!priv); @@ -2510,44 +2510,44 @@ static int pri_xpd_probe(struct device *dev) xpd = dev_to_xpd(dev); /* Is it our device? */ - if(xpd->type != XPD_TYPE_PRI) { + if (xpd->type != XPD_TYPE_PRI) { XPD_ERR(xpd, "drop suggestion for %s (%d)\n", dev_name(dev), xpd->type); return -EINVAL; } XPD_DBG(DEVICES, xpd, "SYSFS\n"); ret = device_create_file(dev, &dev_attr_pri_protocol); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_create_file(pri_protocol) failed: %d\n", __func__, ret); goto fail_pri_protocol; } ret = device_create_file(dev, &dev_attr_pri_localloop); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_create_file(pri_localloop) failed: %d\n", __func__, ret); goto fail_pri_localloop; } ret = device_create_file(dev, &dev_attr_pri_layer1); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_create_file(pri_layer1) failed: %d\n", __func__, ret); goto fail_pri_layer1; } ret = device_create_file(dev, &dev_attr_pri_alarms); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_create_file(pri_alarms) failed: %d\n", __func__, ret); goto fail_pri_alarms; } ret = device_create_file(dev, &dev_attr_pri_cas); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_create_file(pri_cas) failed: %d\n", __func__, ret); goto fail_pri_cas; } ret = device_create_file(dev, &dev_attr_pri_dchan); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_create_file(pri_dchan) failed: %d\n", __func__, ret); goto fail_pri_dchan; } ret = device_create_file(dev, &dev_attr_pri_clocking); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_create_file(pri_clocking) failed: %d\n", __func__, ret); goto fail_pri_clocking; } @@ -2600,7 +2600,7 @@ static int __init card_pri_startup(void) { int ret; - if((ret = xpd_driver_register(&pri_driver.driver)) < 0) + if ((ret = xpd_driver_register(&pri_driver.driver)) < 0) return ret; INFO("revision %s\n", XPP_VERSION); #ifdef DAHDI_AUDIO_NOTIFY diff --git a/drivers/dahdi/xpp/dahdi_debug.c b/drivers/dahdi/xpp/dahdi_debug.c index 0e0261d..dea17e1 100644 --- a/drivers/dahdi/xpp/dahdi_debug.c +++ b/drivers/dahdi/xpp/dahdi_debug.c @@ -58,8 +58,8 @@ void dump_poll(int debug, const char *msg, int poll) { int i; - for(i = 0; i < ARRAY_SIZE(poll_names); i++) { - if(poll & poll_names[i].value) + for (i = 0; i < ARRAY_SIZE(poll_names); i++) { + if (poll & poll_names[i].value) DBG(GENERAL, "%s: %s\n", msg, poll_names[i].name); } } @@ -71,19 +71,19 @@ void alarm2str(int alarm, char *buf, int buflen) int i; int n; - if(!alarm) { + if (!alarm) { snprintf(buf, buflen, "NONE"); return; } memset(buf, 0, buflen); - for(i = 0; i < 8; i++) { - if(left && (alarm & BIT(i))) { + for (i = 0; i < 8; i++) { + if (left && (alarm & BIT(i))) { n = snprintf(p, left, "%s,", alarmbit2str(i)); p += n; left -= n; } } - if(p > buf) /* kill last comma */ + if (p > buf) /* kill last comma */ *(p - 1) = '\0'; } diff --git a/drivers/dahdi/xpp/dahdi_debug.h b/drivers/dahdi/xpp/dahdi_debug.h index ce6ed1b..b93b28d 100644 --- a/drivers/dahdi/xpp/dahdi_debug.h +++ b/drivers/dahdi/xpp/dahdi_debug.h @@ -94,7 +94,7 @@ void dump_poll(int debug, const char *msg, int poll); static inline char *rxsig2str(enum dahdi_rxsig sig) { - switch(sig) { + switch (sig) { case DAHDI_RXSIG_ONHOOK: return "ONHOOK"; case DAHDI_RXSIG_OFFHOOK: return "OFFHOOK"; case DAHDI_RXSIG_START: return "START"; @@ -106,7 +106,7 @@ static inline char *rxsig2str(enum dahdi_rxsig sig) static inline char *txsig2str(enum dahdi_txsig sig) { - switch(sig) { + switch (sig) { case DAHDI_TXSIG_ONHOOK: return "TXSIG_ONHOOK"; case DAHDI_TXSIG_OFFHOOK: return "TXSIG_OFFHOOK"; case DAHDI_TXSIG_START: return "TXSIG_START"; @@ -118,7 +118,7 @@ static inline char *txsig2str(enum dahdi_txsig sig) static inline char *event2str(int event) { - switch(event) { + switch (event) { case DAHDI_EVENT_NONE: return "NONE"; case DAHDI_EVENT_ONHOOK: return "ONHOOK"; case DAHDI_EVENT_RINGOFFHOOK: return "RINGOFFHOOK"; @@ -143,7 +143,7 @@ static inline char *event2str(int event) static inline char *hookstate2str(int hookstate) { - switch(hookstate) { + switch (hookstate) { case DAHDI_ONHOOK: return "DAHDI_ONHOOK"; case DAHDI_START: return "DAHDI_START"; case DAHDI_OFFHOOK: return "DAHDI_OFFHOOK"; @@ -185,7 +185,7 @@ static inline char *sig2str(int sig) static inline char *alarmbit2str(int alarmbit) { /* from dahdi/kernel.h */ - switch(1 << alarmbit) { + switch (1 << alarmbit) { case DAHDI_ALARM_NONE: return "NONE"; case DAHDI_ALARM_RECOVER: return "RECOVER"; case DAHDI_ALARM_LOOPBACK: return "LOOPBACK"; diff --git a/drivers/dahdi/xpp/mmapdrv.c b/drivers/dahdi/xpp/mmapdrv.c index 0635903..bd6ec88 100644 --- a/drivers/dahdi/xpp/mmapdrv.c +++ b/drivers/dahdi/xpp/mmapdrv.c @@ -115,7 +115,7 @@ static irqreturn_t xpp_mmap_rx_irq(int irq, void *dev_id) xbus = xbus_num(global_xbus->num); BUG_ON(!xbus); - if(!XBUS_GET(xbus)) { + if (!XBUS_GET(xbus)) { if (printk_ratelimit()) XBUS_ERR(xbus, "Dropping packet. Is shutting down.\n"); goto out; @@ -129,7 +129,7 @@ static irqreturn_t xpp_mmap_rx_irq(int irq, void *dev_id) NOTICE("Got %d bytes\n", rxcnt); goto out; } - if(rxcnt >= XFRAME_DATASIZE) { + if (rxcnt >= XFRAME_DATASIZE) { if (printk_ratelimit()) ERR("Bad rxcnt=%d\n", rxcnt); goto out; @@ -520,7 +520,7 @@ static int __init xpp_mmap_init(void) NULL, #endif NULL); - if(!xframe_cache) { + if (!xframe_cache) { ret = -ENOMEM; goto fail_cache; } diff --git a/drivers/dahdi/xpp/parport_debug.c b/drivers/dahdi/xpp/parport_debug.c index 950e45d..4b9f83f 100644 --- a/drivers/dahdi/xpp/parport_debug.c +++ b/drivers/dahdi/xpp/parport_debug.c @@ -41,8 +41,8 @@ void flip_parport_bit(unsigned char bitnum) unsigned char mask; unsigned char value; - if(!debug_sync_parport) { - if(printk_ratelimit()) { + if (!debug_sync_parport) { + if (printk_ratelimit()) { printk(KERN_NOTICE "%s: no debug parallel port\n", THIS_MODULE->name); } @@ -52,7 +52,7 @@ void flip_parport_bit(unsigned char bitnum) mask = 1 << bitnum; spin_lock_irqsave(&lock, flags); value = last_value & ~mask; - if(parport_toggles[bitnum] % 2) /* square wave */ + if (parport_toggles[bitnum] % 2) /* square wave */ value |= mask; last_value = value; parport_toggles[bitnum]++; @@ -64,7 +64,7 @@ EXPORT_SYMBOL(flip_parport_bit); static void parport_attach(struct parport *port) { printk(KERN_INFO "%s: Using %s for debugging\n", THIS_MODULE->name, port->name); - if(debug_sync_parport) { + if (debug_sync_parport) { printk(KERN_ERR "%s: Using %s, ignore new attachment %s\n", THIS_MODULE->name, debug_sync_parport->name, port->name); return; @@ -76,7 +76,7 @@ static void parport_attach(struct parport *port) static void parport_detach(struct parport *port) { printk(KERN_INFO "%s: Releasing %s\n", THIS_MODULE->name, port->name); - if(debug_sync_parport != port) { + if (debug_sync_parport != port) { printk(KERN_ERR "%s: Using %s, ignore new detachment %s\n", THIS_MODULE->name, debug_sync_parport->name, port->name); return; diff --git a/drivers/dahdi/xpp/xbus-core.c b/drivers/dahdi/xpp/xbus-core.c index d4db723..9eb2eec 100644 --- a/drivers/dahdi/xpp/xbus-core.c +++ b/drivers/dahdi/xpp/xbus-core.c @@ -118,7 +118,7 @@ int xbus_check_unique(xbus_t *xbus) const char *xbus_statename(enum xbus_state st) { - switch(st) { + switch (st) { case XBUS_STATE_START: return "START"; case XBUS_STATE_IDLE: return "IDLE"; case XBUS_STATE_SENT_REQUEST: return "SENT_REQUEST"; @@ -144,7 +144,7 @@ xbus_t *xbus_num(uint num) { struct xbus_desc *desc; - if(num >= ARRAY_SIZE(xbuses_array)) + if (num >= ARRAY_SIZE(xbuses_array)) return NULL; desc = &xbuses_array[num]; return desc->xbus; @@ -154,7 +154,7 @@ static void initialize_xbuses_array(void) { int i; - for(i = 0; i < ARRAY_SIZE(xbuses_array); i++) + for (i = 0; i < ARRAY_SIZE(xbuses_array); i++) init_xbus(i, NULL); } @@ -162,8 +162,8 @@ static void finalize_xbuses_array(void) { int i; - for(i = 0; i < ARRAY_SIZE(xbuses_array); i++) { - if(xbuses_array[i].xbus != NULL) { + for (i = 0; i < ARRAY_SIZE(xbuses_array); i++) { + if (xbuses_array[i].xbus != NULL) { ERR("%s: xbus #%d is not NULL\n", __func__, i); BUG(); } @@ -256,7 +256,7 @@ static void do_hexdump(const char msg[], byte *data, uint16_t len) int i; int debug = DBG_ANY; /* mask global debug */ - for(i = 0; i < len; i++) + for (i = 0; i < len; i++) DBG(ANY, "%s: %3d> %02X\n", msg, i, data[i]); } @@ -270,23 +270,23 @@ void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe, i bool do_print; unsigned long flags; - if(xframe->xframe_magic != XFRAME_MAGIC) { + if (xframe->xframe_magic != XFRAME_MAGIC) { XBUS_ERR(xbus, "%s: bad xframe_magic %lX\n", __func__, xframe->xframe_magic); return; } spin_lock_irqsave(&serialize_dump_xframe, flags); do { - if(pos >= xbus->transport.max_send_size) { - if(printk_ratelimit()) { + if (pos >= xbus->transport.max_send_size) { + if (printk_ratelimit()) { XBUS_NOTICE(xbus, "%s: xframe overflow (%d bytes)\n", msg, frm_len); do_hexdump(msg, xframe->packets, frm_len); } break; } - if(pos > frm_len) { - if(printk_ratelimit()) { + if (pos > frm_len) { + if (printk_ratelimit()) { XBUS_NOTICE(xbus, "%s: packet overflow pos=%d frame_len=%d\n", msg, pos, frm_len); do_hexdump(msg, xframe->packets, frm_len); @@ -294,8 +294,8 @@ void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe, i break; } pack = (xpacket_t *)&xframe->packets[pos]; - if(XPACKET_LEN(pack) <= 0) { - if(printk_ratelimit()) { + if (XPACKET_LEN(pack) <= 0) { + if (printk_ratelimit()) { XBUS_NOTICE(xbus, "%s: xframe -- bad packet_len=%d pos=%d frame_len=%d\n", msg, XPACKET_LEN(pack), pos, frm_len); do_hexdump(msg, xframe->packets, frm_len); @@ -303,8 +303,8 @@ void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe, i break; } nextpos = pos + XPACKET_LEN(pack); - if(nextpos > frm_len) { - if(printk_ratelimit()) { + if (nextpos > frm_len) { + if (printk_ratelimit()) { XBUS_NOTICE(xbus, "%s: packet overflow nextpos=%d frame_len=%d\n", msg, nextpos, frm_len); do_hexdump(msg, xframe->packets, frm_len); @@ -312,19 +312,19 @@ void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe, i break; } do_print = 0; - if(debug == DBG_ANY) + if (debug == DBG_ANY) do_print = 1; - else if(XPACKET_OP(pack) != XPROTO_NAME(GLOBAL,PCM_READ) && + else if (XPACKET_OP(pack) != XPROTO_NAME(GLOBAL,PCM_READ) && XPACKET_OP(pack) != XPROTO_NAME(GLOBAL,PCM_WRITE)) do_print = 1; - else if(debug & DBG_PCM) { + else if (debug & DBG_PCM) { static int rate_limit; - if((rate_limit++ % 1003) == 0) + if ((rate_limit++ % 1003) == 0) do_print = 1; } - if(do_print) { - if(num == 1) { + if (do_print) { + if (num == 1) { XBUS_DBG(ANY, xbus, "%s: frame_len=%d. %s\n", msg, frm_len, (XPACKET_IS_PCM(pack)) @@ -341,9 +341,9 @@ void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe, i } num++; pos = nextpos; - if(pos >= frm_len) + if (pos >= frm_len) break; - } while(1); + } while (1); spin_unlock_irqrestore(&serialize_dump_xframe, flags); } @@ -359,7 +359,7 @@ int send_pcm_frame(xbus_t *xbus, xframe_t *xframe) int ret = -ENODEV; BUG_ON(!xframe); - if(!XBUS_IS(xbus, READY)) { + if (!XBUS_IS(xbus, READY)) { XBUS_ERR(xbus, "Dropped a pcm frame -- hardware is not ready.\n"); ret = -ENODEV; goto error; @@ -368,7 +368,7 @@ int send_pcm_frame(xbus_t *xbus, xframe_t *xframe) BUG_ON(!ops); ret = ops->xframe_send_pcm(xbus, xframe); transportops_put(xbus); - if(ret) + if (ret) XBUS_COUNTER(xbus, TX_BYTES) += XFRAME_LEN(xframe); return ret; @@ -385,7 +385,7 @@ static int really_send_cmd_frame(xbus_t *xbus, xframe_t *xframe) BUG_ON(!xbus); BUG_ON(!xframe); BUG_ON(xframe->xframe_magic != XFRAME_MAGIC); - if(!XBUS_FLAGS(xbus, CONNECTED)) { + if (!XBUS_FLAGS(xbus, CONNECTED)) { XBUS_ERR(xbus, "Dropped command before sending -- hardware deactivated.\n"); dump_xframe("Dropped", xbus, xframe, DBG_ANY); FREE_SEND_XFRAME(xbus, xframe); @@ -393,11 +393,11 @@ static int really_send_cmd_frame(xbus_t *xbus, xframe_t *xframe) } ops = transportops_get(xbus); BUG_ON(!ops); - if(debug & DBG_COMMANDS) + if (debug & DBG_COMMANDS) dump_xframe("TX-CMD", xbus, xframe, DBG_ANY); ret = ops->xframe_send_cmd(xbus, xframe); transportops_put(xbus); - if(ret == 0) { + if (ret == 0) { XBUS_COUNTER(xbus, TX_CMD)++; XBUS_COUNTER(xbus, TX_BYTES) += XFRAME_LEN(xframe); } @@ -412,25 +412,25 @@ int xbus_command_queue_tick(xbus_t *xbus) xbus->command_tick_counter++; xbus->usec_nosend -= 1000; /* That's our budget */ - for(packno = 0; packno < 3; packno++) { - if(xbus->usec_nosend > 0) + for (packno = 0; packno < 3; packno++) { + if (xbus->usec_nosend > 0) break; frm = xframe_dequeue(&xbus->command_queue); - if(!frm) { + if (!frm) { wake_up(&xbus->command_queue_empty); break; } BUG_ON(frm->xframe_magic != XFRAME_MAGIC); xbus->usec_nosend += frm->usec_towait; ret = really_send_cmd_frame(xbus, frm); - if(ret < 0) { + if (ret < 0) { XBUS_ERR(xbus, "Failed to send from command_queue (ret=%d)\n", ret); xbus_setstate(xbus, XBUS_STATE_FAIL); } } - if(xbus->usec_nosend < 0) + if (xbus->usec_nosend < 0) xbus->usec_nosend = 0; return ret; } @@ -441,7 +441,7 @@ static void xbus_command_queue_clean(xbus_t *xbus) XBUS_DBG(DEVICES, xbus, "count=%d\n", xbus->command_queue.count); xframe_queue_disable(&xbus->command_queue, 1); - while((frm = xframe_dequeue(&xbus->command_queue)) != NULL) { + while ((frm = xframe_dequeue(&xbus->command_queue)) != NULL) { FREE_SEND_XFRAME(xbus, frm); } } @@ -453,7 +453,7 @@ static int xbus_command_queue_waitempty(xbus_t *xbus) XBUS_DBG(DEVICES, xbus, "Waiting for command_queue to empty\n"); ret = wait_event_interruptible(xbus->command_queue_empty, xframe_queue_count(&xbus->command_queue) == 0); - if(ret) { + if (ret) { XBUS_ERR(xbus, "waiting for command_queue interrupted!!!\n"); } return ret; @@ -466,15 +466,15 @@ int send_cmd_frame(xbus_t *xbus, xframe_t *xframe) BUG_ON(xframe->xframe_magic != XFRAME_MAGIC); - if(!XBUS_FLAGS(xbus, CONNECTED)) { + if (!XBUS_FLAGS(xbus, CONNECTED)) { XBUS_ERR(xbus, "Dropped command before queueing -- hardware deactivated.\n"); ret = -ENODEV; goto err; } - if(debug & DBG_COMMANDS) + if (debug & DBG_COMMANDS) dump_xframe(__func__, xbus, xframe, DBG_ANY); - if(!xframe_enqueue(&xbus->command_queue, xframe)) { - if((rate_limit++ % 1003) == 0) { + if (!xframe_enqueue(&xbus->command_queue, xframe)) { + if ((rate_limit++ % 1003) == 0) { XBUS_ERR(xbus, "Dropped command xframe. Cannot enqueue (%d)\n", rate_limit); @@ -498,10 +498,10 @@ static void xframe_enqueue_recv(xbus_t *xbus, xframe_t *xframe) BUG_ON(!xbus); xbus->cpu_rcv_intr[cpu]++; - if(!xframe_enqueue(&xbus->receive_queue, xframe)) { + if (!xframe_enqueue(&xbus->receive_queue, xframe)) { static int rate_limit; - if((rate_limit++ % 1003) == 0) + if ((rate_limit++ % 1003) == 0) XBUS_ERR(xbus, "Failed to enqueue for receive_tasklet (%d)\n", rate_limit); FREE_RECV_XFRAME(xbus, xframe); /* return to receive_pool */ return; @@ -520,7 +520,7 @@ static void receive_tasklet_func(unsigned long data) BUG_ON(!xbus); xbus->cpu_rcv_tasklet[cpu]++; - while((xframe = xframe_dequeue(&xbus->receive_queue)) != NULL) { + while ((xframe = xframe_dequeue(&xbus->receive_queue)) != NULL) { xframe_receive(xbus, xframe); } } @@ -528,10 +528,10 @@ static void receive_tasklet_func(unsigned long data) void xbus_receive_xframe(xbus_t *xbus, xframe_t *xframe) { BUG_ON(!xbus); - if(rx_tasklet) { + if (rx_tasklet) { xframe_enqueue_recv(xbus, xframe); } else { - if(likely(XBUS_FLAGS(xbus, CONNECTED))) + if (likely(XBUS_FLAGS(xbus, CONNECTED))) xframe_receive(xbus, xframe); else FREE_RECV_XFRAME(xbus, xframe); /* return to receive_pool */ @@ -541,14 +541,14 @@ void xbus_receive_xframe(xbus_t *xbus, xframe_t *xframe) /*------------------------- Bus Management -------------------------*/ xpd_t *xpd_of(const xbus_t *xbus, int xpd_num) { - if(!VALID_XPD_NUM(xpd_num)) + if (!VALID_XPD_NUM(xpd_num)) return NULL; return xbus->xpds[xpd_num]; } xpd_t *xpd_byaddr(const xbus_t *xbus, uint unit, uint subunit) { - if(unit > MAX_UNIT || subunit > MAX_SUBUNIT) + if (unit > MAX_UNIT || subunit > MAX_SUBUNIT) return NULL; return xbus->xpds[XPD_IDX(unit,subunit)]; } @@ -562,11 +562,11 @@ int xbus_xpd_bind(xbus_t *xbus, xpd_t *xpd, int unit, int subunit) xpd_num = XPD_IDX(unit,subunit); XBUS_DBG(DEVICES, xbus, "XPD #%d\n", xpd_num); spin_lock_irqsave(&xbus->lock, flags); - if(!VALID_XPD_NUM(xpd_num)) { + if (!VALID_XPD_NUM(xpd_num)) { XBUS_ERR(xbus, "Bad xpd_num = %d\n", xpd_num); BUG(); } - if(xbus->xpds[xpd_num] != NULL) { + if (xbus->xpds[xpd_num] != NULL) { xpd_t *other = xbus->xpds[xpd_num]; XBUS_ERR(xbus, "xpd_num=%d is occupied by %p (%s)\n", @@ -581,7 +581,7 @@ int xbus_xpd_bind(xbus_t *xbus, xpd_t *xpd, int unit, int subunit) atomic_inc(&xbus->num_xpds); spin_unlock_irqrestore(&xbus->lock, flags); /* Must be done out of atomic context */ - if(xpd_device_register(xbus, xpd) < 0) { + if (xpd_device_register(xbus, xpd) < 0) { XPD_ERR(xpd, "%s: xpd_device_register() failed\n", __func__); /* FIXME: What to do? */ } @@ -594,15 +594,15 @@ int xbus_xpd_unbind(xbus_t *xbus, xpd_t *xpd) unsigned long flags; XBUS_DBG(DEVICES, xbus, "XPD #%d\n", xpd_num); - if(!VALID_XPD_NUM(xpd_num)) { + if (!VALID_XPD_NUM(xpd_num)) { XBUS_ERR(xbus, "%s: Bad xpd_num = %d\n", __func__, xpd_num); BUG(); } - if(xbus->xpds[xpd_num] == NULL) { + if (xbus->xpds[xpd_num] == NULL) { XBUS_ERR(xbus, "%s: slot xpd_num=%d is empty\n", __func__, xpd_num); BUG(); } - if(xbus->xpds[xpd_num] != xpd) { + if (xbus->xpds[xpd_num] != xpd) { xpd_t *other = xbus->xpds[xpd_num]; XBUS_ERR(xbus, "%s: slot xpd_num=%d is occupied by %p (%s)\n", @@ -612,7 +612,7 @@ int xbus_xpd_unbind(xbus_t *xbus, xpd_t *xpd) spin_lock_irqsave(&xbus->lock, flags); xpd->xbus = NULL; xbus->xpds[xpd_num] = NULL; - if(atomic_dec_and_test(&xbus->num_xpds)) + if (atomic_dec_and_test(&xbus->num_xpds)) xbus_setstate(xbus, XBUS_STATE_IDLE); spin_unlock_irqrestore(&xbus->lock, flags); return 0; @@ -635,7 +635,7 @@ static int new_card(xbus_t *xbus, const struct echoops *echoops; proto_table = xproto_get(type); - if(!proto_table) { + if (!proto_table) { XBUS_NOTICE(xbus, "CARD %d: missing protocol table for type %d. Ignored.\n", unit, type); @@ -671,13 +671,13 @@ static int new_card(xbus_t *xbus, if (type == XPD_TYPE_FXO) xbus->quirks.has_fxo = 1; xbus->worker.num_units += subunits - 1; - for(i = 0; i < subunits; i++) { + for (i = 0; i < subunits; i++) { int subunit_ports = proto_table->ports_per_subunit; - if(subunit_ports > remaining_ports) + if (subunit_ports > remaining_ports) subunit_ports = remaining_ports; remaining_ports -= proto_table->ports_per_subunit; - if(subunit_ports <= 0) { + if (subunit_ports <= 0) { XBUS_NOTICE(xbus, "Subunit XPD=%d%d without ports (%d of %d)\n", unit, @@ -687,7 +687,7 @@ static int new_card(xbus_t *xbus, ret = -ENODEV; goto out; } - if(!XBUS_IS(xbus, RECVD_DESC)) { + if (!XBUS_IS(xbus, RECVD_DESC)) { XBUS_NOTICE(xbus, "Cannot create XPD=%d%d in state %s\n", unit, @@ -702,7 +702,7 @@ static int new_card(xbus_t *xbus, type, subtype, subunit_ports); ret = create_xpd(xbus, proto_table, unit, i, type, subtype, subunits, subunit_ports, port_dir); - if(ret < 0) { + if (ret < 0) { XBUS_ERR(xbus, "Creation of XPD=%d%d failed %d\n", unit, i, ret); goto out; @@ -719,10 +719,10 @@ static void xbus_release_xpds(xbus_t *xbus) int i; XBUS_DBG(DEVICES, xbus, "[%s] Release XPDS\n", xbus->label); - for(i = 0; i < MAX_XPDS; i++) { + for (i = 0; i < MAX_XPDS; i++) { xpd_t *xpd = xpd_of(xbus, i); - if(xpd) + if (xpd) put_xpd(__func__, xpd); } } @@ -761,7 +761,7 @@ static int xpd_initialize(xpd_t *xpd) { int ret = -ENODEV; - if(CALL_XMETHOD(card_init, xpd) < 0) { + if (CALL_XMETHOD(card_init, xpd) < 0) { XPD_ERR(xpd, "Card Initialization failed\n"); goto out; } @@ -774,7 +774,7 @@ static int xpd_initialize(xpd_t *xpd) CALL_PHONE_METHOD(echocancel_setmask, xpd, 0); CALL_PHONE_METHOD(card_state, xpd, 1); /* Turn on all channels */ } - if(!xpd_setstate(xpd, XPD_STATE_READY)) { + if (!xpd_setstate(xpd, XPD_STATE_READY)) { goto out; } XPD_INFO(xpd, "Initialized: %s\n", xpd->type_name); @@ -849,9 +849,9 @@ static int xbus_initialize(xbus_t *xbus) refcount_xbus(xbus)); if (xbus_aquire_xpds(xbus) < 0) /* Until end of initialization */ return -EBUSY; - for(unit = 0; unit < MAX_UNIT; unit++) { + for (unit = 0; unit < MAX_UNIT; unit++) { xpd = xpd_byaddr(xbus, unit, 0); - if(!xpd) + if (!xpd) continue; if (!XBUS_IS(xbus, RECVD_DESC)) { XBUS_NOTICE(xbus, @@ -860,15 +860,15 @@ static int xbus_initialize(xbus_t *xbus) xbus_statename(XBUS_STATE(xbus))); goto err; } - if(run_initialize_registers(xpd) < 0) { + if (run_initialize_registers(xpd) < 0) { XBUS_ERR(xbus, "Register Initialization of card #%d failed\n", unit); goto err; } - for(subunit = 0; subunit < MAX_SUBUNIT; subunit++) { + for (subunit = 0; subunit < MAX_SUBUNIT; subunit++) { int ret; xpd = xpd_byaddr(xbus, unit, subunit); - if(!xpd) + if (!xpd) continue; if (!XBUS_IS(xbus, RECVD_DESC)) { XBUS_ERR(xbus, @@ -877,7 +877,7 @@ static int xbus_initialize(xbus_t *xbus) goto err; } ret = xpd_initialize(xpd); - if(ret < 0) + if (ret < 0) goto err; } } @@ -994,7 +994,7 @@ void xbus_unregister_dahdi_device(xbus_t *xbus) int i; XBUS_NOTICE(xbus, "%s\n", __func__); - for(i = 0; i < MAX_XPDS; i++) { + for (i = 0; i < MAX_XPDS; i++) { xpd_t *xpd = xpd_of(xbus, i); xpd_dahdi_preunregister(xpd); } @@ -1003,7 +1003,7 @@ void xbus_unregister_dahdi_device(xbus_t *xbus) XBUS_NOTICE(xbus, "%s: finished dahdi_unregister_device()\n", __func__); xbus_free_ddev(xbus); } - for(i = 0; i < MAX_XPDS; i++) { + for (i = 0; i < MAX_XPDS; i++) { xpd_t *xpd = xpd_of(xbus, i); xpd_dahdi_postunregister(xpd); } @@ -1050,16 +1050,16 @@ void xbus_populate(void *data) card_desc->port_dir); spin_lock_irqsave(&xbus->worker.worker_lock, flags); KZFREE(card_desc); - if(ret) + if (ret) break; } spin_unlock_irqrestore(&worker->worker_lock, flags); - if(xbus_initialize(xbus) < 0) { + if (xbus_initialize(xbus) < 0) { XBUS_NOTICE(xbus, "Initialization failed. Leave unused. refcount_xbus=%d\n", refcount_xbus(xbus)); goto failed; } - if(!xbus_setstate(xbus, XBUS_STATE_READY)) { + if (!xbus_setstate(xbus, XBUS_STATE_READY)) { XBUS_NOTICE(xbus, "Illegal transition. Leave unused. refcount_xbus=%d\n", refcount_xbus(xbus)); goto failed; @@ -1090,7 +1090,7 @@ int xbus_process_worker(xbus_t *xbus) { struct xbus_workqueue *worker; - if(!xbus) { + if (!xbus) { ERR("%s: xbus gone -- skip initialization\n", __func__); return 0; } @@ -1108,7 +1108,7 @@ int xbus_process_worker(xbus_t *xbus) #endif BUG_ON(!xbus); /* Now send it */ - if(!queue_work(worker->wq, &worker->xpds_init_work)) { + if (!queue_work(worker->wq, &worker->xpds_init_work)) { XBUS_ERR(xbus, "Failed to queue xpd initialization work\n"); up(&worker->running_initialization); return 0; @@ -1128,7 +1128,7 @@ static void worker_reset(xbus_t *xbus) worker = &xbus->worker; name = (xbus) ? xbus->busname : "detached"; DBG(DEVICES, "%s\n", name); - if(!worker->xpds_init_done) { + if (!worker->xpds_init_done) { NOTICE("%s: worker(%s)->xpds_init_done=%d\n", __func__, name, worker->xpds_init_done); } @@ -1200,7 +1200,7 @@ static int worker_run(xbus_t *xbus) XBUS_DBG(DEVICES, xbus, "\n"); /* poll related variables */ worker->wq = create_singlethread_workqueue(xbus->busname); - if(!worker->wq) { + if (!worker->wq) { XBUS_ERR(xbus, "Failed to create worker workqueue.\n"); goto err; } @@ -1218,7 +1218,7 @@ bool xbus_setflags(xbus_t *xbus, int flagbit, bool on) XBUS_DBG(DEVICES, xbus, "%s flag %d\n", (on) ? "Set" : "Clear", flagbit); - if(on) + if (on) set_bit(flagbit, &(xbus->transport.transport_flags)); else clear_bit(flagbit, &(xbus->transport.transport_flags)); @@ -1233,48 +1233,48 @@ bool xbus_setstate(xbus_t *xbus, enum xbus_state newstate) int state_flip = 0; spin_lock_irqsave(&xbus->transport.state_lock, flags); - if(newstate == XBUS_STATE(xbus)) { + if (newstate == XBUS_STATE(xbus)) { XBUS_DBG(DEVICES, xbus, "stay at %s\n", xbus_statename(newstate)); goto out; } /* Sanity tests */ - switch(newstate) { + switch (newstate) { case XBUS_STATE_START: goto bad_state; case XBUS_STATE_IDLE: - if(!XBUS_IS(xbus, START) && + if (!XBUS_IS(xbus, START) && !XBUS_IS(xbus, DEACTIVATED)) goto bad_state; break; case XBUS_STATE_SENT_REQUEST: - if(!XBUS_IS(xbus, IDLE) && + if (!XBUS_IS(xbus, IDLE) && !XBUS_IS(xbus, SENT_REQUEST)) goto bad_state; break; case XBUS_STATE_RECVD_DESC: - if(!XBUS_IS(xbus, SENT_REQUEST)) + if (!XBUS_IS(xbus, SENT_REQUEST)) goto bad_state; break; case XBUS_STATE_READY: - if(!XBUS_IS(xbus, RECVD_DESC)) + if (!XBUS_IS(xbus, RECVD_DESC)) goto bad_state; state_flip = 1; /* We are good */ break; case XBUS_STATE_DEACTIVATING: - if(XBUS_IS(xbus, DEACTIVATING)) + if (XBUS_IS(xbus, DEACTIVATING)) goto bad_state; - if(XBUS_IS(xbus, DEACTIVATED)) + if (XBUS_IS(xbus, DEACTIVATED)) goto bad_state; break; case XBUS_STATE_DEACTIVATED: - if(!XBUS_IS(xbus, DEACTIVATING)) + if (!XBUS_IS(xbus, DEACTIVATING)) goto bad_state; break; case XBUS_STATE_FAIL: - if(XBUS_IS(xbus, DEACTIVATING)) + if (XBUS_IS(xbus, DEACTIVATING)) goto bad_state; - if(XBUS_IS(xbus, DEACTIVATED)) + if (XBUS_IS(xbus, DEACTIVATED)) goto bad_state; break; default: @@ -1285,16 +1285,16 @@ bool xbus_setstate(xbus_t *xbus, enum xbus_state newstate) XBUS_DBG(DEVICES, xbus, "%s -> %s\n", xbus_statename(XBUS_STATE(xbus)), xbus_statename(newstate)); - if(xbus->transport.xbus_state == XBUS_STATE_READY && newstate != XBUS_STATE_READY) + if (xbus->transport.xbus_state == XBUS_STATE_READY && newstate != XBUS_STATE_READY) state_flip = -1; /* We became bad */ xbus->transport.xbus_state = newstate; ret = 1; out: spin_unlock_irqrestore(&xbus->transport.state_lock, flags); /* Should be sent out of spinlocks */ - if(state_flip > 0) + if (state_flip > 0) astribank_uevent_send(xbus, KOBJ_ONLINE); - else if(state_flip < 0) + else if (state_flip < 0) astribank_uevent_send(xbus, KOBJ_OFFLINE); return ret; bad_state: @@ -1341,7 +1341,7 @@ void xbus_deactivate(xbus_t *xbus) { BUG_ON(!xbus); XBUS_INFO(xbus, "[%s] Deactivating\n", xbus->label); - if(!xbus_setstate(xbus, XBUS_STATE_DEACTIVATING)) + if (!xbus_setstate(xbus, XBUS_STATE_DEACTIVATING)) return; xbus_request_sync(xbus, SYNC_MODE_NONE); /* no more ticks */ elect_syncer("deactivate"); @@ -1386,15 +1386,15 @@ static xbus_t *xbus_alloc(void) int i; xbus = KZALLOC(sizeof(xbus_t), GFP_KERNEL); - if(!xbus) { + if (!xbus) { ERR("%s: out of memory\n", __func__); return NULL; } spin_lock_irqsave(&xbuses_lock, flags); - for(i = 0; i < MAX_BUSES; i++) - if(xbuses_array[i].xbus == NULL) + for (i = 0; i < MAX_BUSES; i++) + if (xbuses_array[i].xbus == NULL) break; - if(i >= MAX_BUSES) { + if (i >= MAX_BUSES) { ERR("%s: No free slot for new bus. i=%d\n", __func__, i); KZFREE(xbus); xbus = NULL; @@ -1414,7 +1414,7 @@ void xbus_free(xbus_t *xbus) unsigned long flags; uint num; - if(!xbus) + if (!xbus) return; XBUS_DBG(DEVICES, xbus, "Free\n"); spin_lock_irqsave(&xbuses_lock, flags); @@ -1423,14 +1423,14 @@ void xbus_free(xbus_t *xbus) BUG_ON(xbus != xbuses_array[num].xbus); spin_unlock_irqrestore(&xbuses_lock, flags); #ifdef CONFIG_PROC_FS - if(xbus->proc_xbus_dir) { - if(xbus->proc_xbus_summary) { + if (xbus->proc_xbus_dir) { + if (xbus->proc_xbus_summary) { XBUS_DBG(PROC, xbus, "Removing proc '%s'\n", PROC_XBUS_SUMMARY); remove_proc_entry(PROC_XBUS_SUMMARY, xbus->proc_xbus_dir); xbus->proc_xbus_summary = NULL; } #ifdef PROTOCOL_DEBUG - if(xbus->proc_xbus_command) { + if (xbus->proc_xbus_command) { XBUS_DBG(PROC, xbus, "Removing proc '%s'\n", PROC_XBUS_COMMAND); remove_proc_entry(PROC_XBUS_COMMAND, xbus->proc_xbus_dir); xbus->proc_xbus_command = NULL; @@ -1455,7 +1455,7 @@ xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size, struct device *tran BUG_ON(!ops); xbus = xbus_alloc(); - if(!xbus) { + if (!xbus) { ERR("%s: Failed allocating new xbus\n", __func__); return NULL; } @@ -1475,7 +1475,7 @@ xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size, struct device *tran xbus->sync_mode = SYNC_MODE_NONE; xbus->sync_mode_default = SYNC_MODE_PLL; err = xbus_sysfs_create(xbus); - if(err) { + if (err) { XBUS_ERR(xbus, "SYSFS creation failed: %d\n", err); goto nobus; } @@ -1489,7 +1489,7 @@ xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size, struct device *tran #ifdef CONFIG_PROC_FS XBUS_DBG(PROC, xbus, "Creating xbus proc directory\n"); xbus->proc_xbus_dir = proc_mkdir(xbus->busname, xpp_proc_toplevel); - if(!xbus->proc_xbus_dir) { + if (!xbus->proc_xbus_dir) { XBUS_ERR(xbus, "Failed to create proc directory\n"); err = -EIO; goto nobus; @@ -1543,7 +1543,7 @@ void xbus_reset_counters(xbus_t *xbus) int i; XBUS_DBG(GENERAL, xbus, "Reseting counters\n"); - for(i = 0; i < XBUS_COUNTER_MAX; i++) { + for (i = 0; i < XBUS_COUNTER_MAX; i++) { xbus->counters[i] = 0; } } @@ -1650,7 +1650,7 @@ static int xbus_read_proc(char *page, char **start, off_t off, int count, int *e int i = (int)((unsigned long)data); xbus = get_xbus(__func__, i); /* until end of xbus_read_proc */ - if(!xbus) + if (!xbus) goto out; spin_lock_irqsave(&xbus->lock, flags); @@ -1665,7 +1665,7 @@ static int xbus_read_proc(char *page, char **start, off_t off, int count, int *e len += xbus_fill_proc_queue(page + len, &xbus->command_queue); len += xbus_fill_proc_queue(page + len, &xbus->receive_queue); len += xbus_fill_proc_queue(page + len, &xbus->pcm_tospan); - if(rx_tasklet) { + if (rx_tasklet) { len += sprintf(page + len, "\ncpu_rcv_intr: "); for_each_online_cpu(i) len += sprintf(page + len, "%5d ", xbus->cpu_rcv_intr[i]); @@ -1694,7 +1694,7 @@ static int xbus_read_proc(char *page, char **start, off_t off, int count, int *e len += sprintf(page + len, "\tPCM RX: min=%ld max=%ld\n", xbus->min_rx_sync, xbus->max_rx_sync); len += sprintf(page + len, "COUNTERS:\n"); - for(i = 0; i < XBUS_COUNTER_MAX; i++) { + for (i = 0; i < XBUS_COUNTER_MAX; i++) { len += sprintf(page + len, "\t%-15s = %d\n", xbus_counters[i].name, xbus->counters[i]); } @@ -1727,15 +1727,15 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer, const size_t max_len = xbus->transport.max_send_size; const size_t max_text = max_len * 3 + 10; - if(count > max_text) { + if (count > max_text) { XBUS_ERR(xbus, "%s: line too long (%ld > %zd)\n", __func__, count, max_len); return -EFBIG; } /* 3 bytes per hex-digit and space */ buf = kmalloc(max_text, GFP_KERNEL); - if(!buf) + if (!buf) return -ENOMEM; - if(copy_from_user(buf, buffer, count)) { + if (copy_from_user(buf, buffer, count)) { count = -EINVAL; goto out; } @@ -1747,15 +1747,15 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer, * as the binary representation is shorter */ q = pack_start = buf; - for(p = buf; *p;) { + for (p = buf; *p;) { int val; char hexdigit[3]; - while(*p && isspace(*p)) // skip whitespace + while (*p && isspace(*p)) // skip whitespace p++; - if(!(*p)) + if (!(*p)) break; - if(!isxdigit(*p)) { + if (!isxdigit(*p)) { XBUS_ERR(xbus, "%s: bad hex value ASCII='0x%X' at position %ld\n", __func__, *p, (long)(p - buf)); count = -EINVAL; @@ -1764,9 +1764,9 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer, hexdigit[0] = *p++; hexdigit[1] = '\0'; hexdigit[2] = '\0'; - if(isxdigit(*p)) + if (isxdigit(*p)) hexdigit[1] = *p++; - if(sscanf(hexdigit, "%2X", &val) != 1) { + if (sscanf(hexdigit, "%2X", &val) != 1) { XBUS_ERR(xbus, "%s: bad hex value '%s' at position %ld\n", __func__, hexdigit, (long)(p - buf)); count = -EINVAL; @@ -1777,11 +1777,11 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer, } len = q - pack_start; xframe = ALLOC_SEND_XFRAME(xbus); - if(!xframe) { + if (!xframe) { count = -ENOMEM; goto out; } - if(len > max_len) + if (len > max_len) len = max_len; atomic_set(&xframe->frame_len, len); memcpy(xframe->packets, pack_start, len); /* FIXME: checksum? */ @@ -1799,10 +1799,10 @@ static int read_proc_xbuses(char *page, char **start, off_t off, int count, int int len = 0; int i; - for(i = 0; i < MAX_BUSES; i++) { + for (i = 0; i < MAX_BUSES; i++) { xbus_t *xbus = get_xbus(__func__, i); - if(xbus) { + if (xbus) { len += sprintf(page + len, "%s: CONNECTOR=%s LABEL=[%s] STATUS=%s\n", xbus->busname, xbus->connector, @@ -1857,7 +1857,7 @@ static void transport_destroy(xbus_t *xbus) atomic_read(&xbus->transport.transport_refcount)); ret = wait_event_interruptible(xbus->transport.transport_unused, atomic_read(&xbus->transport.transport_refcount) == 0); - if(ret) + if (ret) XBUS_ERR(xbus, "Waiting for transport_refcount interrupted!!!\n"); xbus->transport.ops = NULL; xbus->transport.priv = NULL; @@ -1870,7 +1870,7 @@ struct xbus_ops *transportops_get(xbus_t *xbus) BUG_ON(!xbus); atomic_inc(&xbus->transport.transport_refcount); ops = xbus->transport.ops; - if(!ops) + if (!ops) atomic_dec(&xbus->transport.transport_refcount); /* fall through */ return ops; @@ -1883,7 +1883,7 @@ void transportops_put(xbus_t *xbus) BUG_ON(!xbus); ops = xbus->transport.ops; BUG_ON(!ops); - if(atomic_dec_and_test(&xbus->transport.transport_refcount)) + if (atomic_dec_and_test(&xbus->transport.transport_refcount)) wake_up(&xbus->transport.transport_unused); } @@ -1892,7 +1892,7 @@ static void xbus_core_cleanup(void) { finalize_xbuses_array(); #ifdef CONFIG_PROC_FS - if(proc_xbuses) { + if (proc_xbuses) { DBG(PROC, "Removing " PROC_XBUSES " from proc\n"); remove_proc_entry(PROC_XBUSES, xpp_proc_toplevel); proc_xbuses = NULL; @@ -1917,7 +1917,7 @@ int __init xbus_core_init(void) } SET_PROC_DIRENTRY_OWNER(proc_xbuses); #endif - if((ret = xpp_driver_init()) < 0) + if ((ret = xpp_driver_init()) < 0) goto err; return 0; err: diff --git a/drivers/dahdi/xpp/xbus-pcm.c b/drivers/dahdi/xpp/xbus-pcm.c index 44168b9..d48ae56 100644 --- a/drivers/dahdi/xpp/xbus-pcm.c +++ b/drivers/dahdi/xpp/xbus-pcm.c @@ -92,9 +92,9 @@ static void ticker_set_cycle(struct xpp_ticker *ticker, int cycle) unsigned long flags; spin_lock_irqsave(&ticker->lock, flags); - if(cycle < SYNC_ADJ_QUICK) + if (cycle < SYNC_ADJ_QUICK) cycle = SYNC_ADJ_QUICK; - if(cycle > SYNC_ADJ_SLOW) + if (cycle > SYNC_ADJ_SLOW) cycle = SYNC_ADJ_SLOW; ticker->cycle = cycle; spin_unlock_irqrestore(&ticker->lock, flags); @@ -117,7 +117,7 @@ static int xpp_ticker_step(struct xpp_ticker *ticker, const struct timeval *t) spin_lock_irqsave(&ticker->lock, flags); ticker->last_sample.tv = *t; - if((ticker->count % ticker->cycle) == ticker->cycle - 1) { /* rate adjust */ + if ((ticker->count % ticker->cycle) == ticker->cycle - 1) { /* rate adjust */ usec = (long)usec_diff( &ticker->last_sample.tv, &ticker->first_sample.tv); @@ -156,9 +156,9 @@ void xpp_drift_init(xbus_t *xbus) #ifdef SAMPLE_TICKS static void sample_tick(xbus_t *xbus, int sample) { - if(!xbus->sample_running) + if (!xbus->sample_running) return; - if(xbus->sample_pos < SAMPLE_SIZE) + if (xbus->sample_pos < SAMPLE_SIZE) xbus->sample_ticks[xbus->sample_pos++] = sample; else { xbus->sample_running = 0; @@ -194,13 +194,13 @@ 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) { + 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) { + if (lost_ticks) { static int rate_limit; /* @@ -209,7 +209,7 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) */ di->lost_ticks++; di->lost_tick_count += abs(lost_ticks); - if((rate_limit++ % 1003) == 0) { + if ((rate_limit++ % 1003) == 0) { /* FIXME: This should be a NOTICE. * However we have several false ones at * startup. @@ -218,7 +218,7 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) lost_ticks, (abs(lost_ticks) > 1) ? "s": ""); } - if(abs(lost_ticks) > 100) { + if (abs(lost_ticks) > 100) { xbus_drift_clear(xbus); ticker->count = ref_ticker->count; } @@ -231,7 +231,7 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) if ((ticker->count % SYNC_CYCLE) > (SYNC_CYCLE - SYNC_CYCLE_SAMPLE)) di->delta_sum += usec_delta; - if((ticker->count % SYNC_CYCLE) == 0) { + if ((ticker->count % SYNC_CYCLE) == 0) { /* * Full sampling cycle passed. Let's calculate */ @@ -263,9 +263,9 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) di->min_speed = speed; if (speed > di->max_speed) di->max_speed = speed; - if(offset > di->offset_max) + if (offset > di->offset_max) di->offset_max = offset; - if(offset < di->offset_min) + 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", @@ -273,16 +273,16 @@ static void xpp_drift_step(xbus_t *xbus, const struct timeval *tv) 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; - if(ticker->count >= SYNC_CYCLE * SYNC_CONVERGE) { + if (ticker->count >= SYNC_CYCLE * SYNC_CONVERGE) { 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) + if (di->max_speed > best_speed) di->max_speed--; - if(di->min_speed < best_speed) + if (di->min_speed < best_speed) di->min_speed++; } di->offset_prev = offset; @@ -301,7 +301,7 @@ const char *sync_mode_name(enum sync_mode mode) [SYNC_MODE_PLL] = "PLL", [SYNC_MODE_QUERY] = "QUERY", }; - if(mode >= ARRAY_SIZE(sync_mode_names)) + if (mode >= ARRAY_SIZE(sync_mode_names)) return NULL; return sync_mode_names[mode]; } @@ -311,20 +311,20 @@ 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) + if (ref_ticker != &dahdi_ticker) ref_ticker = NULL; return; } - if(syncer != xbus && on) { + if (syncer != xbus && on) { XBUS_DBG(SYNC, xbus, "New syncer\n"); syncer = xbus; - } else if(syncer == xbus && !on) { + } else if (syncer == xbus && !on) { XBUS_DBG(SYNC, xbus, "Lost syncer\n"); syncer = NULL; - if(ref_ticker != &dahdi_ticker) + if (ref_ticker != &dahdi_ticker) ref_ticker = NULL; } else XBUS_DBG(SYNC, xbus, "ignore %s (current syncer: %s)\n", @@ -340,22 +340,22 @@ static void xbus_command_timer(unsigned long param) BUG_ON(!xbus); do_gettimeofday(&now); xbus_command_queue_tick(xbus); - if(!xbus->self_ticking) + if (!xbus->self_ticking) mod_timer(&xbus->command_timer, jiffies + 1); /* Must be 1KHz rate */ } void xbus_set_command_timer(xbus_t *xbus, bool on) { XBUS_DBG(SYNC, xbus, "%s\n", (on)?"ON":"OFF"); - if(on) { - if(!timer_pending(&xbus->command_timer)) { + if (on) { + if (!timer_pending(&xbus->command_timer)) { XBUS_DBG(SYNC, xbus, "add_timer\n"); xbus->command_timer.function = xbus_command_timer; xbus->command_timer.data = (unsigned long)xbus; xbus->command_timer.expires = jiffies + 1; add_timer(&xbus->command_timer); } - } else if(timer_pending(&xbus->command_timer)) { + } else if (timer_pending(&xbus->command_timer)) { XBUS_DBG(SYNC, xbus, "del_timer\n"); del_timer(&xbus->command_timer); } @@ -373,14 +373,14 @@ void got_new_syncer(xbus_t *xbus, enum sync_mode mode, int drift) spin_lock_irqsave(&xbus->lock, flags); spin_lock_irqsave(&ref_ticker_lock, flags2); xbus->sync_adjustment = (signed char)drift; - if(xbus->sync_mode == mode) { + if (xbus->sync_mode == mode) { XBUS_DBG(SYNC, xbus, "Already in mode '%s'. Ignored\n", 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)); - switch(mode) { + switch (mode) { case SYNC_MODE_AB: xbus->sync_mode = mode; xbus_set_command_timer(xbus, 0); @@ -415,7 +415,7 @@ void xbus_request_sync(xbus_t *xbus, enum sync_mode mode) BUG_ON(!xbus); XBUS_DBG(SYNC, xbus, "sent request (mode=%d)\n", mode); CALL_PROTO(GLOBAL, SYNC_SOURCE, xbus, NULL, mode, 0); - if(mode == SYNC_MODE_NONE) { + if (mode == SYNC_MODE_NONE) { /* * We must deselect the syncer *now* and not wait for the * reply from the AB. Otherwise, a disconnect of the syncing @@ -439,7 +439,7 @@ static void reset_sync_counters(void) int i; //DBG(SYNC, "%d\n", atomic_read(&xpp_tick_counter)); - for(i = 0; i < MAX_BUSES; i++) { + for (i = 0; i < MAX_BUSES; i++) { xbus_t *xbus = get_xbus(__func__, i); if (xbus == NULL) @@ -450,8 +450,8 @@ static void reset_sync_counters(void) * - Or maybe they didn't answer us in the first place (e.g: wrong firmware version, etc). */ - if(xbus->self_ticking) { - if(!XBUS_FLAGS(xbus, CONNECTED)) { + if (xbus->self_ticking) { + if (!XBUS_FLAGS(xbus, CONNECTED)) { XBUS_DBG(GENERAL, xbus, "Dropped packet. Is shutting down.\n"); } else { @@ -470,14 +470,14 @@ static void send_drift(xbus_t *xbus, int drift) BUG_ON(abs(drift) > SYNC_ADJ_MAX); do_gettimeofday(&now); - if(drift > xbus->sync_adjustment) + if (drift > xbus->sync_adjustment) 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); - if(!disable_pll_sync) + if (!disable_pll_sync) CALL_PROTO(GLOBAL, SYNC_SOURCE, xbus, NULL, SYNC_MODE_PLL, drift); xbus->pll_updated_at = now.tv_sec; } @@ -488,7 +488,7 @@ static void global_tick(void) do_gettimeofday(&now); atomic_inc(&xpp_tick_counter); - if((atomic_read(&xpp_tick_counter) % BIG_TICK_INTERVAL) == 0) + if ((atomic_read(&xpp_tick_counter) % BIG_TICK_INTERVAL) == 0) reset_sync_counters(); xpp_ticker_step(&global_ticks_series, &now); } @@ -501,35 +501,35 @@ void dahdi_sync_tick(struct dahdi_span *span, int is_master) static int redundant_ticks; /* for extra spans */ struct timeval now; - if(!force_dahdi_sync) + if (!force_dahdi_sync) goto noop; do_gettimeofday(&now); BUG_ON(!xpd); /* * Detect if any of our spans is dahdi sync master */ - if(is_master) { + if (is_master) { static int rate_limit; - if((rate_limit++ % 10003) == 0) + if ((rate_limit++ % 10003) == 0) 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) { + if (syncer) { static int rate_limit; - if((rate_limit++ % 5003) == 0) + if ((rate_limit++ % 5003) == 0) XBUS_DBG(SYNC, syncer, "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 ((redundant_ticks++ % total_registered_spans()) != 0) { #if 0 static int rate_limit; - if((rate_limit++ % 1003) < 16) + if ((rate_limit++ % 1003) < 16) XPD_NOTICE(xpd, "boop (%d)\n", dahdi_tick_count); #endif goto noop; @@ -571,9 +571,9 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi) * they'll revert it to PLL instead of AB. */ spin_lock_irqsave(&ref_ticker_lock, flags); - if(syncer) + if (syncer) xbus_drift_clear(syncer); /* Clean old data */ - if(new_syncer) { + if (new_syncer) { XBUS_DBG(SYNC, new_syncer, "pcm_rx_counter=%d\n", atomic_read(&new_syncer->pcm_rx_counter)); force_dahdi_sync = 0; @@ -581,7 +581,7 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi) xbus_drift_clear(new_syncer); /* Clean new data */ xpp_set_syncer(new_syncer, 1); xbus_request_sync(new_syncer, SYNC_MODE_AB); - } else if(force_dahdi_sync) { + } else if (force_dahdi_sync) { ref_ticker = &dahdi_ticker; } else { ref_ticker = NULL; @@ -589,12 +589,12 @@ static void update_sync_master(xbus_t *new_syncer, bool force_dahdi) spin_unlock_irqrestore(&ref_ticker_lock, flags); DBG(SYNC, "stop unwanted syncers\n"); /* Shut all down except the wanted sync master */ - for(i = 0; i < MAX_BUSES; i++) { + for (i = 0; i < MAX_BUSES; i++) { xbus_t *xbus = get_xbus(__func__, i); if (xbus == NULL) continue; - if(XBUS_FLAGS(xbus, CONNECTED) && xbus != new_syncer) { - if(xbus->self_ticking) + if (XBUS_FLAGS(xbus, CONNECTED) && xbus != new_syncer) { + if (xbus->self_ticking) xbus_request_sync(xbus, xbus->sync_mode_default); else @@ -616,19 +616,19 @@ void elect_syncer(const char *msg) spin_lock_irqsave(&elect_syncer_lock, flags); DBG(SYNC, "%s: %s syncer=%s\n", __func__, msg, (syncer) ? syncer->busname : "NULL"); - for(i = 0; i < MAX_BUSES; i++) { + for (i = 0; i < MAX_BUSES; i++) { xbus_t *xbus = get_xbus(__func__, i); if (xbus == NULL) continue; - if(XBUS_IS(xbus, READY)) { - if(!the_xbus) + if (XBUS_IS(xbus, READY)) { + if (!the_xbus) the_xbus = xbus; /* First candidate */ - for(j = 0; j < MAX_XPDS; j++) { + for (j = 0; j < MAX_XPDS; j++) { 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); if (prio < 0) { @@ -644,10 +644,10 @@ void elect_syncer(const char *msg) } put_xbus(__func__, xbus); } - if(best_xpd) { + if (best_xpd) { the_xbus = best_xpd->xbus; XPD_DBG(SYNC, best_xpd, "%s: elected with priority %d\n", msg, timing_priority); - } else if(the_xbus) { + } else if (the_xbus) { XBUS_DBG(SYNC, the_xbus, "%s: elected\n", msg); } else { unsigned long flags; @@ -658,7 +658,7 @@ void elect_syncer(const char *msg) spin_unlock_irqrestore(&ref_ticker_lock, flags); the_xbus = NULL; } - if(the_xbus != syncer) + if (the_xbus != syncer) update_sync_master(the_xbus, force_dahdi_sync); spin_unlock_irqrestore(&elect_syncer_lock, flags); } @@ -694,13 +694,13 @@ 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)) + if (IS_SET(pcm_mask, i)) line_count++; /* * FIXME: Workaround a bug in sync code of the Astribank. * Send dummy PCM for sync. */ - if(xpd->addr.unit == 0 && pcm_mask == 0) { + if (xpd->addr.unit == 0 && pcm_mask == 0) { pcm_mask = BIT(0); line_count = 1; } @@ -727,7 +727,7 @@ void fill_beep(u_char *buf, int num, int duration) static u_char beep_alt[] = { 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, /* silence */ }; - if(alternate) { + if (alternate) { which = num % ARRAY_SIZE(beep_alt); snd = &beep_alt[which]; } else { @@ -744,9 +744,9 @@ static void do_ec(xpd_t *xpd) 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 */ + 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); @@ -790,15 +790,15 @@ static bool pcm_valid(xpd_t *xpd, xpacket_t *pack) * ignore the channels of the other xpd's in the same unit. */ for (i = 0; i < CHANNELS_PERXPD; i++) - if(IS_SET(lines, i)) + if (IS_SET(lines, i)) count++; /* FRAMES: include opcode in calculation */ good_len = RPACKET_HEADERSIZE + sizeof(xpp_line_t) + count * 8; - if(XPACKET_LEN(pack) != good_len) { + if (XPACKET_LEN(pack) != good_len) { static int rate_limit; XPD_COUNTER(xpd, RECV_ERRORS)++; - if((rate_limit++ % 1000) <= 10) { + 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); dump_packet("BAD PCM REPLY", pack, 1); @@ -818,29 +818,29 @@ static inline void pcm_frame_out(xbus_t *xbus, xframe_t *xframe) spin_lock_irqsave(&xbus->lock, flags); do_gettimeofday(&now); - if(unlikely(disable_pcm || !XBUS_IS(xbus, READY))) + if (unlikely(disable_pcm || !XBUS_IS(xbus, READY))) goto dropit; - if(XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) { + if (XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) { 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(abs(usec - 1000) > TICK_TOLERANCE) { + if (likely(atomic_read(&xbus->pcm_rx_counter) > BIG_TICK_INTERVAL)) { + if (abs(usec - 1000) > TICK_TOLERANCE) { static int rate_limit; - if((rate_limit++ % 5003) == 0) + if ((rate_limit++ % 5003) == 0) XBUS_DBG(SYNC, xbus, "Bad PCM TX timing(%d): usec=%ld.\n", rate_limit, usec); } - if(usec > xbus->max_tx_sync) + if (usec > xbus->max_tx_sync) xbus->max_tx_sync = usec; - if(usec < xbus->min_tx_sync) + if (usec < xbus->min_tx_sync) xbus->min_tx_sync = usec; } } 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)++; @@ -870,12 +870,12 @@ void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack) for (i = 0; i < PHONEDEV(xpd).channels; i++) { struct dahdi_chan *chan = XPD_CHAN(xpd, i); - if(IS_SET(wanted_lines, i)) { - if(SPAN_REGISTERED(xpd)) { + if (IS_SET(wanted_lines, i)) { + if (SPAN_REGISTERED(xpd)) { #ifdef DEBUG_PCMTX int channo = chan->channo; - if(pcmtx >= 0 && pcmtx_chan == channo) + if (pcmtx >= 0 && pcmtx_chan == channo) memset((u_char *)pcm, pcmtx, DAHDI_CHUNKSIZE); else #endif @@ -905,20 +905,20 @@ void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) */ pcm_mute = ~(PHONEDEV(xpd).wanted_pcm_mask); pcm_mute |= PHONEDEV(xpd).mute_dtmf | PHONEDEV(xpd).silence_pcm; - if(!SPAN_REGISTERED(xpd)) + 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); - if(got_data && !IS_SET(pcm_mute, i)) { + if (got_data && !IS_SET(pcm_mute, i)) { /* We have and want real data */ // 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)) { + if (IS_SET(PHONEDEV(xpd).silence_pcm, i)) { /* * This will clear the EC buffers until next tick * So we don't have noise residues from the past. @@ -927,7 +927,7 @@ void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack) memset(PHONEDEV(xpd).ec_chunk1[i], 0x7F, DAHDI_CHUNKSIZE); } } - if(got_data) + if (got_data) pcm += DAHDI_CHUNKSIZE; } out: @@ -968,7 +968,7 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe) byte *p; int ret = -EPROTO; /* Assume error */ - if(debug & DBG_PCM) + if (debug & DBG_PCM) dump_xframe("RX_XFRAME_PCM", xbus, xframe, debug); /* handle content */ @@ -981,10 +981,10 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe) pack = (xpacket_t *)p; len = XPACKET_LEN(pack); /* Sanity checks */ - if(unlikely(XPACKET_OP(pack) != XPROTO_NAME(GLOBAL,PCM_READ))) { + if (unlikely(XPACKET_OP(pack) != XPROTO_NAME(GLOBAL,PCM_READ))) { static int rate_limit; - if((rate_limit++ % 1003) == 0) { + if ((rate_limit++ % 1003) == 0) { XBUS_NOTICE(xbus, "%s: Non-PCM packet within a PCM xframe. (%d)\n", __func__, rate_limit); @@ -993,10 +993,10 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe) goto out; } p += len; - if(p > xframe_end || len < RPACKET_HEADERSIZE) { + if (p > xframe_end || len < RPACKET_HEADERSIZE) { static int rate_limit; - if((rate_limit++ % 1003) == 0) { + if ((rate_limit++ % 1003) == 0) { XBUS_NOTICE(xbus, "%s: Invalid packet length %d. (%d)\n", __func__, len, rate_limit); @@ -1005,22 +1005,22 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe) goto out; } xpd = xpd_byaddr(xbus, XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack)); - if(unlikely(!xpd)) { + if (unlikely(!xpd)) { static int rate_limit; - if((rate_limit++ % 1003) == 0) { + if ((rate_limit++ % 1003) == 0) { notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), "RECEIVE PCM"); dump_xframe("Unknown XPD addr", xbus, xframe, debug); } goto out; } - if(!pcm_valid(xpd, pack)) + if (!pcm_valid(xpd, pack)) goto out; - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { XBUS_COUNTER(xbus, RX_PACK_PCM)++; CALL_PHONE_METHOD(card_pcm_tospan, xpd, pack); } - } while(p < xframe_end); + } while (p < xframe_end); ret = 0; /* all good */ XBUS_COUNTER(xbus, RX_XFRAME_PCM)++; out: @@ -1044,9 +1044,9 @@ static void xbus_tick(xbus_t *xbus) /* * Update dahdi */ - for(i = 0; i < MAX_XPDS; i++) { + for (i = 0; i < MAX_XPDS; i++) { xpd = xpd_of(xbus, i); - if(xpd && SPAN_REGISTERED(xpd)) { + if (xpd && SPAN_REGISTERED(xpd)) { #ifdef OPTIMIZE_CHANMUTE int j; xpp_line_t xmit_mask = PHONEDEV(xpd).wanted_pcm_mask; @@ -1069,28 +1069,28 @@ static void xbus_tick(xbus_t *xbus) /* * Fill xframes */ - for(i = 0; i < MAX_XPDS; i++) { - if((xpd = xpd_of(xbus, i)) == NULL) + for (i = 0; i < MAX_XPDS; i++) { + if ((xpd = xpd_of(xbus, i)) == NULL) continue; if (!IS_PHONEDEV(xpd)) continue; - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { size_t pcm_len = PHONEDEV(xpd).pcm_len; - if(pcm_len && xpd->card_present) { + if (pcm_len && xpd->card_present) { do { // pack = NULL; /* FORCE single packet frames */ - if(xframe && !pack) { /* FULL frame */ + if (xframe && !pack) { /* FULL frame */ pcm_frame_out(xbus, xframe); xframe = NULL; XBUS_COUNTER(xbus, TX_PCM_FRAG)++; } - if(!xframe) { /* Alloc frame */ + 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__); @@ -1098,10 +1098,10 @@ static void xbus_tick(xbus_t *xbus) } } pack = xframe_next_packet(xframe, pcm_len); - } while(!pack); + } while (!pack); XPACKET_INIT(pack, GLOBAL, PCM_WRITE, xpd->xbus_idx, 1, 0); XPACKET_LEN(pack) = pcm_len; - if(!sent_sync_bit) { + if (!sent_sync_bit) { XPACKET_ADDR_SYNC(pack) = 1; sent_sync_bit = 1; } @@ -1110,14 +1110,14 @@ static void xbus_tick(xbus_t *xbus) } } } - if(xframe) /* clean any leftovers */ + if (xframe) /* clean any leftovers */ pcm_frame_out(xbus, xframe); /* * Receive PCM */ - while((xframe = xframe_dequeue(&xbus->pcm_tospan)) != NULL) { + while ((xframe = xframe_dequeue(&xbus->pcm_tospan)) != NULL) { copy_pcm_tospan(xbus, xframe); - if(XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) { + if (XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) { struct timeval now; unsigned long usec; @@ -1125,27 +1125,27 @@ static void xbus_tick(xbus_t *xbus) 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(abs(usec - 1000) > TICK_TOLERANCE) { + if (likely(atomic_read(&xbus->pcm_rx_counter) > BIG_TICK_INTERVAL)) { + if (abs(usec - 1000) > TICK_TOLERANCE) { static int rate_limit; - if((rate_limit++ % 5003) == 0) + if ((rate_limit++ % 5003) == 0) XBUS_DBG(SYNC, xbus, "Bad PCM RX timing(%d): usec=%ld.\n", rate_limit, usec); } - if(usec > xbus->max_rx_sync) + if (usec > xbus->max_rx_sync) xbus->max_rx_sync = usec; - if(usec < xbus->min_rx_sync) + if (usec < xbus->min_rx_sync) xbus->min_rx_sync = usec; } } } - for(i = 0; i < MAX_XPDS; i++) { + for (i = 0; i < MAX_XPDS; i++) { xpd = xpd_of(xbus, i); - if(!xpd || !xpd->card_present) + if (!xpd || !xpd->card_present) continue; if (IS_PHONEDEV(xpd)) { - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { do_ec(xpd); dahdi_receive(&PHONEDEV(xpd).span); } @@ -1166,22 +1166,22 @@ static void do_tick(xbus_t *xbus, const struct timeval *tv_received) unsigned long flags; xbus_command_queue_tick(xbus); - if(global_ticker == xbus) + 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); spin_unlock_irqrestore(&ref_ticker_lock, flags); - if(likely(xbus->self_ticking)) + if (likely(xbus->self_ticking)) xbus_tick(xbus); xbus->global_counter = counter; } void xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe) { - if(!xframe_enqueue(&xbus->pcm_tospan, xframe)) { + if (!xframe_enqueue(&xbus->pcm_tospan, xframe)) { static int rate_limit; - if((rate_limit++ % 1003) == 0) + if ((rate_limit++ % 1003) == 0) XBUS_DBG(SYNC, xbus, "Failed to enqueue received pcm frame. (%d)\n", rate_limit); @@ -1192,7 +1192,7 @@ void xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe) * of the frame, regardless of the XPD that is sync master. * FIXME: what about PRI split? */ - if(XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) { + if (XPACKET_ADDR_SYNC((xpacket_t *)xframe->packets)) { do_tick(xbus, &xframe->tv_received); atomic_inc(&xbus->pcm_rx_counter); } else @@ -1205,10 +1205,10 @@ int exec_sync_command(const char *buf, size_t count) int xbusno; xbus_t *xbus; - if(strncmp("DAHDI", buf, 6) == 0) { /* Ignore the newline */ + if (strncmp("DAHDI", buf, 6) == 0) { /* Ignore the newline */ DBG(SYNC, "DAHDI"); update_sync_master(NULL, 1); - } else if(sscanf(buf, "SYNC=%d", &xbusno) == 1) { + } else if (sscanf(buf, "SYNC=%d", &xbusno) == 1) { DBG(SYNC, "SYNC=%d\n", xbusno); xbus = get_xbus(__func__, xbusno); if (xbus == NULL) { @@ -1217,7 +1217,7 @@ int exec_sync_command(const char *buf, size_t count) } update_sync_master(xbus, 0); put_xbus(__func__, xbus); - } else if(sscanf(buf, "QUERY=%d", &xbusno) == 1) { + } else if (sscanf(buf, "QUERY=%d", &xbusno) == 1) { DBG(SYNC, "QUERY=%d\n", xbusno); xbus = get_xbus(__func__, xbusno); if (xbus == NULL) { @@ -1237,7 +1237,7 @@ int fill_sync_string(char *buf, size_t count) { int len = 0; - if(!syncer) { + if (!syncer) { len += snprintf(buf, count, "%s\n", (force_dahdi_sync) ? "DAHDI" : "NO-SYNC"); } else diff --git a/drivers/dahdi/xpp/xbus-sysfs.c b/drivers/dahdi/xpp/xbus-sysfs.c index c0aaf45..3a20ef0 100644 --- a/drivers/dahdi/xpp/xbus-sysfs.c +++ b/drivers/dahdi/xpp/xbus-sysfs.c @@ -82,9 +82,9 @@ static DEVICE_ATTR_WRITER(xbus_state_store, dev, buf, count) xbus = dev_to_xbus(dev); XBUS_DBG(GENERAL, xbus, "%s\n", buf); - if(strncmp(buf, "stop", 4) == 0) + if (strncmp(buf, "stop", 4) == 0) xbus_deactivate(xbus); - else if(XBUS_IS(xbus, IDLE) && strncmp(buf, "start", 5) == 0) + else if (XBUS_IS(xbus, IDLE) && strncmp(buf, "start", 5) == 0) xbus_activate(xbus); else { XBUS_NOTICE(xbus, "%s: Illegal action %s in state %s. Ignored.\n", @@ -116,7 +116,7 @@ static DEVICE_ATTR_READER(timing_show, dev, buf) 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) { + if (xbus->sync_mode == SYNC_MODE_PLL) { len += snprintf(buf + len, PAGE_SIZE - len, " %5d: lost (%4d,%4d) : ", xbus->ticker.cycle, @@ -146,10 +146,10 @@ static DEVICE_ATTR_READER(samples_show, dev, buf) int i; xbus = dev_to_xbus(dev); - if(xbus->sample_running) + if (xbus->sample_running) return -EBUSY; - for(i = 0; i < SAMPLE_SIZE; i++) { - if(len > PAGE_SIZE - 20) + for (i = 0; i < SAMPLE_SIZE; i++) { + if (len > PAGE_SIZE - 20) break; len += snprintf(buf + len, PAGE_SIZE - len, "%d\n", xbus->sample_ticks[i]); } @@ -161,7 +161,7 @@ static DEVICE_ATTR_WRITER(samples_store, dev, buf, count) xbus_t *xbus; xbus = dev_to_xbus(dev); - if(xbus->sample_running) + if (xbus->sample_running) return -EBUSY; memset(xbus->sample_ticks, 0, sizeof(*xbus->sample_ticks)); xbus->sample_pos = 0; @@ -245,10 +245,10 @@ static DEVICE_ATTR_READER(driftinfo_show, dev, buf) uframes_inaccuracy = di->sync_inaccuracy / 125; len += snprintf(buf + len, PAGE_SIZE - len, "%-15s: %8d ", "instability", speed_range + uframes_inaccuracy); - if(xbus->sync_mode == SYNC_MODE_AB) { + if (xbus->sync_mode == SYNC_MODE_AB) { buf[len++] = '-'; } else { - for(i = 0; len < PAGE_SIZE - 1 && i < speed_range + uframes_inaccuracy; i++) + for (i = 0; len < PAGE_SIZE - 1 && i < speed_range + uframes_inaccuracy; i++) buf[len++] = '#'; } buf[len++] = '\n'; @@ -321,11 +321,11 @@ static int astribank_hotplug(struct device *dev, char **envp, int envnum, char * { xbus_t *xbus; - if(!dev) + if (!dev) return -ENODEV; xbus = dev_to_xbus(dev); envp[0] = buff; - if(snprintf(buff, bufsize, "XBUS_NAME=%s", xbus->busname) >= bufsize) + if (snprintf(buff, bufsize, "XBUS_NAME=%s", xbus->busname) >= bufsize) return -ENOMEM; envp[1] = NULL; return 0; @@ -337,7 +337,7 @@ static int astribank_hotplug(struct device *dev, char **envp, int envnum, char * XBUS_ADD_UEVENT_VAR("XPP_INIT_DIR=%s", initdir); \ XBUS_ADD_UEVENT_VAR("XBUS_NUM=%02d", xbus->num); \ XBUS_ADD_UEVENT_VAR("XBUS_NAME=%s", xbus->busname); \ - } while(0) + } while (0) #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) #define XBUS_ADD_UEVENT_VAR(fmt, val...) \ @@ -356,7 +356,7 @@ static int astribank_uevent(struct device *dev, char **envp, int num_envp, char int len = 0; extern char *initdir; - if(!dev) + if (!dev) return -ENODEV; xbus = dev_to_xbus(dev); DBG(GENERAL, "SYFS bus_id=%s xbus=%s\n", dev_name(dev), xbus->busname); @@ -378,7 +378,7 @@ static int astribank_uevent(struct device *dev, struct kobj_uevent_env *kenv) xbus_t *xbus; extern char *initdir; - if(!dev) + if (!dev) return -ENODEV; xbus = dev_to_xbus(dev); DBG(GENERAL, "SYFS bus_id=%s xbus=%s\n", dev_name(dev), xbus->busname); @@ -425,11 +425,11 @@ static void astribank_release(struct device *dev) BUG_ON(!dev); xbus = dev_to_xbus(dev); - if(XBUS_FLAGS(xbus, CONNECTED)) { + if (XBUS_FLAGS(xbus, CONNECTED)) { XBUS_ERR(xbus, "Try to release CONNECTED device.\n"); BUG(); } - if(!XBUS_IS(xbus, IDLE) && !XBUS_IS(xbus, FAIL) && !XBUS_IS(xbus, DEACTIVATED)) { + if (!XBUS_IS(xbus, IDLE) && !XBUS_IS(xbus, FAIL) && !XBUS_IS(xbus, DEACTIVATED)) { XBUS_ERR(xbus, "Try to release in state %s\n", xbus_statename(XBUS_STATE(xbus))); BUG(); @@ -491,7 +491,7 @@ static DEVICE_ATTR_READER(chipregs_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; spin_lock_irqsave(&xpd->lock, flags); regs = &xpd->last_reply; @@ -499,12 +499,12 @@ static DEVICE_ATTR_READER(chipregs_show, dev, buf) len += sprintf(buf + len, "# Consult firmware docs first\n"); len += sprintf(buf + len, "#\n"); do_datah = REG_FIELD(regs, do_datah) ? 1 : 0; - if(do_datah) { + if (do_datah) { snprintf(datah_str, ARRAY_SIZE(datah_str), "\t%02X", REG_FIELD(regs, data_high)); } else datah_str[0] = '\0'; - if(REG_FIELD(regs, do_subreg)) { + if (REG_FIELD(regs, do_subreg)) { len += sprintf(buf + len, "#CH\tOP\tReg.\tSub\tDL%s\n", (do_datah) ? "\tDH" : ""); len += sprintf(buf + len, "%2d\tRS\t%02X\t%02X\t%02X%s\n", @@ -534,27 +534,27 @@ static DEVICE_ATTR_WRITER(chipregs_store, dev, buf, count) BUG_ON(!dev); xpd = dev_to_xpd(dev); //XPD_DBG(GENERAL, xpd, "%s\n", buf); - if(!xpd) + if (!xpd) return -ENODEV; p = buf; - while((p - buf) < count) { + while ((p - buf) < count) { i = strcspn(p, "\r\n"); - if(i > 0) { - if(i >= MAX_PROC_WRITE) { + if (i > 0) { + if (i >= MAX_PROC_WRITE) { XPD_NOTICE(xpd, "Command too long (%d chars)\n", i); return -E2BIG; } memcpy(tmp, p, i); tmp[i] = '\0'; ret = parse_chip_command(xpd, tmp); - if(ret < 0) { + if (ret < 0) { XPD_NOTICE(xpd, "Failed writing command: '%s'\n", tmp); return ret; } } p += i + 1; /* Don't flood command_queue */ - if(xframe_queue_count(&xpd->xbus->command_queue) > 5) + if (xframe_queue_count(&xpd->xbus->command_queue) > 5) msleep(6); } return count; @@ -568,7 +568,7 @@ static DEVICE_ATTR_READER(blink_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; spin_lock_irqsave(&xpd->lock, flags); len += sprintf(buf, "0x%lX\n", xpd->blink_mode); @@ -585,12 +585,12 @@ static DEVICE_ATTR_WRITER(blink_store, dev, buf, count) BUG_ON(!dev); xpd = dev_to_xpd(dev); //XPD_DBG(GENERAL, xpd, "%s\n", buf); - if(!xpd) + if (!xpd) return -ENODEV; blink = simple_strtoul(buf, &endp, 0); - if(*endp != '\0' && *endp != '\n' && *endp != '\r') + if (*endp != '\0' && *endp != '\n' && *endp != '\r') return -EINVAL; - if(blink > 0xFFFF) + if (blink > 0xFFFF) return -EINVAL; XPD_DBG(GENERAL, xpd, "BLINK channels: 0x%lX\n", blink); xpd->blink_mode = blink; @@ -605,7 +605,7 @@ static DEVICE_ATTR_READER(span_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; spin_lock_irqsave(&xpd->lock, flags); len += sprintf(buf, "%d\n", SPAN_REGISTERED(xpd) ? PHONEDEV(xpd).span.spanno : 0); @@ -662,7 +662,7 @@ static DEVICE_ATTR_READER(type_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; len += sprintf(buf, "%s\n", xpd->type_name); return len; @@ -676,12 +676,12 @@ static DEVICE_ATTR_READER(offhook_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; for_each_line(xpd, i) { len += sprintf(buf + len, "%d ", IS_OFFHOOK(xpd, i)); } - if(len) { + if (len) { len--; /* backout last space */ } len += sprintf(buf + len, "\n"); @@ -696,7 +696,7 @@ static DEVICE_ATTR_READER(timing_priority_show, dev, buf) BUG_ON(!dev); xpd = dev_to_xpd(dev); - if(!xpd) + if (!xpd) return -ENODEV; spin_lock_irqsave(&xpd->lock, flags); len += sprintf(buf + len, "%d\n", PHONEDEV(xpd).timing_priority); @@ -724,7 +724,7 @@ static int xpd_match(struct device *dev, struct device_driver *driver) xpd_driver = driver_to_xpd_driver(driver); xpd = dev_to_xpd(dev); - if(xpd_driver->type != xpd->type) { + if (xpd_driver->type != xpd->type) { XPD_DBG(DEVICES, xpd, "SYSFS match fail: xpd->type = %d, xpd_driver->type = %d\n", xpd->type, xpd_driver->type); return 0; @@ -757,7 +757,7 @@ int xpd_driver_register(struct device_driver *driver) DBG(DEVICES, "%s\n", driver->name); driver->bus = &xpd_type; - if((ret = driver_register(driver)) < 0) { + if ((ret = driver_register(driver)) < 0) { ERR("%s: driver_register(%s) failed. Error number %d", __func__, driver->name, ret); } @@ -793,7 +793,7 @@ int xpd_device_register(xbus_t *xbus, xpd_t *xpd) dev_set_drvdata(dev, xpd); dev->release = xpd_release; ret = device_register(dev); - if(ret) { + if (ret) { XPD_ERR(xpd, "%s: device_register failed: %d\n", __func__, ret); return ret; } @@ -809,7 +809,7 @@ void xpd_device_unregister(xpd_t *xpd) BUG_ON(!xbus); XPD_DBG(DEVICES, xpd, "SYSFS\n"); dev = &xpd->xpd_dev; - if(!dev_get_drvdata(dev)) + if (!dev_get_drvdata(dev)) return; BUG_ON(dev_get_drvdata(dev) != xpd); device_unregister(dev); @@ -957,7 +957,7 @@ void xbus_sysfs_remove(xbus_t *xbus) BUG_ON(!xbus); XBUS_DBG(DEVICES, xbus, "\n"); astribank = &xbus->astribank; - if(!dev_get_drvdata(astribank)) + if (!dev_get_drvdata(astribank)) return; BUG_ON(dev_get_drvdata(astribank) != xbus); device_unregister(astribank); @@ -978,7 +978,7 @@ int xbus_sysfs_create(xbus_t *xbus) dev_set_drvdata(astribank, xbus); astribank->release = astribank_release; ret = device_register(astribank); - if(ret) { + if (ret) { XBUS_ERR(xbus, "%s: device_register failed: %d\n", __func__, ret); dev_set_drvdata(astribank, NULL); } @@ -990,17 +990,17 @@ int __init xpp_driver_init(void) int ret; DBG(DEVICES, "SYSFS\n"); - if((ret = bus_register(&toplevel_bus_type)) < 0) { + if ((ret = bus_register(&toplevel_bus_type)) < 0) { ERR("%s: bus_register(%s) failed. Error number %d", __func__, toplevel_bus_type.name, ret); goto failed_toplevel; } - if((ret = driver_register(&xpp_driver)) < 0) { + if ((ret = driver_register(&xpp_driver)) < 0) { ERR("%s: driver_register(%s) failed. Error number %d", __func__, xpp_driver.name, ret); goto failed_xpp_driver; } - if((ret = bus_register(&xpd_type)) < 0) { + if ((ret = bus_register(&xpd_type)) < 0) { ERR("%s: bus_register(%s) failed. Error number %d", __func__, xpd_type.name, ret); goto failed_xpd_bus; diff --git a/drivers/dahdi/xpp/xdefs.h b/drivers/dahdi/xpp/xdefs.h index a97ee9b..aa39266 100644 --- a/drivers/dahdi/xpp/xdefs.h +++ b/drivers/dahdi/xpp/xdefs.h @@ -112,7 +112,7 @@ typedef unsigned char byte; #define KZFREE(p) do { \ memset((p), 0, sizeof(*(p))); \ kfree(p); \ - } while(0); + } while (0); /* * Hotplug replaced with uevent in 2.6.16 @@ -139,9 +139,9 @@ typedef unsigned char byte; ssize_t name(struct device_driver *drv, char * buf) #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30) -#define SET_PROC_DIRENTRY_OWNER(p) do { (p)->owner = THIS_MODULE; } while(0); +#define SET_PROC_DIRENTRY_OWNER(p) do { (p)->owner = THIS_MODULE; } while (0); #else -#define SET_PROC_DIRENTRY_OWNER(p) do { } while(0); +#define SET_PROC_DIRENTRY_OWNER(p) do { } while (0); #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) diff --git a/drivers/dahdi/xpp/xframe_queue.c b/drivers/dahdi/xpp/xframe_queue.c index ce71f86..ac5398a 100644 --- a/drivers/dahdi/xpp/xframe_queue.c +++ b/drivers/dahdi/xpp/xframe_queue.c @@ -50,11 +50,11 @@ static bool __xframe_enqueue(struct xframe_queue *q, xframe_t *xframe) int ret = 1; static int overflow_cnt; - if(unlikely(q->disabled)) { + if (unlikely(q->disabled)) { ret = 0; goto out; } - if(q->count >= q->max_count) { + 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", @@ -71,7 +71,7 @@ static bool __xframe_enqueue(struct xframe_queue *q, xframe_t *xframe) ret = 0; goto out; } - if(++q->count > q->worst_count) + if (++q->count > q->worst_count) q->worst_count = q->count; list_add_tail(&xframe->frame_list, &q->head); do_gettimeofday(&xframe->tv_queued); @@ -97,7 +97,7 @@ static xframe_t *__xframe_dequeue(struct xframe_queue *q) struct timeval now; unsigned long usec_lag; - if(list_empty(&q->head)) + if (list_empty(&q->head)) goto out; h = q->head.next; list_del_init(h); @@ -107,7 +107,7 @@ static xframe_t *__xframe_dequeue(struct xframe_queue *q) usec_lag = (now.tv_sec - frm->tv_queued.tv_sec)*1000*1000 + (now.tv_usec - frm->tv_queued.tv_usec); - if(q->worst_lag_usec < usec_lag) + if (q->worst_lag_usec < usec_lag) q->worst_lag_usec = usec_lag; out: return frm; @@ -135,7 +135,7 @@ void xframe_queue_clear(struct xframe_queue *q) int i = 0; xframe_queue_disable(q, 1); - while((xframe = xframe_dequeue(q)) != NULL) { + while ((xframe = xframe_dequeue(q)) != NULL) { transport_free_xframe(xbus, xframe); i++; } @@ -157,17 +157,17 @@ static xframe_t *transport_alloc_xframe(xbus_t *xbus, gfp_t gfp_flags) BUG_ON(!xbus); ops = transportops_get(xbus); - if(unlikely(!ops)) { + if (unlikely(!ops)) { XBUS_ERR(xbus, "Missing transport\n"); return NULL; } spin_lock_irqsave(&xbus->transport.lock, flags); //XBUS_INFO(xbus, "%s (transport_refcount=%d)\n", __func__, atomic_read(&xbus->transport.transport_refcount)); xframe = ops->alloc_xframe(xbus, gfp_flags); - if(!xframe) { + if (!xframe) { static int rate_limit; - if((rate_limit++ % 3001) == 0) + if ((rate_limit++ % 3001) == 0) XBUS_ERR(xbus, "Failed xframe allocation from transport (%d)\n", rate_limit); @@ -206,33 +206,33 @@ static bool xframe_queue_adjust(struct xframe_queue *q) BUG_ON(!xbus); spin_lock_irqsave(&q->lock, flags); delta = q->count - q->steady_state_count; - if(delta < -XFRAME_QUEUE_MARGIN) { + if (delta < -XFRAME_QUEUE_MARGIN) { /* Increase pool by one frame */ //XBUS_INFO(xbus, "%s(%d): Allocate one\n", q->name, delta); xframe = transport_alloc_xframe(xbus, GFP_ATOMIC); - if(!xframe) { + if (!xframe) { static int rate_limit; - if((rate_limit++ % 3001) == 0) + if ((rate_limit++ % 3001) == 0) XBUS_ERR(xbus, "%s: failed frame allocation\n", q->name); goto out; } - if(!__xframe_enqueue(q, xframe)) { + if (!__xframe_enqueue(q, xframe)) { static int rate_limit; - if((rate_limit++ % 3001) == 0) + if ((rate_limit++ % 3001) == 0) XBUS_ERR(xbus, "%s: failed enqueueing frame\n", q->name); transport_free_xframe(xbus, xframe); goto out; } - } else if(delta > XFRAME_QUEUE_MARGIN) { + } else if (delta > XFRAME_QUEUE_MARGIN) { /* Decrease pool by one frame */ //XBUS_INFO(xbus, "%s(%d): Free one\n", q->name, delta); xframe = __xframe_dequeue(q); - if(!xframe) { + if (!xframe) { static int rate_limit; - if((rate_limit++ % 3001) == 0) + if ((rate_limit++ % 3001) == 0) XBUS_ERR(xbus, "%s: failed dequeueing frame\n", q->name); goto out; } @@ -254,10 +254,10 @@ xframe_t *get_xframe(struct xframe_queue *q) BUG_ON(!xbus); xframe_queue_adjust(q); xframe = xframe_dequeue(q); - if(!xframe) { + if (!xframe) { static int rate_limit; - if((rate_limit++ % 3001) == 0) + if ((rate_limit++ % 3001) == 0) XBUS_ERR(xbus, "%s STILL EMPTY (%d)\n", q->name, rate_limit); return NULL; } @@ -286,7 +286,7 @@ void put_xframe(struct xframe_queue *q, xframe_t *xframe) BUG_ON(!xbus); //XBUS_INFO(xbus, "%s\n", __func__); BUG_ON(!TRANSPORT_EXIST(xbus)); - if(unlikely(!xframe_enqueue(q, xframe))) { + if (unlikely(!xframe_enqueue(q, xframe))) { XBUS_ERR(xbus, "Failed returning xframe to %s\n", q->name); transport_free_xframe(xbus, xframe); return; diff --git a/drivers/dahdi/xpp/xpd.h b/drivers/dahdi/xpp/xpd.h index 8eaa8dd..fcf64f5 100644 --- a/drivers/dahdi/xpp/xpd.h +++ b/drivers/dahdi/xpp/xpd.h @@ -228,7 +228,7 @@ struct xpd { unsigned int timer_count; }; -#define for_each_line(xpd,i) for((i) = 0; (i) < PHONEDEV(xpd).channels; (i)++) +#define for_each_line(xpd,i) for ((i) = 0; (i) < PHONEDEV(xpd).channels; (i)++) #define IS_BRI(xpd) ((xpd)->type == XPD_TYPE_BRI) #define TICK_TOLERANCE 500 /* usec */ @@ -243,7 +243,7 @@ static inline void *my_kzalloc(size_t size, gfp_t flags) void *p; p = kmalloc(size, flags); - if(p) + if (p) memset(p, 0, size); return p; } diff --git a/drivers/dahdi/xpp/xpp_dahdi.c b/drivers/dahdi/xpp/xpp_dahdi.c index a7d263a..9fd00d1 100644 --- a/drivers/dahdi/xpp/xpp_dahdi.c +++ b/drivers/dahdi/xpp/xpp_dahdi.c @@ -92,9 +92,9 @@ void xbus_flip_bit(xbus_t *xbus, unsigned int bitnum0, unsigned int bitnum1) { int num = xbus->num; - if(num == parport_xbuses[0]) + if (num == parport_xbuses[0]) flip_parport_bit(bitnum0); - if(num == parport_xbuses[1]) + if (num == parport_xbuses[1]) flip_parport_bit(bitnum1); } EXPORT_SYMBOL(xbus_flip_bit); @@ -150,8 +150,8 @@ void put_xpd(const char *msg, xpd_t *xpd) static void xpd_proc_remove(xbus_t *xbus, xpd_t *xpd) { #ifdef CONFIG_PROC_FS - if(xpd->proc_xpd_dir) { - if(xpd->proc_xpd_summary) { + if (xpd->proc_xpd_dir) { + if (xpd->proc_xpd_summary) { XPD_DBG(PROC, xpd, "Removing proc '%s'\n", PROC_XPD_SUMMARY); remove_proc_entry(PROC_XPD_SUMMARY, xpd->proc_xpd_dir); xpd->proc_xpd_summary = NULL; @@ -169,13 +169,13 @@ static int xpd_proc_create(xbus_t *xbus, xpd_t *xpd) #ifdef CONFIG_PROC_FS XPD_DBG(PROC, xpd, "Creating proc directory\n"); xpd->proc_xpd_dir = proc_mkdir(xpd->xpdname, xbus->proc_xbus_dir); - if(!xpd->proc_xpd_dir) { + if (!xpd->proc_xpd_dir) { XPD_ERR(xpd, "Failed to create proc directory\n"); goto err; } xpd->proc_xpd_summary = create_proc_read_entry(PROC_XPD_SUMMARY, 0444, xpd->proc_xpd_dir, xpd_read_proc, xpd); - if(!xpd->proc_xpd_summary) { + if (!xpd->proc_xpd_summary) { XPD_ERR(xpd, "Failed to create proc file '%s'\n", PROC_XPD_SUMMARY); goto err; } @@ -193,13 +193,13 @@ void xpd_free(xpd_t *xpd) { xbus_t *xbus = NULL; - if(!xpd) + if (!xpd) return; - if(xpd->xproto) + if (xpd->xproto) xproto_put(xpd->xproto); /* was taken in xpd_alloc() */ xpd->xproto = NULL; xbus = xpd->xbus; - if(!xbus) + if (!xbus) return; XPD_DBG(DEVICES, xpd, "\n"); xpd_proc_remove(xbus, xpd); @@ -233,18 +233,18 @@ int create_xpd(xbus_t *xbus, const xproto_table_t *proto_table, to_phone = BIT(subunit) & port_dir; BUG_ON(!xbus); xpd = xpd_byaddr(xbus, unit, subunit); - if(xpd) { + if (xpd) { XPD_NOTICE(xpd, "XPD at %d%d already exists\n", unit, subunit); return 0; } - if(subunit_ports <= 0 || subunit_ports > CHANNELS_PERXPD) { + if (subunit_ports <= 0 || subunit_ports > CHANNELS_PERXPD) { XBUS_NOTICE(xbus, "Illegal number of ports %d for XPD %d%d\n", subunit_ports, unit, subunit); return 0; } xpd = proto_table->xops->card_new(xbus, unit, subunit, proto_table, subtype, subunits, subunit_ports, to_phone); - if(!xpd) { + if (!xpd) { XBUS_NOTICE(xbus, "card_new(%d,%d,%d,%d,%d) failed. Ignored.\n", unit, subunit, proto_table->type, subtype, to_phone); return -EINVAL; @@ -269,7 +269,7 @@ static int xpd_read_proc(char *page, char **start, off_t off, int count, int *eo xpd_t *xpd = data; int i; - if(!xpd) + if (!xpd) goto out; len += sprintf(page + len, "%s (%s, card %s, span %d)\n" @@ -322,7 +322,7 @@ static int xpd_read_proc(char *page, char **start, off_t off, int count, int *eo len += sprintf(page + len, "%d ", IS_SET(PHONEDEV(xpd).no_pcm, i)); } #if 1 - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { len += sprintf(page + len, "\nPCM:\n | [readchunk] | [writechunk] | W D"); for_each_line(xpd, i) { struct dahdi_chan *chan = XPD_CHAN(xpd, i); @@ -332,22 +332,22 @@ static int xpd_read_proc(char *page, char **start, off_t off, int count, int *eo byte *wp; int j; - if(IS_SET(PHONEDEV(xpd).digital_outputs, i)) + if (IS_SET(PHONEDEV(xpd).digital_outputs, i)) continue; - if(IS_SET(PHONEDEV(xpd).digital_inputs, i)) + if (IS_SET(PHONEDEV(xpd).digital_inputs, i)) continue; - if(IS_SET(PHONEDEV(xpd).digital_signalling, i)) + if (IS_SET(PHONEDEV(xpd).digital_signalling, i)) continue; rp = chan->readchunk; wp = chan->writechunk; memcpy(rchunk, rp, DAHDI_CHUNKSIZE); memcpy(wchunk, wp, DAHDI_CHUNKSIZE); len += sprintf(page + len, "\n port %2d> | ", i); - for(j = 0; j < DAHDI_CHUNKSIZE; j++) { + for (j = 0; j < DAHDI_CHUNKSIZE; j++) { len += sprintf(page + len, "%02X ", rchunk[j]); } len += sprintf(page + len, " | "); - for(j = 0; j < DAHDI_CHUNKSIZE; j++) { + for (j = 0; j < DAHDI_CHUNKSIZE; j++) { len += sprintf(page + len, "%02X ", wchunk[j]); } len += sprintf(page + len, " | %c", @@ -358,7 +358,7 @@ static int xpd_read_proc(char *page, char **start, off_t off, int count, int *eo } #endif #if 0 - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { len += sprintf(page + len, "\nSignalling:\n"); for_each_line(xpd, i) { struct dahdi_chan *chan = XPD_CHAN(xpd, i); @@ -367,7 +367,7 @@ static int xpd_read_proc(char *page, char **start, off_t off, int count, int *eo } #endif len += sprintf(page + len, "\nCOUNTERS:\n"); - for(i = 0; i < XPD_COUNTER_MAX; i++) { + for (i = 0; i < XPD_COUNTER_MAX; i++) { len += sprintf(page + len, "\t\t%-20s = %d\n", xpd_counters[i].name, xpd->counters[i]); } @@ -389,7 +389,7 @@ out: const char *xpd_statename(enum xpd_state st) { - switch(st) { + switch (st) { case XPD_STATE_START: return "START"; case XPD_STATE_INIT_REGS: return "INIT_REGS"; case XPD_STATE_READY: return "READY"; @@ -404,13 +404,13 @@ bool xpd_setstate(xpd_t *xpd, enum xpd_state newstate) XPD_DBG(DEVICES, xpd, "%s: %s (%d) -> %s (%d)\n", __func__, xpd_statename(xpd->xpd_state), xpd->xpd_state, xpd_statename(newstate), newstate); - switch(newstate) { + switch (newstate) { case XPD_STATE_START: goto badstate; case XPD_STATE_INIT_REGS: - if(xpd->xpd_state != XPD_STATE_START) + if (xpd->xpd_state != XPD_STATE_START) goto badstate; - if(xpd->addr.subunit != 0) { + if (xpd->addr.subunit != 0) { XPD_NOTICE(xpd, "%s: Moving to %s allowed only for subunit 0\n", __func__, xpd_statename(newstate)); @@ -418,12 +418,12 @@ bool xpd_setstate(xpd_t *xpd, enum xpd_state newstate) } break; case XPD_STATE_READY: - if(xpd->addr.subunit == 0) { + if (xpd->addr.subunit == 0) { /* Unit 0 script initialize registers of all subunits */ - if(xpd->xpd_state != XPD_STATE_INIT_REGS) + if (xpd->xpd_state != XPD_STATE_INIT_REGS) goto badstate; } else { - if(xpd->xpd_state != XPD_STATE_START) + if (xpd->xpd_state != XPD_STATE_START) goto badstate; } break; @@ -511,13 +511,13 @@ __must_check xpd_t *xpd_alloc(xbus_t *xbus, BUG_ON(!proto_table); XBUS_DBG(DEVICES, xbus, "type=%d channels=%d (alloc_size=%zd)\n", type, channels, alloc_size); - if(channels > CHANNELS_PERXPD) { + if (channels > CHANNELS_PERXPD) { XBUS_ERR(xbus, "%s: type=%d: too many channels %d\n", __func__, type, channels); goto err; } - if((xpd = KZALLOC(alloc_size, GFP_KERNEL)) == NULL) { + if ((xpd = KZALLOC(alloc_size, GFP_KERNEL)) == NULL) { XBUS_ERR(xbus, "%s: type=%d: Unable to allocate memory\n", __func__, type); goto err; @@ -534,7 +534,7 @@ __must_check xpd_t *xpd_alloc(xbus_t *xbus, kref_init(&xpd->kref); /* For USB-1 disable some channels */ - if(MAX_SEND_SIZE(xbus) < RPACKET_SIZE(GLOBAL, PCM_WRITE)) { + if (MAX_SEND_SIZE(xbus) < RPACKET_SIZE(GLOBAL, PCM_WRITE)) { no_pcm = 0x7F | PHONEDEV(xpd).digital_outputs | PHONEDEV(xpd).digital_inputs; XBUS_NOTICE(xbus, "max xframe size = %d, disabling some PCM channels. no_pcm=0x%04X\n", MAX_SEND_SIZE(xbus), PHONEDEV(xpd).no_pcm); @@ -542,7 +542,7 @@ __must_check xpd_t *xpd_alloc(xbus_t *xbus, if (phonedev_init(xpd, proto_table, channels, no_pcm) < 0) goto err; xbus_xpd_bind(xbus, xpd, unit, subunit); - if(xpd_proc_create(xbus, xpd) < 0) + if (xpd_proc_create(xbus, xpd) < 0) goto err; /* * This makes sure the xbus cannot be removed before this xpd @@ -552,7 +552,7 @@ __must_check xpd_t *xpd_alloc(xbus_t *xbus, xproto_get(type); /* will be returned in xpd_free() */ return xpd; err: - if(xpd) { + if (xpd) { xpd_proc_remove(xbus, xpd); phonedev_cleanup(xpd); KZFREE(xpd); @@ -575,7 +575,7 @@ void update_xpd_status(xpd_t *xpd, int alarm_flag) { struct dahdi_span *span = &PHONEDEV(xpd).span; - if(!SPAN_REGISTERED(xpd)) { + if (!SPAN_REGISTERED(xpd)) { // XPD_NOTICE(xpd, "%s: XPD is not registered. Skipping.\n", __func__); return; } @@ -587,7 +587,7 @@ void update_xpd_status(xpd_t *xpd, int alarm_flag) // Nothing break; } - if(span->alarms == alarm_flag) + if (span->alarms == alarm_flag) return; XPD_DBG(GENERAL, xpd, "Update XPD alarms: %s -> %02X\n", PHONEDEV(xpd).span.name, alarm_flag); span->alarms = alarm_flag; @@ -601,7 +601,7 @@ void update_xpd_status(xpd_t *xpd, int alarm_flag) */ void oht_pcm(xpd_t *xpd, int pos, bool pass) { - if(pass) { + if (pass) { LINE_DBG(SIGNAL, xpd, pos, "OHT PCM: pass\n"); BIT_SET(PHONEDEV(xpd).oht_pcm_pass, pos); } else { @@ -616,7 +616,7 @@ void oht_pcm(xpd_t *xpd, int pos, bool pass) */ void mark_offhook(xpd_t *xpd, int pos, bool to_offhook) { - if(to_offhook) { + if (to_offhook) { LINE_DBG(SIGNAL, xpd, pos, "OFFHOOK\n"); BIT_SET(PHONEDEV(xpd).offhook_state, pos); } else { @@ -637,7 +637,7 @@ void notify_rxsig(xpd_t *xpd, int pos, enum dahdi_rxsig rxsig) * a nested spinlock scenario */ LINE_DBG(SIGNAL, xpd, pos, "rxsig=%s\n", rxsig2str(rxsig)); - if(SPAN_REGISTERED(xpd)) + if (SPAN_REGISTERED(xpd)) dahdi_hooksig(XPD_CHAN(xpd, pos), rxsig); } @@ -650,7 +650,7 @@ void hookstate_changed(xpd_t *xpd, int pos, bool to_offhook) { BUG_ON(!xpd); mark_offhook(xpd, pos, to_offhook); - if(!to_offhook) { + if (!to_offhook) { oht_pcm(xpd, pos, 0); /* * To prevent latest PCM to stay in buffers @@ -695,7 +695,7 @@ int xpp_open(struct dahdi_chan *chan) BUG(); } pos = chan->chanpos - 1; - if(!xpd->card_present) { + if (!xpd->card_present) { LINE_NOTICE(xpd, pos, "Cannot open -- device not ready\n"); return -ENODEV; } @@ -705,7 +705,7 @@ int xpp_open(struct dahdi_chan *chan) current->comm, current->pid, atomic_read(&PHONEDEV(xpd).open_counter)); spin_unlock_irqrestore(&xbus->lock, flags); - if(PHONE_METHOD(card_open, xpd)) + if (PHONE_METHOD(card_open, xpd)) CALL_PHONE_METHOD(card_open, xpd, pos); return 0; } @@ -719,7 +719,7 @@ int xpp_close(struct dahdi_chan *chan) spin_lock_irqsave(&xbus->lock, flags); spin_unlock_irqrestore(&xbus->lock, flags); - if(PHONE_METHOD(card_close, xpd)) + if (PHONE_METHOD(card_close, xpd)) CALL_PHONE_METHOD(card_close, xpd, pos); LINE_DBG(DEVICES, xpd, pos, "%s[%d]: open_counter=%d\n", current->comm, current->pid, @@ -732,7 +732,7 @@ void report_bad_ioctl(const char *msg, xpd_t *xpd, int pos, unsigned int cmd) { char *extra_msg = ""; - if(_IOC_TYPE(cmd) == 'J') + if (_IOC_TYPE(cmd) == 'J') extra_msg = " (for old ZAPTEL)"; XPD_NOTICE(xpd, "%s: Bad ioctl%s\n", msg, extra_msg); XPD_NOTICE(xpd, "ENOTTY: chan=%d cmd=0x%x\n", pos, cmd); @@ -747,7 +747,7 @@ int xpp_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long arg) xpd_t *xpd = chan->pvt; int pos = chan->chanpos - 1; - if(!xpd) { + if (!xpd) { ERR("%s: channel in pos %d, was already closed. Ignore.\n", __func__, pos); return -ENODEV; @@ -770,12 +770,12 @@ int xpp_hooksig(struct dahdi_chan *chan, enum dahdi_txsig txsig) xbus_t *xbus; int pos = chan->chanpos - 1; - if(!xpd) { + if (!xpd) { ERR("%s: channel in pos %d, was already closed. Ignore.\n", __func__, pos); return -ENODEV; } - if(!PHONE_METHOD(card_hooksig, xpd)) { + if (!PHONE_METHOD(card_hooksig, xpd)) { LINE_ERR(xpd, pos, "%s: No hooksig method for this channel. Ignore.\n", __func__); @@ -803,7 +803,7 @@ int xpp_maint(struct dahdi_span *span, int cmd) #endif DBG(GENERAL, "span->mainttimer=%d\n", span->mainttimer); - switch(cmd) { + switch (cmd) { case DAHDI_MAINT_NONE: INFO("XXX Turn off local and remote loops XXX\n"); break; @@ -838,7 +838,7 @@ static int xpp_watchdog(struct dahdi_span *span, int cause) { static int rate_limit; - if((rate_limit++ % 1000) == 0) + if ((rate_limit++ % 1000) == 0) DBG(GENERAL, "\n"); return 0; } @@ -1067,7 +1067,7 @@ int xpd_dahdi_postregister(xpd_t *xpd) * after open). */ for_each_line(xpd, cn) { - if(IS_OFFHOOK(xpd, cn)) + if (IS_OFFHOOK(xpd, cn)) notify_rxsig(xpd, cn, DAHDI_RXSIG_OFFHOOK); } return 0; @@ -1086,10 +1086,10 @@ void xpd_dahdi_preunregister(xpd_t *xpd) return; XPD_DBG(DEVICES, xpd, "\n"); update_xpd_status(xpd, DAHDI_ALARM_NOTOPEN); - if(xpd->card_present) + if (xpd->card_present) CALL_PHONE_METHOD(card_dahdi_preregistration, xpd, 0); /* Now notify dahdi */ - if(SPAN_REGISTERED(xpd)) { + if (SPAN_REGISTERED(xpd)) { int j; dahdi_alarm_notify(&PHONEDEV(xpd).span); @@ -1106,7 +1106,7 @@ void xpd_dahdi_postunregister(xpd_t *xpd) return; atomic_dec(&PHONEDEV(xpd).dahdi_registered); atomic_dec(&num_registered_spans); - if(xpd->card_present) + if (xpd->card_present) CALL_PHONE_METHOD(card_dahdi_postregistration, xpd, 0); } @@ -1115,7 +1115,7 @@ void xpd_dahdi_postunregister(xpd_t *xpd) static void do_cleanup(void) { #ifdef CONFIG_PROC_FS - if(xpp_proc_toplevel) { + if (xpp_proc_toplevel) { DBG(GENERAL, "Removing '%s' from proc\n", PROC_DIR); remove_proc_entry(PROC_DIR, NULL); xpp_proc_toplevel = NULL; @@ -1132,19 +1132,19 @@ static int __init xpp_dahdi_init(void) MAX_XPDS, MAX_UNIT, MAX_SUBUNIT); #ifdef CONFIG_PROC_FS xpp_proc_toplevel = proc_mkdir(PROC_DIR, NULL); - if(!xpp_proc_toplevel) { + if (!xpp_proc_toplevel) { ret = -EIO; goto err; } top = xpp_proc_toplevel; #endif ret = xbus_core_init(); - if(ret) { + if (ret) { ERR("xbus_core_init failed (%d)\n", ret); goto err; } ret = xbus_pcm_init(top); - if(ret) { + if (ret) { ERR("xbus_pcm_init failed (%d)\n", ret); xbus_core_shutdown(); goto err; diff --git a/drivers/dahdi/xpp/xpp_usb.c b/drivers/dahdi/xpp/xpp_usb.c index 01b3bd8..39902b7 100644 --- a/drivers/dahdi/xpp/xpp_usb.c +++ b/drivers/dahdi/xpp/xpp_usb.c @@ -93,20 +93,20 @@ static DEF_PARM(uint, drop_pcm_after, 6, 0644, "Number of consecutive tx_sluggis # define USB_MAX_STRING 128 # define USB_GET_STRING(udev,field,buf) \ do { \ - if((udev)->descriptor.field) { \ + if ((udev)->descriptor.field) { \ char tmp[USB_MAX_STRING]; \ - if(usb_string((udev), (udev)->descriptor.field, tmp, sizeof(tmp)) > 0) \ + if (usb_string((udev), (udev)->descriptor.field, tmp, sizeof(tmp)) > 0) \ snprintf((buf), USB_MAX_STRING, "%s", tmp); \ } \ - } while(0); + } while (0); # define USB_GET_IFACE_NAME(udev,iface,buf) \ do { \ - if((iface)->desc.iInterface) { \ + if ((iface)->desc.iInterface) { \ char tmp[USB_MAX_STRING]; \ - if(usb_string((udev), (iface)->desc.iInterface, tmp, sizeof(tmp)) > 0) \ + if (usb_string((udev), (iface)->desc.iInterface, tmp, sizeof(tmp)) > 0) \ snprintf((buf), USB_MAX_STRING, "%s", tmp); \ } \ - } while(0); + } while (0); #endif #ifdef DEBUG_PCM_TIMING @@ -303,23 +303,23 @@ static xframe_t *alloc_xframe(xbus_t *xbus, gfp_t gfp_flags) BUG_ON(!xbus); xusb = xusb_of(xbus); BUG_ON(!xusb); - if(!xusb->present) { - if((rate_limit++ % 1003) == 0) + if (!xusb->present) { + if ((rate_limit++ % 1003) == 0) XUSB_ERR(xusb, "abort allocations during device disconnect (%d)\n", rate_limit); return NULL; } size = min(xusb->endpoints[XUSB_SEND].max_size, xusb->endpoints[XUSB_RECV].max_size); uframe = kmem_cache_alloc(xusb_cache, gfp_flags); - if(!uframe) { - if((rate_limit++ % 1003) == 0) + if (!uframe) { + if ((rate_limit++ % 1003) == 0) XUSB_ERR(xusb, "frame allocation failed (%d)\n", rate_limit); return NULL; } usb_init_urb(&uframe->urb); p = usb_alloc_coherent(xusb->udev, size, gfp_flags, &uframe->urb.transfer_dma); - if(!p) { - if((rate_limit++ % 1003) == 0) + if (!p) { + if ((rate_limit++ % 1003) == 0) XUSB_ERR(xusb, "buffer allocation failed (%d)\n", rate_limit); kmem_cache_free(xusb_cache, uframe); return NULL; @@ -362,10 +362,10 @@ static int do_send_xframe(xbus_t *xbus, xframe_t *xframe) BUG_ON(xframe->xframe_magic != XFRAME_MAGIC); xusb = xusb_of(xbus); BUG_ON(!xusb); - if(!xusb->present) { + if (!xusb->present) { static int rate_limit; - if((rate_limit++ % 1003) == 0) + if ((rate_limit++ % 1003) == 0) XUSB_ERR(xusb, "abort do_send_xframe during device disconnect (%d)\n", rate_limit); ret = -ENODEV; @@ -374,10 +374,10 @@ static int do_send_xframe(xbus_t *xbus, xframe_t *xframe) /* * If something really bad happend, do not overflow the USB stack */ - if(atomic_read(&xusb->pending_writes) > MAX_PENDING_WRITES) { + if (atomic_read(&xusb->pending_writes) > MAX_PENDING_WRITES) { static int rate_limit; - if((rate_limit++ % 5000) == 0) + if ((rate_limit++ % 5000) == 0) XUSB_ERR(xusb, "USB device is totaly stuck. Dropping packets (#%d).\n", rate_limit); @@ -394,10 +394,10 @@ static int do_send_xframe(xbus_t *xbus, xframe_t *xframe) urb->transfer_buffer_length = XFRAME_LEN(xframe); do_gettimeofday(&xframe->tv_submitted); ret = usb_submit_urb(urb, GFP_ATOMIC); - if(ret < 0) { + if (ret < 0) { static int rate_limit; - if((rate_limit++ % 1000) == 0) + if ((rate_limit++ % 1000) == 0) XBUS_ERR(xbus, "%s: usb_submit_urb failed: %d\n", __func__, ret); ret = -EBADF; @@ -424,7 +424,7 @@ static int xframe_send_pcm(xbus_t *xbus, xframe_t *xframe) BUG_ON(!xframe); xusb = xusb_of(xbus); BUG_ON(!xusb); - if(xusb->drop_next_pcm) { + if (xusb->drop_next_pcm) { FREE_SEND_XFRAME(xbus, xframe); /* return to pool */ xusb->drop_next_pcm = 0; return -EIO; @@ -455,17 +455,17 @@ static bool xusb_listen(xusb_t *xusb) BUG_ON(!xbus); xframe = ALLOC_RECV_XFRAME(xbus); - if(!xframe) { + if (!xframe) { XBUS_ERR(xbus, "Empty receive_pool\n"); goto out; } uframe = xframe_to_uframe(xframe); uframe_recompute(uframe, XUSB_RECV); ret = usb_submit_urb(&uframe->urb, GFP_ATOMIC); - if(ret < 0) { + if (ret < 0) { static int rate_limit; - if((rate_limit++ % 1000) == 0) + if ((rate_limit++ % 1000) == 0) XBUS_ERR(xbus, "%s: usb_submit_urb failed: %d\n", __func__, ret); FREE_RECV_XFRAME(xbus, xframe); @@ -570,10 +570,10 @@ static int check_usb1(struct usb_endpoint_descriptor *endpoint) { const char *msg = (usb_pipein(endpoint->bEndpointAddress))?"input":"output"; - if(endpoint->wMaxPacketSize >= sizeof(xpacket_t)) + if (endpoint->wMaxPacketSize >= sizeof(xpacket_t)) return 1; - if(usb1) { + if (usb1) { NOTICE("USB1 endpoint detected: USB %s endpoint 0x%X support only wMaxPacketSize=%d.\n", msg, endpoint->bEndpointAddress, endpoint->wMaxPacketSize); return 1; @@ -601,13 +601,13 @@ static int set_endpoints(xusb_t *xusb, struct usb_host_interface *iface_desc, st endpoint = &iface_desc->endpoint[i].desc; ep_addr = endpoint->bEndpointAddress; - if(!BULK_ENDPOINT(endpoint)) { + if (!BULK_ENDPOINT(endpoint)) { DBG(DEVICES, "endpoint 0x%x is not bulk: mbAttributes=0x%X\n", ep_addr, endpoint->bmAttributes); continue; } - if(usb_pipein(ep_addr)) { // Input - if(ep_addr == model_info->in.ep_addr) { + if (usb_pipein(ep_addr)) { // Input + if (ep_addr == model_info->in.ep_addr) { if (!check_usb1(endpoint)) return 0; xusb_ep = &xusb->endpoints[XUSB_RECV]; @@ -616,7 +616,7 @@ static int set_endpoints(xusb_t *xusb, struct usb_host_interface *iface_desc, st xusb_ep->callback = xpp_receive_callback; } } else { // Output - if(ep_addr == model_info->out.ep_addr) { + if (ep_addr == model_info->out.ep_addr) { if (!check_usb1(endpoint)) return 0; xusb_ep = &xusb->endpoints[XUSB_SEND]; @@ -666,12 +666,12 @@ static int xusb_probe(struct usb_interface *interface, const struct usb_device_i int i; DBG(DEVICES, "New XUSB device MODEL=%s\n", model_info->desc); - if(iface_desc->desc.bInterfaceNumber != model_info->iface_num) { + if (iface_desc->desc.bInterfaceNumber != model_info->iface_num) { DBG(DEVICES, "Skip interface #%d != #%d\n", iface_desc->desc.bInterfaceNumber, model_info->iface_num); return -ENODEV; } - if((retval = DO_USB_RESET_DEVICE(udev)) < 0) { + if ((retval = DO_USB_RESET_DEVICE(udev)) < 0) { ERR("usb_reset_device failed: %d\n", retval); goto probe_failed; } @@ -698,7 +698,7 @@ static int xusb_probe(struct usb_interface *interface, const struct usb_device_i xusb->interface = interface; xusb->model_info = model_info; - if(!set_endpoints(xusb, iface_desc, model_info)) { + if (!set_endpoints(xusb, iface_desc, model_info)) { retval = -ENODEV; goto probe_failed; } @@ -733,7 +733,7 @@ static int xusb_probe(struct usb_interface *interface, const struct usb_device_i /* let the user know what node this device is now attached to */ DBG(DEVICES, "USB XPP device now attached to minor %d\n", xusb->minor); xbus = xbus_new(&xusb_ops, min(xusb->endpoints[XUSB_SEND].max_size, xusb->endpoints[XUSB_RECV].max_size), &udev->dev, xusb); - if(!xbus) { + if (!xbus) { retval = -ENOMEM; goto probe_failed; } @@ -744,19 +744,19 @@ static int xusb_probe(struct usb_interface *interface, const struct usb_device_i udev->descriptor.idProduct, udev->descriptor.bcdDevice); spin_lock_irqsave(&xusb_lock, flags); - for(i = 0; i < MAX_BUSES; i++) { - if(xusb_array[i] == NULL) + for (i = 0; i < MAX_BUSES; i++) { + if (xusb_array[i] == NULL) break; } spin_unlock_irqrestore(&xusb_lock, flags); - if(i >= MAX_BUSES) { + if (i >= MAX_BUSES) { ERR("xpp_usb: Too many XPP USB buses\n"); retval = -ENOMEM; goto probe_failed; } usb_make_path(udev, xusb->path, XBUS_DESCLEN); // May trunacte... ignore snprintf(xbus->connector, XBUS_DESCLEN, "%s", xusb->path); - if(xusb->serial && xusb->serial[0]) + if (xusb->serial && xusb->serial[0]) snprintf(xbus->label, LABEL_SIZE, "usb:%s", xusb->serial); xusb->index = i; xusb_array[i] = xusb; @@ -777,24 +777,24 @@ static int xusb_probe(struct usb_interface *interface, const struct usb_device_i bus_count++; xusb->xbus_num = xbus->num; /* prepare several pending frames for receive side */ - for(i = 0; i < 10; i++) + for (i = 0; i < 10; i++) xusb_listen(xusb); xbus_connect(xbus); return retval; probe_failed: ERR("Failed to initialize xpp usb bus: %d\n", retval); usb_set_intfdata(interface, NULL); - if(xusb) { - if(xusb->minor) { // passed registration phase + if (xusb) { + if (xusb->minor) { // passed registration phase ERR("Calling usb_deregister_dev()\n"); usb_deregister_dev(interface, &xusb_class); } ERR("Removing failed xusb\n"); KZFREE(xusb); } - if(xbus) { + if (xbus) { #ifdef CONFIG_PROC_FS - if(procsummary) { + if (procsummary) { XBUS_DBG(PROC, xbus, "Remove proc_entry: " PROC_USBXPP_SUMMARY "\n"); remove_proc_entry(PROC_USBXPP_SUMMARY, xbus->proc_xbus_dir); procsummary = NULL; @@ -834,15 +834,15 @@ static void xusb_disconnect(struct usb_interface *interface) xbus = xbus_num(xusb->xbus_num); /* find our xusb */ - for(i = 0; i < MAX_BUSES; i++) { - if(xusb_array[i] == xusb) + for (i = 0; i < MAX_BUSES; i++) { + if (xusb_array[i] == xusb) break; } BUG_ON(i >= MAX_BUSES); xusb_array[i] = NULL; #ifdef CONFIG_PROC_FS - if(xbus->proc_xbus_dir) { + if (xbus->proc_xbus_dir) { XBUS_DBG(PROC, xbus, "Remove proc_entry: " PROC_USBXPP_SUMMARY "\n"); remove_proc_entry(PROC_USBXPP_SUMMARY, xbus->proc_xbus_dir); } @@ -873,7 +873,7 @@ static void xpp_send_callback(USB_PASS_CB(urb)) int writes = atomic_read(&xusb->pending_writes); int i; - if(!xbus) { + if (!xbus) { XUSB_ERR(xusb, "Sent URB does not belong to a valid xbus anymore...\n"); return; } @@ -882,18 +882,18 @@ static void xpp_send_callback(USB_PASS_CB(urb)) do_gettimeofday(&now); xusb->last_tx = xframe->tv_submitted; usec = usec_diff(&now, &xframe->tv_submitted); - if(usec > xusb->max_tx_delay) + if (usec > xusb->max_tx_delay) xusb->max_tx_delay = usec; i = usec / USEC_BUCKET; - if(i >= NUM_BUCKETS) + if (i >= NUM_BUCKETS) i = NUM_BUCKETS - 1; xusb->usb_tx_delay[i]++; - if(unlikely(usec > tx_sluggish)) { + if (unlikely(usec > tx_sluggish)) { atomic_inc(&xusb->usb_sluggish_count); - if(xusb->sluggish_debounce++ > drop_pcm_after) { + if (xusb->sluggish_debounce++ > drop_pcm_after) { static int rate_limit; - if((rate_limit++ % 1003) == 500) /* skip first messages */ + if ((rate_limit++ % 1003) == 500) /* skip first messages */ XUSB_NOTICE(xusb, "Sluggish USB. Dropping next PCM frame (pending_writes=%d)\n", writes); @@ -906,7 +906,7 @@ static void xpp_send_callback(USB_PASS_CB(urb)) /* sync/async unlink faults aren't errors */ if (urb->status && !(urb->status == -ENOENT || urb->status == -ECONNRESET)) { static int rate_limit; - if((rate_limit++ % 1000) < 10) { + if ((rate_limit++ % 1000) < 10) { XUSB_ERR(xusb, "nonzero write bulk status received: %d (pending_writes=%d)\n", urb->status, writes); @@ -916,7 +916,7 @@ static void xpp_send_callback(USB_PASS_CB(urb)) } else XUSB_COUNTER(xusb, TX_FRAMES)++; FREE_SEND_XFRAME(xbus, xframe); - if(!xusb->present) + if (!xusb->present) XUSB_ERR(xusb, "A urb from non-connected device?\n"); } @@ -932,11 +932,11 @@ static void xpp_receive_callback(USB_PASS_CB(urb)) do_gettimeofday(&now); atomic_dec(&xusb->pending_reads); - if(!xbus) { + if (!xbus) { XUSB_ERR(xusb, "Received URB does not belong to a valid xbus anymore...\n"); return; } - if(!xusb->present) { + if (!xusb->present) { do_resubmit = 0; goto err; } @@ -946,10 +946,10 @@ static void xpp_receive_callback(USB_PASS_CB(urb)) goto err; } size = urb->actual_length; - if(size == 0) { + if (size == 0) { static int rate_limit; - if((rate_limit++ % 5003) == 0) + if ((rate_limit++ % 5003) == 0) XUSB_NOTICE(xusb, "Received a zero length URBs (%d)\n", rate_limit); XUSB_COUNTER(xusb, RCV_ZERO_LEN)++; goto err; @@ -963,7 +963,7 @@ static void xpp_receive_callback(USB_PASS_CB(urb)) /* Send UP */ xbus_receive_xframe(xbus, xframe); end: - if(do_resubmit) + if (do_resubmit) xusb_listen(xusb); return; err: @@ -976,7 +976,7 @@ err: static void xpp_usb_cleanup(void) { - if(xusb_cache) { + if (xusb_cache) { kmem_cache_destroy(xusb_cache); xusb_cache = NULL; } @@ -999,7 +999,7 @@ static int __init xpp_usb_init(void) NULL, #endif NULL); - if(!xusb_cache) { + if (!xusb_cache) { ret = -ENOMEM; goto failure; } @@ -1039,7 +1039,7 @@ static int xusb_read_proc(char *page, char **start, off_t off, int count, int *e uint usb_tx_delay[NUM_BUCKETS]; const int mark_limit = tx_sluggish/USEC_BUCKET; - if(!xusb) + if (!xusb) goto out; // TODO: probably needs a per-xusb lock: spin_lock_irqsave(&xusb_lock, flags); @@ -1070,10 +1070,10 @@ static int xusb_read_proc(char *page, char **start, off_t off, int count, int *e memcpy(usb_tx_delay, xusb->usb_tx_delay, sizeof(usb_tx_delay)); len += sprintf(page + len, "usb_tx_delay[%d,%d,%d]: ", USEC_BUCKET, BUCKET_START, NUM_BUCKETS); - for(i = BUCKET_START; i < NUM_BUCKETS; i++) { + for (i = BUCKET_START; i < NUM_BUCKETS; i++) { len += sprintf(page + len, "%6d ", usb_tx_delay[i]); - if(i == mark_limit) + if (i == mark_limit) len += sprintf(page + len, "| "); } len += sprintf(page + len, "\nPCM_TX_DROPS: %5d (sluggish: %d)\n", @@ -1081,7 +1081,7 @@ static int xusb_read_proc(char *page, char **start, off_t off, int count, int *e atomic_read(&xusb->usb_sluggish_count) ); len += sprintf(page + len, "\nCOUNTERS:\n"); - for(i = 0; i < XUSB_COUNTER_MAX; i++) { + for (i = 0; i < XUSB_COUNTER_MAX; i++) { len += sprintf(page + len, "\t%-15s = %d\n", xusb_counters[i].name, xusb->counters[i]); } #if 0 diff --git a/drivers/dahdi/xpp/xproto.c b/drivers/dahdi/xpp/xproto.c index d0c44e6..529bbef 100644 --- a/drivers/dahdi/xpp/xproto.c +++ b/drivers/dahdi/xpp/xproto.c @@ -70,7 +70,7 @@ xproto_handler_t xproto_global_handler(byte opcode) static const xproto_table_t *xproto_table(xpd_type_t cardtype) { - if(cardtype >= XPD_TYPE_NOMODULE) + if (cardtype >= XPD_TYPE_NOMODULE) return NULL; return xprotocol_tables[cardtype]; } @@ -79,24 +79,24 @@ const xproto_table_t *xproto_get(xpd_type_t cardtype) { const xproto_table_t *xtable; - if(cardtype >= XPD_TYPE_NOMODULE) + if (cardtype >= XPD_TYPE_NOMODULE) return NULL; xtable = xprotocol_tables[cardtype]; - if(!xtable) { /* Try to load the relevant module */ + if (!xtable) { /* Try to load the relevant module */ int ret = request_module(XPD_TYPE_PREFIX "%d", cardtype); - if(ret != 0) { + if (ret != 0) { NOTICE("%s: Failed to load module for type=%d. exit status=%d.\n", __func__, cardtype, ret); /* Drop through: we may be lucky... */ } xtable = xprotocol_tables[cardtype]; } - if(xtable) { + if (xtable) { BUG_ON(!xtable->owner); #ifdef CONFIG_MODULE_UNLOAD DBG(GENERAL, "%s refcount was %d\n", xtable->name, module_refcount(xtable->owner)); #endif - if(!try_module_get(xtable->owner)) { + if (!try_module_get(xtable->owner)) { ERR("%s: try_module_get for %s failed.\n", __func__, xtable->name); return NULL; } @@ -139,8 +139,8 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack) int ret = -EPROTO; BUG_ON(!pack); - if(!valid_xpd_addr(&XPACKET_ADDR(pack))) { - if(printk_ratelimit()) { + if (!valid_xpd_addr(&XPACKET_ADDR(pack))) { + if (printk_ratelimit()) { XBUS_NOTICE(xbus, "%s: from %d%d: bad address.\n", __func__, XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack)); @@ -153,11 +153,11 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack) /* XPD may be NULL (e.g: during bus polling */ xe = xproto_global_entry(op); /*-------- Validations -----------*/ - if(!xe) { + if (!xe) { const xproto_table_t *xtable; - if(!xpd) { - if(printk_ratelimit()) { + if (!xpd) { + if (printk_ratelimit()) { XBUS_NOTICE(xbus, "%s: from %d%d opcode=0x%02X: no such global command.\n", __func__, XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack), op); @@ -166,16 +166,16 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack) goto out; } xtable = xproto_table(xpd->type); - if(!xtable) { - if(printk_ratelimit()) + if (!xtable) { + if (printk_ratelimit()) XPD_ERR(xpd, "%s: no protocol table (type=%d)\n", __func__, xpd->type); goto out; } xe = xproto_card_entry(xtable, op); - if(!xe) { - if(printk_ratelimit()) { + if (!xe) { + if (printk_ratelimit()) { XPD_NOTICE(xpd, "%s: bad command (type=%d,opcode=0x%x)\n", __func__, xpd->type, op); @@ -186,8 +186,8 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack) } table = xe->table; BUG_ON(!table); - if(!table->packet_is_valid(pack)) { - if(printk_ratelimit()) { + if (!table->packet_is_valid(pack)) { + if (printk_ratelimit()) { ERR("xpp: %s: wrong size %d for opcode=0x%02X\n", __func__, XPACKET_LEN(pack), op); dump_packet("packet_process -- wrong size", pack, debug); @@ -211,7 +211,7 @@ static int xframe_receive_cmd(xbus_t *xbus, xframe_t *xframe) int len; int ret; - if(debug & DBG_COMMANDS) + if (debug & DBG_COMMANDS) dump_xframe("RX-CMD", xbus, xframe, DBG_ANY); p = xframe->packets; xframe_end = p + XFRAME_LEN(xframe); @@ -219,10 +219,10 @@ static int xframe_receive_cmd(xbus_t *xbus, xframe_t *xframe) pack = (xpacket_t *)p; len = XPACKET_LEN(pack); /* Sanity checks */ - if(unlikely(XPACKET_OP(pack) == XPROTO_NAME(GLOBAL,PCM_READ))) { + if (unlikely(XPACKET_OP(pack) == XPROTO_NAME(GLOBAL,PCM_READ))) { static int rate_limit; - if((rate_limit++ % 1003) == 0) { + if ((rate_limit++ % 1003) == 0) { XBUS_DBG(GENERAL, xbus, "A PCM packet within a Non-PCM xframe\n"); dump_xframe("In Non-PCM xframe", xbus, xframe, debug); } @@ -230,10 +230,10 @@ static int xframe_receive_cmd(xbus_t *xbus, xframe_t *xframe) goto out; } p += len; - if(p > xframe_end || len < RPACKET_HEADERSIZE) { + if (p > xframe_end || len < RPACKET_HEADERSIZE) { static int rate_limit; - if((rate_limit++ % 1003) == 0) { + if ((rate_limit++ % 1003) == 0) { XBUS_NOTICE(xbus, "Invalid packet length %d\n", len); dump_xframe("BAD LENGTH", xbus, xframe, debug); } @@ -241,9 +241,9 @@ static int xframe_receive_cmd(xbus_t *xbus, xframe_t *xframe) goto out; } ret = packet_process(xbus, pack); - if(unlikely(ret < 0)) + if (unlikely(ret < 0)) break; - } while(p < xframe_end); + } while (p < xframe_end); out: FREE_RECV_XFRAME(xbus, xframe); return ret; @@ -256,17 +256,17 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe) struct timeval tv_received; int usec; - if(XFRAME_LEN(xframe) < RPACKET_HEADERSIZE) { + if (XFRAME_LEN(xframe) < RPACKET_HEADERSIZE) { static int rate_limit; - if((rate_limit++ % 1003) == 0) { + if ((rate_limit++ % 1003) == 0) { XBUS_NOTICE(xbus, "short xframe\n"); dump_xframe("short xframe", xbus, xframe, debug); } FREE_RECV_XFRAME(xbus, xframe); return -EPROTO; } - if(!XBUS_FLAGS(xbus, CONNECTED)) { + if (!XBUS_FLAGS(xbus, CONNECTED)) { XBUS_DBG(GENERAL, xbus, "Dropped xframe. Is shutting down.\n"); return -ENODEV; } @@ -274,8 +274,8 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe) /* * We want to check that xframes do not mix PCM and other commands */ - if(XPACKET_IS_PCM((xpacket_t *)xframe->packets)) { - if(!XBUS_IS(xbus, READY)) + if (XPACKET_IS_PCM((xpacket_t *)xframe->packets)) { + if (!XBUS_IS(xbus, READY)) FREE_RECV_XFRAME(xbus, xframe); else xframe_receive_pcm(xbus, xframe); @@ -287,7 +287,7 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe) do_gettimeofday(&now); usec = (now.tv_sec - tv_received.tv_sec) * 1000000 + now.tv_usec - tv_received.tv_usec; - if(usec > xbus->max_rx_process) + if (usec > xbus->max_rx_process) xbus->max_rx_process = usec; return ret; } @@ -300,7 +300,7 @@ void dump_packet(const char *msg, const xpacket_t *packet, bool debug) byte op = XPACKET_OP(packet); byte *addr = (byte *)&XPACKET_ADDR(packet); - if(!debug) + if (!debug) return; printk(KERN_DEBUG "%s: XPD=%1X-%1X%c (0x%X) OP=0x%02X LEN=%d", msg, @@ -316,14 +316,14 @@ void dump_packet(const char *msg, const xpacket_t *packet, bool debug) byte *p = (byte *)packet; printk(" BYTES: "); - for(i = 0; i < XPACKET_LEN(packet); i++) { + for (i = 0; i < XPACKET_LEN(packet); i++) { static int limiter; - if(i >= sizeof(xpacket_t)) { - if(limiter < ERR_REPORT_LIMIT) { + if (i >= sizeof(xpacket_t)) { + if (limiter < ERR_REPORT_LIMIT) { ERR("%s: length overflow i=%d > sizeof(xpacket_t)=%lu\n", __func__, i+1, (long)sizeof(xpacket_t)); - } else if(limiter == ERR_REPORT_LIMIT) { + } else if (limiter == ERR_REPORT_LIMIT) { ERR("%s: error packet #%d... squelsh reports.\n", __func__, limiter); } @@ -347,12 +347,12 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, char reg_buf[MAX_PROC_WRITE]; char data_buf[MAX_PROC_WRITE]; - if(regcmd->bytes > sizeof(*regcmd) - 1) { /* The size byte is not included */ + if (regcmd->bytes > sizeof(*regcmd) - 1) { /* The size byte is not included */ PORT_NOTICE(xbus, unit, port, "%s: %s: Too long: regcmd->bytes = %d\n", __func__, msg, regcmd->bytes); return; } - if(regcmd->is_multibyte) { + if (regcmd->is_multibyte) { char buf[MAX_PROC_WRITE + 1]; int i; int n = 0; @@ -360,7 +360,7 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, const byte *p = REG_XDATA(regcmd); buf[0] = '\0'; - for(i = 0; i < len && n < MAX_PROC_WRITE; i++) + for (i = 0; i < len && n < MAX_PROC_WRITE; i++) n += snprintf(&buf[n], MAX_PROC_WRITE - n, "%02X ", p[i]); PORT_DBG(REGS, xbus, unit, port, "UNIT-%d PORT-%d: Multibyte(eoframe=%d) %s[0..%zd]: %s%s\n", @@ -368,7 +368,7 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, msg, len-1, buf, (n >= MAX_PROC_WRITE)?"...":""); return; } - if(regcmd->bytes != sizeof(*regcmd) - 1) { /* The size byte is not included */ + if (regcmd->bytes != sizeof(*regcmd) - 1) { /* The size byte is not included */ PORT_NOTICE(xbus, unit, port, "%s: %s: Wrong size: regcmd->bytes = %d\n", __func__, msg, regcmd->bytes); return; @@ -378,7 +378,7 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, (REG_FIELD(regcmd, all_ports_broadcast)) ? "*" : ""); action = (REG_FIELD(regcmd, read_request)) ? 'R' : 'W'; modifier = 'D'; - if(REG_FIELD(regcmd, do_subreg)) { + if (REG_FIELD(regcmd, do_subreg)) { snprintf(reg_buf, MAX_PROC_WRITE, "%02X %02X", REG_FIELD(regcmd, regnum), REG_FIELD(regcmd, subreg)); @@ -387,9 +387,9 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, snprintf(reg_buf, MAX_PROC_WRITE, "%02X", REG_FIELD(regcmd, regnum)); } - if(REG_FIELD(regcmd, read_request)) { + if (REG_FIELD(regcmd, read_request)) { data_buf[0] = '\0'; - } else if(REG_FIELD(regcmd, do_datah)) { + } else if (REG_FIELD(regcmd, do_datah)) { snprintf(data_buf, MAX_PROC_WRITE, "%02X %02X", REG_FIELD(regcmd, data_low), REG_FIELD(regcmd, data_high)); @@ -409,19 +409,19 @@ const char *xproto_name(xpd_type_t xpd_type) BUG_ON(xpd_type >= XPD_TYPE_NOMODULE); proto_table = xprotocol_tables[xpd_type]; - if(!proto_table) + if (!proto_table) return NULL; return proto_table->name; } #define CHECK_XOP(xops, f) \ - if(!(xops)->f) { \ + if (!(xops)->f) { \ ERR("%s: missing xmethod %s [%s (%d)]\n", __func__, #f, name, type); \ return -EINVAL; \ } #define CHECK_PHONEOP(phoneops, f) \ - if(!(phoneops)->f) { \ + if (!(phoneops)->f) { \ ERR("%s: missing phone method %s [%s (%d)]\n", __func__, #f, name, type); \ return -EINVAL; \ } @@ -436,12 +436,12 @@ int xproto_register(const xproto_table_t *proto_table) BUG_ON(!proto_table); type = proto_table->type; name = proto_table->name; - if(type >= XPD_TYPE_NOMODULE) { + if (type >= XPD_TYPE_NOMODULE) { NOTICE("%s: Bad xproto type %d\n", __func__, type); return -EINVAL; } DBG(GENERAL, "%s (%d)\n", name, type); - if(xprotocol_tables[type]) + if (xprotocol_tables[type]) NOTICE("%s: overriding registration of %s (%d)\n", __func__, name, type); xops = proto_table->xops; CHECK_XOP(xops, card_new); @@ -476,11 +476,11 @@ void xproto_unregister(const xproto_table_t *proto_table) type = proto_table->type; name = proto_table->name; DBG(GENERAL, "%s (%d)\n", name, type); - if(type >= XPD_TYPE_NOMODULE) { + if (type >= XPD_TYPE_NOMODULE) { NOTICE("%s: Bad xproto type %s (%d)\n", __func__, name, type); return; } - if(!xprotocol_tables[type]) + if (!xprotocol_tables[type]) NOTICE("%s: xproto type %s (%d) is already unregistered\n", __func__, name, type); xprotocol_tables[type] = NULL; } diff --git a/drivers/dahdi/xpp/xproto.h b/drivers/dahdi/xpp/xproto.h index 92d7ab0..6eda25f 100644 --- a/drivers/dahdi/xpp/xproto.h +++ b/drivers/dahdi/xpp/xproto.h @@ -45,7 +45,7 @@ struct xpd_addr { (p)->unit = (u); \ (p)->subunit = (s); \ (p)->sync_master = 0; \ - } while(0) + } while (0) struct xpacket_header { uint16_t packet_len:10; @@ -142,23 +142,23 @@ bool valid_xpd_addr(const struct xpd_addr *addr); XPACKET_ADDR_SUBUNIT(p) = XBUS_SUBUNIT(to); \ XPACKET_ADDR_SYNC(p) = 0; \ XPACKET_ADDR_RESERVED(p) = 0; \ - } while(0) + } while (0) #define XFRAME_NEW_CMD(frm, p, xbus, card, op, to) \ do { \ int pack_len = RPACKET_SIZE(card,op); \ \ - if(!XBUS_FLAGS(xbus, CONNECTED)) \ + if (!XBUS_FLAGS(xbus, CONNECTED)) \ return -ENODEV; \ (frm) = ALLOC_SEND_XFRAME(xbus); \ - if(!(frm)) \ + if (!(frm)) \ return -ENOMEM; \ (p) = xframe_next_packet(frm, pack_len); \ - if(!(p)) \ + if (!(p)) \ return -ENOMEM; \ XPACKET_INIT(p, card, op, to, 0, 0); \ (frm)->usec_towait = 0; \ - } while(0) + } while (0) #endif -- cgit v1.2.3