xpp: style: convert __FUNCTION__ to __func__
* Applied via: perl -pi -e 's/\b__FUNCTION__\b/__func__/g' "$@" Signed-off-by: Oron Peled <oron.peled@xorcom.com> Acked-By: Tzafrir Cohen <tzafrir.cohen@xorcom.com> git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@10422 a0bf4364-ded3-4de4-8d8a-66a801d63aff
This commit is contained in:
Oron Peled
Tzafrir Cohen
parent
647212c45f
commit
535ef8086c
@ -1372,7 +1372,7 @@ static void su_new_state(xpd_t *xpd, byte reg_x30)
|
||||
priv = xpd->priv;
|
||||
BUG_ON(!priv);
|
||||
if(!priv->initialized) {
|
||||
XPD_ERR(xpd, "%s called on uninitialized AB\n", __FUNCTION__);
|
||||
XPD_ERR(xpd, "%s called on uninitialized AB\n", __func__);
|
||||
return;
|
||||
}
|
||||
new_state.reg = reg_x30;
|
||||
@ -1477,7 +1477,7 @@ static int BRI_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
|
||||
static int rate_limit;
|
||||
|
||||
if((rate_limit++ % 1003) < 5)
|
||||
notify_bad_xpd(__FUNCTION__, xbus, addr , orig_xpd->xpdname);
|
||||
notify_bad_xpd(__func__, xbus, addr , orig_xpd->xpdname);
|
||||
return -EPROTO;
|
||||
}
|
||||
spin_lock_irqsave(&xpd->lock, flags);
|
||||
|
||||
@ -835,7 +835,7 @@ HANDLER_DEF(FXO, SIG_CHANGED)
|
||||
struct FXO_priv_data *priv;
|
||||
|
||||
if(!xpd) {
|
||||
notify_bad_xpd(__FUNCTION__, xbus, XPACKET_ADDR(pack), cmd->name);
|
||||
notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), cmd->name);
|
||||
return -EPROTO;
|
||||
}
|
||||
priv = xpd->priv;
|
||||
@ -1359,7 +1359,7 @@ static int fxo_xpd_probe(struct device *dev)
|
||||
XPD_DBG(DEVICES, xpd, "SYSFS\n");
|
||||
ret = device_create_file(dev, &dev_attr_fxo_battery);
|
||||
if(ret) {
|
||||
XPD_ERR(xpd, "%s: device_create_file(fxo_battery) failed: %d\n", __FUNCTION__, ret);
|
||||
XPD_ERR(xpd, "%s: device_create_file(fxo_battery) failed: %d\n", __func__, ret);
|
||||
goto fail_fxo_battery;
|
||||
}
|
||||
return 0;
|
||||
|
||||
@ -805,7 +805,7 @@ static int FXS_card_hooksig(xpd_t *xpd, int pos, enum dahdi_txsig txsig)
|
||||
break;
|
||||
default:
|
||||
XPD_NOTICE(xpd, "%s: Can't set tx state to %s (%d)\n",
|
||||
__FUNCTION__, txsig2str(txsig), txsig);
|
||||
__func__, txsig2str(txsig), txsig);
|
||||
ret = -EINVAL;
|
||||
}
|
||||
return ret;
|
||||
@ -872,7 +872,7 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a
|
||||
return -ENODEV;
|
||||
if (pos < 0 || pos >= PHONEDEV(xpd).channels) {
|
||||
XPD_NOTICE(xpd, "Bad channel number %d in %s(), cmd=%u\n",
|
||||
pos, __FUNCTION__, cmd);
|
||||
pos, __func__, cmd);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
||||
@ -545,7 +545,7 @@ HANDLER_DEF(GLOBAL, REGISTER_REPLY)
|
||||
static int rate_limit;
|
||||
|
||||
if((rate_limit++ % 1003) < 5)
|
||||
notify_bad_xpd(__FUNCTION__, xbus, XPACKET_ADDR(pack), "");
|
||||
notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), "");
|
||||
return -EPROTO;
|
||||
}
|
||||
if(debug & DBG_REGS) {
|
||||
|
||||
@ -606,7 +606,7 @@ static int set_pri_proto(xpd_t *xpd, enum pri_protocol set_proto)
|
||||
return -ENOSYS;
|
||||
default:
|
||||
XPD_ERR(xpd, "%s: Unknown pri protocol = %d\n",
|
||||
__FUNCTION__, set_proto);
|
||||
__func__, set_proto);
|
||||
return -EINVAL;
|
||||
}
|
||||
priv->pri_protocol = set_proto;
|
||||
@ -747,7 +747,7 @@ static void set_reg_lim0(const char *msg, xpd_t *xpd)
|
||||
lim0 |= REG_LIM0_MAS;
|
||||
else
|
||||
lim0 &= ~REG_LIM0_MAS;
|
||||
XPD_DBG(SIGNAL, xpd, "%s(%s): %s, %s\n", __FUNCTION__, msg,
|
||||
XPD_DBG(SIGNAL, xpd, "%s(%s): %s, %s\n", __func__, msg,
|
||||
(is_master_mode) ? "MASTER" : "SLAVE",
|
||||
(localloop) ? "LOCALLOOP" : "NO_LOCALLOOP");
|
||||
write_subunit(xpd, REG_LIM0 , lim0);
|
||||
@ -764,7 +764,7 @@ static int set_master_mode(const char *msg, xpd_t *xpd)
|
||||
{
|
||||
BUG_ON(!xpd);
|
||||
XPD_DBG(SIGNAL, xpd, "\n");
|
||||
set_reg_lim0(__FUNCTION__, xpd);
|
||||
set_reg_lim0(__func__, xpd);
|
||||
set_clocking(xpd);
|
||||
return 0;
|
||||
}
|
||||
@ -777,12 +777,12 @@ static int set_localloop(xpd_t *xpd, bool localloop)
|
||||
priv = xpd->priv;
|
||||
if(SPAN_REGISTERED(xpd)) {
|
||||
XPD_NOTICE(xpd, "Registered as span %d. Cannot do %s\n",
|
||||
PHONEDEV(xpd).span.spanno, __FUNCTION__);
|
||||
PHONEDEV(xpd).span.spanno, __func__);
|
||||
return -EBUSY;
|
||||
}
|
||||
priv->local_loopback = localloop;
|
||||
XPD_DBG(SIGNAL, xpd, "%s: %s\n", __FUNCTION__, (localloop) ? "LOCALLOOP" : "NO");
|
||||
set_master_mode(__FUNCTION__, xpd);
|
||||
XPD_DBG(SIGNAL, xpd, "%s: %s\n", __func__, (localloop) ? "LOCALLOOP" : "NO");
|
||||
set_master_mode(__func__, xpd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -921,7 +921,7 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig)
|
||||
}
|
||||
if(flags && flags != BIT(i)) {
|
||||
ERR("%s: BUG: i=%d flags=0x%X\n",
|
||||
__FUNCTION__, i, flags);
|
||||
__func__, i, flags);
|
||||
// BUG();
|
||||
}
|
||||
}
|
||||
@ -1012,24 +1012,24 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig)
|
||||
framingstr, codingstr, crcstr,
|
||||
(lineconfig & DAHDI_CONFIG_NOTOPEN)?"YELLOW":"",
|
||||
lineconfig);
|
||||
set_reg_lim0(__FUNCTION__, xpd);
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr1(0x%02X) = 0x%02X\n", __FUNCTION__, REG_FMR1, fmr1);
|
||||
set_reg_lim0(__func__, xpd);
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr1(0x%02X) = 0x%02X\n", __func__, REG_FMR1, fmr1);
|
||||
write_subunit(xpd, REG_FMR1, fmr1);
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr2(0x%02X) = 0x%02X\n", __FUNCTION__, REG_FMR2, fmr2);
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr2(0x%02X) = 0x%02X\n", __func__, REG_FMR2, fmr2);
|
||||
write_subunit(xpd, REG_FMR2, fmr2);
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr0(0x%02X) = 0x%02X\n", __FUNCTION__, REG_FMR0, fmr0);
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr0(0x%02X) = 0x%02X\n", __func__, REG_FMR0, fmr0);
|
||||
write_subunit(xpd, REG_FMR0, fmr0);
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr4(0x%02X) = 0x%02X\n", __FUNCTION__, REG_FMR4, fmr4);
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr4(0x%02X) = 0x%02X\n", __func__, REG_FMR4, fmr4);
|
||||
write_subunit(xpd, REG_FMR4, fmr4);
|
||||
if(fmr3) {
|
||||
XPD_DBG(GENERAL, xpd, "%s: fmr3(0x%02X) = 0x%02X\n", __FUNCTION__, REG_FMR3, 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", __FUNCTION__, REG_CMDR_E, cmdr);
|
||||
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) {
|
||||
XPD_DBG(GENERAL, xpd, "%s: rc0(0x%02X) = 0x%02X\n", __FUNCTION__, REG_RC0, rc0);
|
||||
XPD_DBG(GENERAL, xpd, "%s: rc0(0x%02X) = 0x%02X\n", __func__, REG_RC0, rc0);
|
||||
write_subunit(xpd, REG_RC0, rc0);
|
||||
}
|
||||
#endif
|
||||
@ -1042,12 +1042,12 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig)
|
||||
* They are unused in E1 and should be 1
|
||||
*/
|
||||
XPD_DBG(GENERAL, xpd, "%s: rs1(0x%02X) = 0x%02X\n",
|
||||
__FUNCTION__, REG_RS1_E, rs1);
|
||||
__func__, REG_RS1_E, rs1);
|
||||
write_subunit(xpd, REG_RS1_E, rs1);
|
||||
}
|
||||
xsp |= REG_XSP_E_CASEN; /* Same as REG_FMR5_T_EIBR for T1 */
|
||||
}
|
||||
XPD_DBG(GENERAL, xpd, "%s: xsp(0x%02X) = 0x%02X\n", __FUNCTION__, REG_XSP_E, xsp);
|
||||
XPD_DBG(GENERAL, xpd, "%s: xsp(0x%02X) = 0x%02X\n", __func__, REG_XSP_E, xsp);
|
||||
write_subunit(xpd, REG_XSP_E, xsp);
|
||||
return 0;
|
||||
bad_lineconfig:
|
||||
@ -1206,7 +1206,7 @@ static int PRI_card_init(xbus_t *xbus, xpd_t *xpd)
|
||||
PHONEDEV(xpd).direction = TO_PSTN;
|
||||
XPD_DBG(DEVICES, xpd, "%s\n", xpd->type_name);
|
||||
PHONEDEV(xpd).timing_priority = 1; /* High priority SLAVE */
|
||||
set_master_mode(__FUNCTION__, xpd);
|
||||
set_master_mode(__func__, xpd);
|
||||
for(ret = 0; ret < NUM_LEDS; ret++) {
|
||||
DO_LED(xpd, ret, PRI_LED_ON);
|
||||
msleep(20);
|
||||
@ -1576,7 +1576,7 @@ static int encode_rbsbits_e1(xpd_t *xpd, int pos, int bits)
|
||||
if(pos == 15)
|
||||
return 0; /* Don't write dchan in CAS */
|
||||
if(pos < 0 || pos > 31) {
|
||||
XPD_NOTICE(xpd, "%s: pos=%d out of range. Ignore\n", __FUNCTION__, pos);
|
||||
XPD_NOTICE(xpd, "%s: pos=%d out of range. Ignore\n", __func__, pos);
|
||||
return 0;
|
||||
}
|
||||
if(pos >= 16) {
|
||||
@ -1609,7 +1609,7 @@ static int encode_rbsbits_t1(xpd_t *xpd, int pos, int bits)
|
||||
BUG_ON(!priv);
|
||||
BUG_ON(priv->pri_protocol != PRI_PROTO_T1);
|
||||
if(pos < 0 || pos >= PHONEDEV(xpd).channels) {
|
||||
XPD_ERR(xpd, "%s: Bad pos=%d\n", __FUNCTION__, pos);
|
||||
XPD_ERR(xpd, "%s: Bad pos=%d\n", __func__, pos);
|
||||
return 0;
|
||||
}
|
||||
chan_per_reg = CHAN_PER_REGS(priv);
|
||||
@ -1701,7 +1701,7 @@ static int pri_rbsbits(struct dahdi_chan *chan, int bits)
|
||||
return -EINVAL;
|
||||
} else {
|
||||
XPD_NOTICE(xpd, "%s: protocol %s is not supported yet with CAS\n",
|
||||
__FUNCTION__, pri_protocol_name(priv->pri_protocol));
|
||||
__func__, pri_protocol_name(priv->pri_protocol));
|
||||
return -EINVAL;
|
||||
}
|
||||
return 0;
|
||||
@ -1996,19 +1996,19 @@ static int decode_cas_e1(xpd_t *xpd, byte regnum, byte data_low)
|
||||
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) {
|
||||
XPD_ERR(xpd, "%s: got bad pos=%d [0-%d]\n", __FUNCTION__, 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) {
|
||||
XPD_NOTICE(xpd, "%s: %s CAS: Bad chan1 number (%d)\n",
|
||||
__FUNCTION__,
|
||||
__func__,
|
||||
pri_protocol_name(priv->pri_protocol),
|
||||
chan1);
|
||||
return -EINVAL;
|
||||
}
|
||||
if(chan2 < 0 || chan2 > PHONEDEV(xpd).channels) {
|
||||
XPD_NOTICE(xpd, "%s: %s CAS: Bad chan2 number (%d)\n",
|
||||
__FUNCTION__,
|
||||
__func__,
|
||||
pri_protocol_name(priv->pri_protocol),
|
||||
chan2);
|
||||
return -EINVAL;
|
||||
@ -2058,12 +2058,12 @@ static int decode_cas_t1(xpd_t *xpd, byte regnum, byte data_low)
|
||||
rxsig <<= 2;
|
||||
pos = rsnum * chan_per_reg + chan_per_reg - i - 1;
|
||||
if(pos < 0 || pos >= PHONEDEV(xpd).channels) {
|
||||
XPD_ERR(xpd, "%s: Bad pos=%d\n", __FUNCTION__, pos);
|
||||
XPD_ERR(xpd, "%s: Bad pos=%d\n", __func__, pos);
|
||||
continue;
|
||||
}
|
||||
chan = XPD_CHAN(xpd, pos);
|
||||
if(!chan) {
|
||||
XPD_ERR(xpd, "%s: Null channel in pos=%d\n", __FUNCTION__, pos);
|
||||
XPD_ERR(xpd, "%s: Null channel in pos=%d\n", __func__, pos);
|
||||
continue;
|
||||
}
|
||||
if(chan->rxsig != rxsig) {
|
||||
@ -2110,7 +2110,7 @@ static void process_cas_dchan(xpd_t *xpd, byte regnum, byte data_low)
|
||||
|
||||
XPD_NOTICE(xpd,
|
||||
"%s: received register 0x%X in protocol %s. Ignore\n",
|
||||
__FUNCTION__, regnum, pri_protocol_name(priv->pri_protocol));
|
||||
__func__, regnum, pri_protocol_name(priv->pri_protocol));
|
||||
return;
|
||||
}
|
||||
if(decode_cas_e1(xpd, regnum, data_low) < 0)
|
||||
@ -2119,14 +2119,14 @@ static void process_cas_dchan(xpd_t *xpd, byte regnum, byte data_low)
|
||||
if(regnum > REG_RS12_E) {
|
||||
XPD_NOTICE(xpd,
|
||||
"%s: received register 0x%X in protocol %s. Ignore\n",
|
||||
__FUNCTION__, regnum, pri_protocol_name(priv->pri_protocol));
|
||||
__func__, regnum, pri_protocol_name(priv->pri_protocol));
|
||||
return;
|
||||
}
|
||||
if(decode_cas_t1(xpd, regnum, data_low) < 0)
|
||||
return;
|
||||
} else {
|
||||
XPD_NOTICE(xpd, "%s: protocol %s is not supported yet with CAS\n",
|
||||
__FUNCTION__, pri_protocol_name(priv->pri_protocol));
|
||||
__func__, pri_protocol_name(priv->pri_protocol));
|
||||
}
|
||||
priv->cas_replies++;
|
||||
}
|
||||
@ -2151,7 +2151,7 @@ static int PRI_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
|
||||
static int rate_limit;
|
||||
|
||||
if((rate_limit++ % 1003) < 5)
|
||||
notify_bad_xpd(__FUNCTION__, xbus, addr , orig_xpd->xpdname);
|
||||
notify_bad_xpd(__func__, xbus, addr , orig_xpd->xpdname);
|
||||
return -EPROTO;
|
||||
}
|
||||
spin_lock_irqsave(&xpd->lock, flags);
|
||||
@ -2518,37 +2518,37 @@ static int pri_xpd_probe(struct device *dev)
|
||||
XPD_DBG(DEVICES, xpd, "SYSFS\n");
|
||||
ret = device_create_file(dev, &dev_attr_pri_protocol);
|
||||
if(ret) {
|
||||
XPD_ERR(xpd, "%s: device_create_file(pri_protocol) failed: %d\n", __FUNCTION__, 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) {
|
||||
XPD_ERR(xpd, "%s: device_create_file(pri_localloop) failed: %d\n", __FUNCTION__, 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) {
|
||||
XPD_ERR(xpd, "%s: device_create_file(pri_layer1) failed: %d\n", __FUNCTION__, 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) {
|
||||
XPD_ERR(xpd, "%s: device_create_file(pri_alarms) failed: %d\n", __FUNCTION__, 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) {
|
||||
XPD_ERR(xpd, "%s: device_create_file(pri_cas) failed: %d\n", __FUNCTION__, 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) {
|
||||
XPD_ERR(xpd, "%s: device_create_file(pri_dchan) failed: %d\n", __FUNCTION__, 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) {
|
||||
XPD_ERR(xpd, "%s: device_create_file(pri_clocking) failed: %d\n", __FUNCTION__, ret);
|
||||
XPD_ERR(xpd, "%s: device_create_file(pri_clocking) failed: %d\n", __func__, ret);
|
||||
goto fail_pri_clocking;
|
||||
}
|
||||
return 0;
|
||||
|
||||
@ -46,33 +46,33 @@
|
||||
category, THIS_MODULE->name, (xbus)->busname, (unit), (port), ## __VA_ARGS__)
|
||||
|
||||
#define DBG(bits, fmt, ...) \
|
||||
((void)((debug & (DBG_ ## bits)) && PRINTK(DEBUG, "-" #bits, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
|
||||
((void)((debug & (DBG_ ## bits)) && PRINTK(DEBUG, "-" #bits, "%s: " fmt, __func__, ## __VA_ARGS__)))
|
||||
#define INFO(fmt, ...) PRINTK(INFO, "", fmt, ## __VA_ARGS__)
|
||||
#define NOTICE(fmt, ...) PRINTK(NOTICE, "", fmt, ## __VA_ARGS__)
|
||||
#define WARNING(fmt, ...) PRINTK(WARNING, "", fmt, ## __VA_ARGS__)
|
||||
#define ERR(fmt, ...) PRINTK(ERR, "", fmt, ## __VA_ARGS__)
|
||||
|
||||
#define XBUS_DBG(bits, xbus, fmt, ...) \
|
||||
((void)((debug & (DBG_ ## bits)) && XBUS_PRINTK(DEBUG, "-" #bits, xbus, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
|
||||
((void)((debug & (DBG_ ## bits)) && XBUS_PRINTK(DEBUG, "-" #bits, xbus, "%s: " fmt, __func__, ## __VA_ARGS__)))
|
||||
#define XBUS_INFO(xbus, fmt, ...) XBUS_PRINTK(INFO, "", xbus, fmt, ## __VA_ARGS__)
|
||||
#define XBUS_NOTICE(xbus, fmt, ...) XBUS_PRINTK(NOTICE, "", xbus, fmt, ## __VA_ARGS__)
|
||||
#define XBUS_ERR(xbus, fmt, ...) XBUS_PRINTK(ERR, "", xbus, fmt, ## __VA_ARGS__)
|
||||
|
||||
#define XPD_DBG(bits, xpd, fmt, ...) \
|
||||
((void)((debug & (DBG_ ## bits)) && XPD_PRINTK(DEBUG, "-" #bits, xpd, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
|
||||
((void)((debug & (DBG_ ## bits)) && XPD_PRINTK(DEBUG, "-" #bits, xpd, "%s: " fmt, __func__, ## __VA_ARGS__)))
|
||||
#define XPD_INFO(xpd, fmt, ...) XPD_PRINTK(INFO, "", xpd, fmt, ## __VA_ARGS__)
|
||||
#define XPD_NOTICE(xpd, fmt, ...) XPD_PRINTK(NOTICE, "", xpd, fmt, ## __VA_ARGS__)
|
||||
#define XPD_WARNING(xpd, fmt, ...) XPD_PRINTK(WARNING, "", xpd, fmt, ## __VA_ARGS__)
|
||||
#define XPD_ERR(xpd, fmt, ...) XPD_PRINTK(ERR, "", xpd, fmt, ## __VA_ARGS__)
|
||||
|
||||
#define LINE_DBG(bits, xpd, pos, fmt, ...) \
|
||||
((void)((debug & (DBG_ ## bits)) && LINE_PRINTK(DEBUG, "-" #bits, xpd, pos, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
|
||||
((void)((debug & (DBG_ ## bits)) && LINE_PRINTK(DEBUG, "-" #bits, xpd, pos, "%s: " fmt, __func__, ## __VA_ARGS__)))
|
||||
#define LINE_NOTICE(xpd, pos, fmt, ...) LINE_PRINTK(NOTICE, "", xpd, pos, fmt, ## __VA_ARGS__)
|
||||
#define LINE_ERR(xpd, pos, fmt, ...) LINE_PRINTK(ERR, "", xpd, pos, fmt, ## __VA_ARGS__)
|
||||
|
||||
#define PORT_DBG(bits, xbus, unit, port, fmt, ...) \
|
||||
((void)((debug & (DBG_ ## bits)) && PORT_PRINTK(DEBUG, "-" #bits, \
|
||||
xbus, unit, port, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
|
||||
xbus, unit, port, "%s: " fmt, __func__, ## __VA_ARGS__)))
|
||||
#define PORT_NOTICE(xbus, unit, port, fmt, ...) PORT_PRINTK(NOTICE, "", xbus, unit, port, fmt, ## __VA_ARGS__)
|
||||
#define PORT_ERR(xbus, unit, port, fmt, ...) PORT_PRINTK(ERR, "", xbus, unit, port, fmt, ## __VA_ARGS__)
|
||||
|
||||
|
||||
@ -383,7 +383,7 @@ static int xpp_mmap_proc_write(struct file *file, const char __user *buffer, uns
|
||||
if (*p == '\0') break;
|
||||
value = simple_strtoul(p, &endp, 16);
|
||||
if (endp == p || value > 0xFF) {
|
||||
INFO("%s: Bad input\n", __FUNCTION__);
|
||||
INFO("%s: Bad input\n", __func__);
|
||||
count = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
@ -164,7 +164,7 @@ static void finalize_xbuses_array(void)
|
||||
|
||||
for(i = 0; i < ARRAY_SIZE(xbuses_array); i++) {
|
||||
if(xbuses_array[i].xbus != NULL) {
|
||||
ERR("%s: xbus #%d is not NULL\n", __FUNCTION__, i);
|
||||
ERR("%s: xbus #%d is not NULL\n", __func__, i);
|
||||
BUG();
|
||||
}
|
||||
}
|
||||
@ -272,7 +272,7 @@ void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe, i
|
||||
|
||||
if(xframe->xframe_magic != XFRAME_MAGIC) {
|
||||
XBUS_ERR(xbus, "%s: bad xframe_magic %lX\n",
|
||||
__FUNCTION__, xframe->xframe_magic);
|
||||
__func__, xframe->xframe_magic);
|
||||
return;
|
||||
}
|
||||
spin_lock_irqsave(&serialize_dump_xframe, flags);
|
||||
@ -472,13 +472,13 @@ int send_cmd_frame(xbus_t *xbus, xframe_t *xframe)
|
||||
goto err;
|
||||
}
|
||||
if(debug & DBG_COMMANDS)
|
||||
dump_xframe(__FUNCTION__, xbus, xframe, DBG_ANY);
|
||||
dump_xframe(__func__, xbus, xframe, DBG_ANY);
|
||||
if(!xframe_enqueue(&xbus->command_queue, xframe)) {
|
||||
if((rate_limit++ % 1003) == 0) {
|
||||
XBUS_ERR(xbus,
|
||||
"Dropped command xframe. Cannot enqueue (%d)\n",
|
||||
rate_limit);
|
||||
dump_xframe(__FUNCTION__, xbus, xframe, DBG_ANY);
|
||||
dump_xframe(__func__, xbus, xframe, DBG_ANY);
|
||||
}
|
||||
xbus_setstate(xbus, XBUS_STATE_FAIL);
|
||||
ret = -E2BIG;
|
||||
@ -582,7 +582,7 @@ int xbus_xpd_bind(xbus_t *xbus, xpd_t *xpd, int unit, int subunit)
|
||||
spin_unlock_irqrestore(&xbus->lock, flags);
|
||||
/* Must be done out of atomic context */
|
||||
if(xpd_device_register(xbus, xpd) < 0) {
|
||||
XPD_ERR(xpd, "%s: xpd_device_register() failed\n", __FUNCTION__);
|
||||
XPD_ERR(xpd, "%s: xpd_device_register() failed\n", __func__);
|
||||
/* FIXME: What to do? */
|
||||
}
|
||||
return 0;
|
||||
@ -595,18 +595,18 @@ int xbus_xpd_unbind(xbus_t *xbus, xpd_t *xpd)
|
||||
|
||||
XBUS_DBG(DEVICES, xbus, "XPD #%d\n", xpd_num);
|
||||
if(!VALID_XPD_NUM(xpd_num)) {
|
||||
XBUS_ERR(xbus, "%s: Bad xpd_num = %d\n", __FUNCTION__, xpd_num);
|
||||
XBUS_ERR(xbus, "%s: Bad xpd_num = %d\n", __func__, xpd_num);
|
||||
BUG();
|
||||
}
|
||||
if(xbus->xpds[xpd_num] == NULL) {
|
||||
XBUS_ERR(xbus, "%s: slot xpd_num=%d is empty\n", __FUNCTION__, xpd_num);
|
||||
XBUS_ERR(xbus, "%s: slot xpd_num=%d is empty\n", __func__, xpd_num);
|
||||
BUG();
|
||||
}
|
||||
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",
|
||||
__FUNCTION__, xpd_num, other, other->xpdname);
|
||||
__func__, xpd_num, other, other->xpdname);
|
||||
BUG();
|
||||
}
|
||||
spin_lock_irqsave(&xbus->lock, flags);
|
||||
@ -1031,7 +1031,7 @@ void xbus_populate(void *data)
|
||||
|
||||
xbus = container_of(worker, xbus_t, worker);
|
||||
xbus = get_xbus(__func__, xbus->num); /* return in function end */
|
||||
XBUS_DBG(DEVICES, xbus, "Entering %s\n", __FUNCTION__);
|
||||
XBUS_DBG(DEVICES, xbus, "Entering %s\n", __func__);
|
||||
spin_lock_irqsave(&worker->worker_lock, flags);
|
||||
list_for_each_safe(card, next_card, &worker->card_list) {
|
||||
struct card_desc_struct *card_desc = list_entry(card, struct card_desc_struct, card_list);
|
||||
@ -1091,12 +1091,12 @@ int xbus_process_worker(xbus_t *xbus)
|
||||
struct xbus_workqueue *worker;
|
||||
|
||||
if(!xbus) {
|
||||
ERR("%s: xbus gone -- skip initialization\n", __FUNCTION__);
|
||||
ERR("%s: xbus gone -- skip initialization\n", __func__);
|
||||
return 0;
|
||||
}
|
||||
worker = &xbus->worker;
|
||||
if (down_trylock(&worker->running_initialization)) {
|
||||
ERR("%s: xbus is disconnected -- skip initialization\n", __FUNCTION__);
|
||||
ERR("%s: xbus is disconnected -- skip initialization\n", __func__);
|
||||
return 0;
|
||||
}
|
||||
XBUS_DBG(DEVICES, xbus, "\n");
|
||||
@ -1130,7 +1130,7 @@ static void worker_reset(xbus_t *xbus)
|
||||
DBG(DEVICES, "%s\n", name);
|
||||
if(!worker->xpds_init_done) {
|
||||
NOTICE("%s: worker(%s)->xpds_init_done=%d\n",
|
||||
__FUNCTION__, name, worker->xpds_init_done);
|
||||
__func__, name, worker->xpds_init_done);
|
||||
}
|
||||
spin_lock_irqsave(&worker->worker_lock, flags);
|
||||
list_for_each_safe(card, next_card, &worker->card_list) {
|
||||
@ -1278,7 +1278,7 @@ bool xbus_setstate(xbus_t *xbus, enum xbus_state newstate)
|
||||
goto bad_state;
|
||||
break;
|
||||
default:
|
||||
XBUS_NOTICE(xbus, "%s: unknown state %d\n", __FUNCTION__, newstate);
|
||||
XBUS_NOTICE(xbus, "%s: unknown state %d\n", __func__, newstate);
|
||||
goto out;
|
||||
}
|
||||
/* All good */
|
||||
@ -1387,7 +1387,7 @@ static xbus_t *xbus_alloc(void)
|
||||
|
||||
xbus = KZALLOC(sizeof(xbus_t), GFP_KERNEL);
|
||||
if(!xbus) {
|
||||
ERR("%s: out of memory\n", __FUNCTION__);
|
||||
ERR("%s: out of memory\n", __func__);
|
||||
return NULL;
|
||||
}
|
||||
spin_lock_irqsave(&xbuses_lock, flags);
|
||||
@ -1395,7 +1395,7 @@ static xbus_t *xbus_alloc(void)
|
||||
if(xbuses_array[i].xbus == NULL)
|
||||
break;
|
||||
if(i >= MAX_BUSES) {
|
||||
ERR("%s: No free slot for new bus. i=%d\n", __FUNCTION__, i);
|
||||
ERR("%s: No free slot for new bus. i=%d\n", __func__, i);
|
||||
KZFREE(xbus);
|
||||
xbus = NULL;
|
||||
goto out;
|
||||
@ -1456,7 +1456,7 @@ xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size, struct device *tran
|
||||
BUG_ON(!ops);
|
||||
xbus = xbus_alloc();
|
||||
if(!xbus) {
|
||||
ERR("%s: Failed allocating new xbus\n", __FUNCTION__);
|
||||
ERR("%s: Failed allocating new xbus\n", __func__);
|
||||
return NULL;
|
||||
}
|
||||
snprintf(xbus->busname, XBUS_NAMELEN, "XBUS-%02d", xbus->num);
|
||||
@ -1700,7 +1700,7 @@ static int xbus_read_proc(char *page, char **start, off_t off, int count, int *e
|
||||
}
|
||||
len += sprintf(page + len, "<-- len=%d\n", len);
|
||||
spin_unlock_irqrestore(&xbus->lock, flags);
|
||||
put_xbus(__FUNCTION__, xbus); /* from xbus_read_proc() */
|
||||
put_xbus(__func__, xbus); /* from xbus_read_proc() */
|
||||
out:
|
||||
if (len <= off+count)
|
||||
*eof = 1;
|
||||
@ -1728,7 +1728,7 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer,
|
||||
const size_t max_text = max_len * 3 + 10;
|
||||
|
||||
if(count > max_text) {
|
||||
XBUS_ERR(xbus, "%s: line too long (%ld > %zd)\n", __FUNCTION__, count, max_len);
|
||||
XBUS_ERR(xbus, "%s: line too long (%ld > %zd)\n", __func__, count, max_len);
|
||||
return -EFBIG;
|
||||
}
|
||||
/* 3 bytes per hex-digit and space */
|
||||
@ -1757,7 +1757,7 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer,
|
||||
break;
|
||||
if(!isxdigit(*p)) {
|
||||
XBUS_ERR(xbus, "%s: bad hex value ASCII='0x%X' at position %ld\n",
|
||||
__FUNCTION__, *p, (long)(p - buf));
|
||||
__func__, *p, (long)(p - buf));
|
||||
count = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
@ -1768,7 +1768,7 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer,
|
||||
hexdigit[1] = *p++;
|
||||
if(sscanf(hexdigit, "%2X", &val) != 1) {
|
||||
XBUS_ERR(xbus, "%s: bad hex value '%s' at position %ld\n",
|
||||
__FUNCTION__, hexdigit, (long)(p - buf));
|
||||
__func__, hexdigit, (long)(p - buf));
|
||||
count = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
@ -401,7 +401,7 @@ void got_new_syncer(xbus_t *xbus, enum sync_mode mode, int drift)
|
||||
case SYNC_MODE_QUERY: /* ignore */
|
||||
break;
|
||||
default:
|
||||
XBUS_ERR(xbus, "%s: unknown mode=0x%X\n", __FUNCTION__, mode);
|
||||
XBUS_ERR(xbus, "%s: unknown mode=0x%X\n", __func__, mode);
|
||||
}
|
||||
out:
|
||||
spin_unlock_irqrestore(&ref_ticker_lock, flags2);
|
||||
@ -987,7 +987,7 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe)
|
||||
if((rate_limit++ % 1003) == 0) {
|
||||
XBUS_NOTICE(xbus,
|
||||
"%s: Non-PCM packet within a PCM xframe. (%d)\n",
|
||||
__FUNCTION__, rate_limit);
|
||||
__func__, rate_limit);
|
||||
dump_xframe("In PCM xframe", xbus, xframe, debug);
|
||||
}
|
||||
goto out;
|
||||
@ -999,7 +999,7 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe)
|
||||
if((rate_limit++ % 1003) == 0) {
|
||||
XBUS_NOTICE(xbus,
|
||||
"%s: Invalid packet length %d. (%d)\n",
|
||||
__FUNCTION__, len, rate_limit);
|
||||
__func__, len, rate_limit);
|
||||
dump_xframe("BAD LENGTH", xbus, xframe, debug);
|
||||
}
|
||||
goto out;
|
||||
@ -1009,7 +1009,7 @@ static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe)
|
||||
static int rate_limit;
|
||||
|
||||
if((rate_limit++ % 1003) == 0) {
|
||||
notify_bad_xpd(__FUNCTION__, xbus, XPACKET_ADDR(pack), "RECEIVE PCM");
|
||||
notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), "RECEIVE PCM");
|
||||
dump_xframe("Unknown XPD addr", xbus, xframe, debug);
|
||||
}
|
||||
goto out;
|
||||
@ -1093,7 +1093,7 @@ static void xbus_tick(xbus_t *xbus)
|
||||
if((rate_limit++ % 3001) == 0)
|
||||
XBUS_ERR(xbus,
|
||||
"%s: failed to allocate new xframe\n",
|
||||
__FUNCTION__);
|
||||
__func__);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -1227,7 +1227,7 @@ int exec_sync_command(const char *buf, size_t count)
|
||||
CALL_PROTO(GLOBAL, SYNC_SOURCE, xbus, NULL, SYNC_MODE_QUERY, 0);
|
||||
put_xbus(__func__, xbus);
|
||||
} else {
|
||||
ERR("%s: cannot parse '%s'\n", __FUNCTION__, buf);
|
||||
ERR("%s: cannot parse '%s'\n", __func__, buf);
|
||||
ret = -EINVAL;
|
||||
}
|
||||
return ret;
|
||||
|
||||
@ -88,7 +88,7 @@ static DEVICE_ATTR_WRITER(xbus_state_store, dev, buf, count)
|
||||
xbus_activate(xbus);
|
||||
else {
|
||||
XBUS_NOTICE(xbus, "%s: Illegal action %s in state %s. Ignored.\n",
|
||||
__FUNCTION__, buf,
|
||||
__func__, buf,
|
||||
xbus_statename(XBUS_STATE(xbus)));
|
||||
return -EINVAL;
|
||||
}
|
||||
@ -759,7 +759,7 @@ int xpd_driver_register(struct device_driver *driver)
|
||||
driver->bus = &xpd_type;
|
||||
if((ret = driver_register(driver)) < 0) {
|
||||
ERR("%s: driver_register(%s) failed. Error number %d",
|
||||
__FUNCTION__, driver->name, ret);
|
||||
__func__, driver->name, ret);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -794,7 +794,7 @@ int xpd_device_register(xbus_t *xbus, xpd_t *xpd)
|
||||
dev->release = xpd_release;
|
||||
ret = device_register(dev);
|
||||
if(ret) {
|
||||
XPD_ERR(xpd, "%s: device_register failed: %d\n", __FUNCTION__, ret);
|
||||
XPD_ERR(xpd, "%s: device_register failed: %d\n", __func__, ret);
|
||||
return ret;
|
||||
}
|
||||
return 0;
|
||||
@ -979,7 +979,7 @@ int xbus_sysfs_create(xbus_t *xbus)
|
||||
astribank->release = astribank_release;
|
||||
ret = device_register(astribank);
|
||||
if(ret) {
|
||||
XBUS_ERR(xbus, "%s: device_register failed: %d\n", __FUNCTION__, ret);
|
||||
XBUS_ERR(xbus, "%s: device_register failed: %d\n", __func__, ret);
|
||||
dev_set_drvdata(astribank, NULL);
|
||||
}
|
||||
return ret;
|
||||
@ -992,17 +992,17 @@ int __init xpp_driver_init(void)
|
||||
DBG(DEVICES, "SYSFS\n");
|
||||
if((ret = bus_register(&toplevel_bus_type)) < 0) {
|
||||
ERR("%s: bus_register(%s) failed. Error number %d",
|
||||
__FUNCTION__, toplevel_bus_type.name, ret);
|
||||
__func__, toplevel_bus_type.name, ret);
|
||||
goto failed_toplevel;
|
||||
}
|
||||
if((ret = driver_register(&xpp_driver)) < 0) {
|
||||
ERR("%s: driver_register(%s) failed. Error number %d",
|
||||
__FUNCTION__, xpp_driver.name, ret);
|
||||
__func__, xpp_driver.name, ret);
|
||||
goto failed_xpp_driver;
|
||||
}
|
||||
if((ret = bus_register(&xpd_type)) < 0) {
|
||||
ERR("%s: bus_register(%s) failed. Error number %d",
|
||||
__FUNCTION__, xpd_type.name, ret);
|
||||
__func__, xpd_type.name, ret);
|
||||
goto failed_xpd_bus;
|
||||
}
|
||||
return 0;
|
||||
|
||||
@ -39,7 +39,7 @@ typedef uint32_t __u32;
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#define DBG(fmt, ...) printf("DBG: %s: " fmt, __FUNCTION__, ## __VA_ARGS__)
|
||||
#define DBG(fmt, ...) printf("DBG: %s: " fmt, __func__, ## __VA_ARGS__)
|
||||
#define INFO(fmt, ...) printf("INFO: " fmt, ## __VA_ARGS__)
|
||||
#define NOTICE(fmt, ...) printf("NOTICE: " fmt, ## __VA_ARGS__)
|
||||
#define ERR(fmt, ...) printf("ERR: " fmt, ## __VA_ARGS__)
|
||||
|
||||
@ -162,7 +162,7 @@ static xframe_t *transport_alloc_xframe(xbus_t *xbus, gfp_t gfp_flags)
|
||||
return NULL;
|
||||
}
|
||||
spin_lock_irqsave(&xbus->transport.lock, flags);
|
||||
//XBUS_INFO(xbus, "%s (transport_refcount=%d)\n", __FUNCTION__, atomic_read(&xbus->transport.transport_refcount));
|
||||
//XBUS_INFO(xbus, "%s (transport_refcount=%d)\n", __func__, atomic_read(&xbus->transport.transport_refcount));
|
||||
xframe = ops->alloc_xframe(xbus, gfp_flags);
|
||||
if(!xframe) {
|
||||
static int rate_limit;
|
||||
@ -187,7 +187,7 @@ static void transport_free_xframe(xbus_t *xbus, xframe_t *xframe)
|
||||
ops = xbus->transport.ops;
|
||||
BUG_ON(!ops);
|
||||
spin_lock_irqsave(&xbus->transport.lock, flags);
|
||||
//XBUS_INFO(xbus, "%s (transport_refcount=%d)\n", __FUNCTION__, atomic_read(&xbus->transport.transport_refcount));
|
||||
//XBUS_INFO(xbus, "%s (transport_refcount=%d)\n", __func__, atomic_read(&xbus->transport.transport_refcount));
|
||||
ops->free_xframe(xbus, xframe);
|
||||
transportops_put(xbus);
|
||||
spin_unlock_irqrestore(&xbus->transport.lock, flags);
|
||||
@ -273,7 +273,7 @@ xframe_t *get_xframe(struct xframe_queue *q)
|
||||
*
|
||||
* memset(xframe->packets, 0, xframe->frame_maxlen);
|
||||
*/
|
||||
//XBUS_INFO(xbus, "%s\n", __FUNCTION__);
|
||||
//XBUS_INFO(xbus, "%s\n", __func__);
|
||||
return xframe;
|
||||
}
|
||||
|
||||
@ -284,7 +284,7 @@ void put_xframe(struct xframe_queue *q, xframe_t *xframe)
|
||||
BUG_ON(!q);
|
||||
xbus = (xbus_t *)q->priv;
|
||||
BUG_ON(!xbus);
|
||||
//XBUS_INFO(xbus, "%s\n", __FUNCTION__);
|
||||
//XBUS_INFO(xbus, "%s\n", __func__);
|
||||
BUG_ON(!TRANSPORT_EXIST(xbus));
|
||||
if(unlikely(!xframe_enqueue(q, xframe))) {
|
||||
XBUS_ERR(xbus, "Failed returning xframe to %s\n", q->name);
|
||||
|
||||
@ -210,7 +210,7 @@ void xpd_free(xpd_t *xpd)
|
||||
/*
|
||||
* This must be last, so the xbus cannot be released before the xpd
|
||||
*/
|
||||
put_xbus(__FUNCTION__, xbus); /* was taken in xpd_alloc() */
|
||||
put_xbus(__func__, xbus); /* was taken in xpd_alloc() */
|
||||
}
|
||||
|
||||
/*
|
||||
@ -401,7 +401,7 @@ const char *xpd_statename(enum xpd_state st)
|
||||
bool xpd_setstate(xpd_t *xpd, enum xpd_state newstate)
|
||||
{
|
||||
BUG_ON(!xpd);
|
||||
XPD_DBG(DEVICES, xpd, "%s: %s (%d) -> %s (%d)\n", __FUNCTION__,
|
||||
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) {
|
||||
@ -413,7 +413,7 @@ bool xpd_setstate(xpd_t *xpd, enum xpd_state newstate)
|
||||
if(xpd->addr.subunit != 0) {
|
||||
XPD_NOTICE(xpd,
|
||||
"%s: Moving to %s allowed only for subunit 0\n",
|
||||
__FUNCTION__, xpd_statename(newstate));
|
||||
__func__, xpd_statename(newstate));
|
||||
goto badstate;
|
||||
}
|
||||
break;
|
||||
@ -430,13 +430,13 @@ bool xpd_setstate(xpd_t *xpd, enum xpd_state newstate)
|
||||
case XPD_STATE_NOHW:
|
||||
break;
|
||||
default:
|
||||
XPD_ERR(xpd, "%s: Unknown newstate=%d\n", __FUNCTION__, newstate);
|
||||
XPD_ERR(xpd, "%s: Unknown newstate=%d\n", __func__, newstate);
|
||||
}
|
||||
xpd->xpd_state = newstate;
|
||||
return 1;
|
||||
badstate:
|
||||
XPD_NOTICE(xpd, "%s: cannot transition: %s (%d) -> %s (%d)\n",
|
||||
__FUNCTION__,
|
||||
__func__,
|
||||
xpd_statename(xpd->xpd_state), xpd->xpd_state,
|
||||
xpd_statename(newstate), newstate);
|
||||
return 0;
|
||||
@ -477,7 +477,7 @@ __must_check static int phonedev_init(xpd_t *xpd, const xproto_table_t *proto_ta
|
||||
atomic_set(&phonedev->open_counter, 0);
|
||||
for (x = 0; x < phonedev->channels; x++) {
|
||||
if (!(phonedev->chans[x] = KZALLOC(sizeof(*(phonedev->chans[x])), GFP_KERNEL))) {
|
||||
ERR("%s: Unable to allocate channel %d\n", __FUNCTION__, x);
|
||||
ERR("%s: Unable to allocate channel %d\n", __func__, x);
|
||||
goto err;
|
||||
}
|
||||
phonedev->ec[x] = KZALLOC(sizeof(*(phonedev->ec[x])),
|
||||
@ -513,13 +513,13 @@ __must_check xpd_t *xpd_alloc(xbus_t *xbus,
|
||||
type, channels, alloc_size);
|
||||
if(channels > CHANNELS_PERXPD) {
|
||||
XBUS_ERR(xbus, "%s: type=%d: too many channels %d\n",
|
||||
__FUNCTION__, type, channels);
|
||||
__func__, type, channels);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if((xpd = KZALLOC(alloc_size, GFP_KERNEL)) == NULL) {
|
||||
XBUS_ERR(xbus, "%s: type=%d: Unable to allocate memory\n",
|
||||
__FUNCTION__, type);
|
||||
__func__, type);
|
||||
goto err;
|
||||
}
|
||||
xpd->priv = (byte *)xpd + sizeof(xpd_t);
|
||||
@ -576,7 +576,7 @@ void update_xpd_status(xpd_t *xpd, int alarm_flag)
|
||||
struct dahdi_span *span = &PHONEDEV(xpd).span;
|
||||
|
||||
if(!SPAN_REGISTERED(xpd)) {
|
||||
// XPD_NOTICE(xpd, "%s: XPD is not registered. Skipping.\n", __FUNCTION__);
|
||||
// XPD_NOTICE(xpd, "%s: XPD is not registered. Skipping.\n", __func__);
|
||||
return;
|
||||
}
|
||||
switch (alarm_flag) {
|
||||
@ -749,7 +749,7 @@ int xpp_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long arg)
|
||||
|
||||
if(!xpd) {
|
||||
ERR("%s: channel in pos %d, was already closed. Ignore.\n",
|
||||
__FUNCTION__, pos);
|
||||
__func__, pos);
|
||||
return -ENODEV;
|
||||
}
|
||||
switch (cmd) {
|
||||
@ -772,13 +772,13 @@ int xpp_hooksig(struct dahdi_chan *chan, enum dahdi_txsig txsig)
|
||||
|
||||
if(!xpd) {
|
||||
ERR("%s: channel in pos %d, was already closed. Ignore.\n",
|
||||
__FUNCTION__, pos);
|
||||
__func__, pos);
|
||||
return -ENODEV;
|
||||
}
|
||||
if(!PHONE_METHOD(card_hooksig, xpd)) {
|
||||
LINE_ERR(xpd, pos,
|
||||
"%s: No hooksig method for this channel. Ignore.\n",
|
||||
__FUNCTION__);
|
||||
__func__);
|
||||
return -ENODEV;
|
||||
}
|
||||
xbus = xpd->xbus;
|
||||
@ -863,7 +863,7 @@ static void echocan_free(struct dahdi_chan *chan,
|
||||
LINE_DBG(GENERAL, xpd, pos, "mode=0x%X\n", ec->status.mode);
|
||||
CALL_EC_METHOD(ec_set, xbus, xpd, pos, 0);
|
||||
CALL_EC_METHOD(ec_update, xbus, xbus);
|
||||
put_xpd(__FUNCTION__, xpd); /* aquired in xpp_echocan_create() */
|
||||
put_xpd(__func__, xpd); /* aquired in xpp_echocan_create() */
|
||||
}
|
||||
|
||||
static const struct dahdi_echocan_features xpp_ec_features = {
|
||||
@ -935,7 +935,7 @@ int xpp_echocan_create(struct dahdi_chan *chan,
|
||||
*ec = phonedev->ec[pos];
|
||||
(*ec)->ops = &xpp_ec_ops;
|
||||
(*ec)->features = xpp_ec_features;
|
||||
xpd = get_xpd(__FUNCTION__, xpd); /* Returned in echocan_free() */
|
||||
xpd = get_xpd(__func__, xpd); /* Returned in echocan_free() */
|
||||
LINE_DBG(GENERAL, xpd, pos, "(tap=%d, param_count=%d)\n",
|
||||
ecp->tap_length, ecp->param_count);
|
||||
ret = CALL_EC_METHOD(ec_set, xbus, xpd, pos, 1);
|
||||
|
||||
@ -57,7 +57,7 @@ static DEF_PARM(uint, drop_pcm_after, 6, 0644, "Number of consecutive tx_sluggis
|
||||
THIS_MODULE->name, (xusb)->index, xusb->path, xusb->serial, ## __VA_ARGS__)
|
||||
|
||||
#define XUSB_DBG(bits, xusb, fmt, ...) \
|
||||
((void)((debug & (DBG_ ## bits)) && XUSB_PRINTK(DEBUG, xusb, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
|
||||
((void)((debug & (DBG_ ## bits)) && XUSB_PRINTK(DEBUG, xusb, "%s: " fmt, __func__, ## __VA_ARGS__)))
|
||||
#define XUSB_ERR(xusb, fmt, ...) XUSB_PRINTK(ERR, xusb, fmt, ## __VA_ARGS__)
|
||||
#define XUSB_NOTICE(xusb, fmt, ...) XUSB_PRINTK(NOTICE, xusb, fmt, ## __VA_ARGS__)
|
||||
#define XUSB_INFO(xusb, fmt, ...) XUSB_PRINTK(INFO, xusb, fmt, ## __VA_ARGS__)
|
||||
@ -399,7 +399,7 @@ static int do_send_xframe(xbus_t *xbus, xframe_t *xframe)
|
||||
|
||||
if((rate_limit++ % 1000) == 0)
|
||||
XBUS_ERR(xbus, "%s: usb_submit_urb failed: %d\n",
|
||||
__FUNCTION__, ret);
|
||||
__func__, ret);
|
||||
ret = -EBADF;
|
||||
goto failure;
|
||||
}
|
||||
@ -439,7 +439,7 @@ static int xframe_send_cmd(xbus_t *xbus, xframe_t *xframe)
|
||||
{
|
||||
BUG_ON(!xbus);
|
||||
BUG_ON(!xframe);
|
||||
//XBUS_INFO(xbus, "%s:\n", __FUNCTION__);
|
||||
//XBUS_INFO(xbus, "%s:\n", __func__);
|
||||
return do_send_xframe(xbus, xframe);
|
||||
}
|
||||
|
||||
@ -467,7 +467,7 @@ static bool xusb_listen(xusb_t *xusb)
|
||||
|
||||
if((rate_limit++ % 1000) == 0)
|
||||
XBUS_ERR(xbus, "%s: usb_submit_urb failed: %d\n",
|
||||
__FUNCTION__, ret);
|
||||
__func__, ret);
|
||||
FREE_RECV_XFRAME(xbus, xframe);
|
||||
goto out;
|
||||
}
|
||||
|
||||
@ -86,7 +86,7 @@ const xproto_table_t *xproto_get(xpd_type_t cardtype)
|
||||
int ret = request_module(XPD_TYPE_PREFIX "%d", cardtype);
|
||||
if(ret != 0) {
|
||||
NOTICE("%s: Failed to load module for type=%d. exit status=%d.\n",
|
||||
__FUNCTION__, cardtype, ret);
|
||||
__func__, cardtype, ret);
|
||||
/* Drop through: we may be lucky... */
|
||||
}
|
||||
xtable = xprotocol_tables[cardtype];
|
||||
@ -97,7 +97,7 @@ const xproto_table_t *xproto_get(xpd_type_t cardtype)
|
||||
DBG(GENERAL, "%s refcount was %d\n", xtable->name, module_refcount(xtable->owner));
|
||||
#endif
|
||||
if(!try_module_get(xtable->owner)) {
|
||||
ERR("%s: try_module_get for %s failed.\n", __FUNCTION__, xtable->name);
|
||||
ERR("%s: try_module_get for %s failed.\n", __func__, xtable->name);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
@ -142,7 +142,7 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack)
|
||||
if(!valid_xpd_addr(&XPACKET_ADDR(pack))) {
|
||||
if(printk_ratelimit()) {
|
||||
XBUS_NOTICE(xbus, "%s: from %d%d: bad address.\n",
|
||||
__FUNCTION__,
|
||||
__func__,
|
||||
XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack));
|
||||
dump_packet("packet_process -- bad address", pack, debug);
|
||||
}
|
||||
@ -159,7 +159,7 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack)
|
||||
if(!xpd) {
|
||||
if(printk_ratelimit()) {
|
||||
XBUS_NOTICE(xbus, "%s: from %d%d opcode=0x%02X: no such global command.\n",
|
||||
__FUNCTION__,
|
||||
__func__,
|
||||
XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack), op);
|
||||
dump_packet("packet_process -- no such global command", pack, 1);
|
||||
}
|
||||
@ -169,7 +169,7 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack)
|
||||
if(!xtable) {
|
||||
if(printk_ratelimit())
|
||||
XPD_ERR(xpd, "%s: no protocol table (type=%d)\n",
|
||||
__FUNCTION__,
|
||||
__func__,
|
||||
xpd->type);
|
||||
goto out;
|
||||
}
|
||||
@ -177,7 +177,7 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack)
|
||||
if(!xe) {
|
||||
if(printk_ratelimit()) {
|
||||
XPD_NOTICE(xpd, "%s: bad command (type=%d,opcode=0x%x)\n",
|
||||
__FUNCTION__,
|
||||
__func__,
|
||||
xpd->type, op);
|
||||
dump_packet("packet_process -- bad command", pack, 1);
|
||||
}
|
||||
@ -189,7 +189,7 @@ static int packet_process(xbus_t *xbus, xpacket_t *pack)
|
||||
if(!table->packet_is_valid(pack)) {
|
||||
if(printk_ratelimit()) {
|
||||
ERR("xpp: %s: wrong size %d for opcode=0x%02X\n",
|
||||
__FUNCTION__, XPACKET_LEN(pack), op);
|
||||
__func__, XPACKET_LEN(pack), op);
|
||||
dump_packet("packet_process -- wrong size", pack, debug);
|
||||
}
|
||||
goto out;
|
||||
@ -322,10 +322,10 @@ void dump_packet(const char *msg, const xpacket_t *packet, bool debug)
|
||||
if(i >= sizeof(xpacket_t)) {
|
||||
if(limiter < ERR_REPORT_LIMIT) {
|
||||
ERR("%s: length overflow i=%d > sizeof(xpacket_t)=%lu\n",
|
||||
__FUNCTION__, i+1, (long)sizeof(xpacket_t));
|
||||
__func__, i+1, (long)sizeof(xpacket_t));
|
||||
} else if(limiter == ERR_REPORT_LIMIT) {
|
||||
ERR("%s: error packet #%d... squelsh reports.\n",
|
||||
__FUNCTION__, limiter);
|
||||
__func__, limiter);
|
||||
}
|
||||
limiter++;
|
||||
break;
|
||||
@ -349,7 +349,7 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus,
|
||||
|
||||
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",
|
||||
__FUNCTION__, msg, regcmd->bytes);
|
||||
__func__, msg, regcmd->bytes);
|
||||
return;
|
||||
}
|
||||
if(regcmd->is_multibyte) {
|
||||
@ -370,7 +370,7 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus,
|
||||
}
|
||||
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",
|
||||
__FUNCTION__, msg, regcmd->bytes);
|
||||
__func__, msg, regcmd->bytes);
|
||||
return;
|
||||
}
|
||||
snprintf(port_buf, MAX_PROC_WRITE, "%d%s",
|
||||
@ -416,13 +416,13 @@ const char *xproto_name(xpd_type_t xpd_type)
|
||||
|
||||
#define CHECK_XOP(xops, f) \
|
||||
if(!(xops)->f) { \
|
||||
ERR("%s: missing xmethod %s [%s (%d)]\n", __FUNCTION__, #f, name, type); \
|
||||
ERR("%s: missing xmethod %s [%s (%d)]\n", __func__, #f, name, type); \
|
||||
return -EINVAL; \
|
||||
}
|
||||
|
||||
#define CHECK_PHONEOP(phoneops, f) \
|
||||
if(!(phoneops)->f) { \
|
||||
ERR("%s: missing phone method %s [%s (%d)]\n", __FUNCTION__, #f, name, type); \
|
||||
ERR("%s: missing phone method %s [%s (%d)]\n", __func__, #f, name, type); \
|
||||
return -EINVAL; \
|
||||
}
|
||||
|
||||
@ -437,12 +437,12 @@ int xproto_register(const xproto_table_t *proto_table)
|
||||
type = proto_table->type;
|
||||
name = proto_table->name;
|
||||
if(type >= XPD_TYPE_NOMODULE) {
|
||||
NOTICE("%s: Bad xproto type %d\n", __FUNCTION__, type);
|
||||
NOTICE("%s: Bad xproto type %d\n", __func__, type);
|
||||
return -EINVAL;
|
||||
}
|
||||
DBG(GENERAL, "%s (%d)\n", name, type);
|
||||
if(xprotocol_tables[type])
|
||||
NOTICE("%s: overriding registration of %s (%d)\n", __FUNCTION__, name, type);
|
||||
NOTICE("%s: overriding registration of %s (%d)\n", __func__, name, type);
|
||||
xops = proto_table->xops;
|
||||
CHECK_XOP(xops, card_new);
|
||||
CHECK_XOP(xops, card_init);
|
||||
@ -477,11 +477,11 @@ void xproto_unregister(const xproto_table_t *proto_table)
|
||||
name = proto_table->name;
|
||||
DBG(GENERAL, "%s (%d)\n", name, type);
|
||||
if(type >= XPD_TYPE_NOMODULE) {
|
||||
NOTICE("%s: Bad xproto type %s (%d)\n", __FUNCTION__, name, type);
|
||||
NOTICE("%s: Bad xproto type %s (%d)\n", __func__, name, type);
|
||||
return;
|
||||
}
|
||||
if(!xprotocol_tables[type])
|
||||
NOTICE("%s: xproto type %s (%d) is already unregistered\n", __FUNCTION__, name, type);
|
||||
NOTICE("%s: xproto type %s (%d) is already unregistered\n", __func__, name, type);
|
||||
xprotocol_tables[type] = NULL;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user