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

xpp: style - place EXPORT_SYMBOL() (manually)

Browse Source 
Manually place EXPORT_SYMBOL() after symbols (or at end of functions).

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@10431 a0bf4364-ded3-4de4-8d8a-66a801d63aff
This commit is contained in:
Oron Peled
2012-01-11 20:01:32 +00:00
committed by Tzafrir Cohen
parent dbf3f017d9
commit cc083d440f
10 changed files with 73 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/dahdi/xpp/card_global.c
View File

@@ -413,6 +413,7 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,
ret = send_cmd_frame(xbus, xframe);
return ret;
}
EXPORT_SYMBOL(xpp_register_request);
/*
* The XPD parameter is totaly ignored by the driver and firmware as well.
@@ -766,7 +767,4 @@ int run_initialize_registers(xpd_t *xpd)
err:
return ret;
}
EXPORT_SYMBOL(sync_mode_name);
EXPORT_SYMBOL(run_initialize_registers);
EXPORT_SYMBOL(xpp_register_request);

3
drivers/dahdi/xpp/dahdi_debug.c
View File

@@ -55,6 +55,7 @@ void dump_poll(int debug, const char *msg, int poll)
DBG(GENERAL, "%s: %s\n", msg, poll_names[i].name);
}
}
EXPORT_SYMBOL(dump_poll);
void alarm2str(int alarm, char *buf, int buflen)
{
@@ -78,6 +79,4 @@ void alarm2str(int alarm, char *buf, int buflen)
if (p > buf) /* kill last comma */
*(p - 1) = '\0';
}
EXPORT_SYMBOL(dump_poll);
EXPORT_SYMBOL(alarm2str);

9
drivers/dahdi/xpp/mmapbus.c
View File

@@ -43,13 +43,12 @@ int register_mmap_device(struct mmap_device *dev)
strncpy(dev->dev.bus_id, dev->name, BUS_ID_SIZE);
return device_register(&dev->dev);
}
EXPORT_SYMBOL(register_mmap_device);
void unregister_mmap_device(struct mmap_device *dev)
{
device_unregister(&dev->dev);
}
EXPORT_SYMBOL(register_mmap_device);
EXPORT_SYMBOL(unregister_mmap_device);
int register_mmap_driver(struct mmap_driver *driver)
@@ -57,13 +56,12 @@ int register_mmap_driver(struct mmap_driver *driver)
driver->driver.bus = &mmap_bus_type;
return driver_register(&driver->driver);
}
EXPORT_SYMBOL(register_mmap_driver);
void unregister_mmap_driver(struct mmap_driver *driver)
{
driver_unregister(&driver->driver);
}
EXPORT_SYMBOL(register_mmap_driver);
EXPORT_SYMBOL(unregister_mmap_driver);
int register_mmap_bus(void)
@@ -80,14 +78,13 @@ bus_reg:
bus_type_reg:
return ret;
}
EXPORT_SYMBOL(register_mmap_bus);
void unregister_mmap_bus(void)
{
device_unregister(&mmap_bus);
bus_unregister(&mmap_bus_type);
}
EXPORT_SYMBOL(register_mmap_bus);
EXPORT_SYMBOL(unregister_mmap_bus);
MODULE_AUTHOR("Alexander Landau <landau.alex@gmail.com>");

1
drivers/dahdi/xpp/parport_debug.c
View File

@@ -59,7 +59,6 @@ void flip_parport_bit(unsigned char bitnum)
spin_unlock_irqrestore(&lock, flags);
parport_write_data(debug_sync_parport, value);
}
EXPORT_SYMBOL(flip_parport_bit);
static void parport_attach(struct parport *port)

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

@@ -144,6 +144,7 @@ const char *xbus_statename(enum xbus_state st)
}
return NULL;
}
EXPORT_SYMBOL(xbus_statename);
static void init_xbus(uint num, xbus_t *xbus)
{
@@ -163,6 +164,7 @@ xbus_t *xbus_num(uint num)
desc = &xbuses_array[num];
return desc->xbus;
}
EXPORT_SYMBOL(xbus_num);
static void initialize_xbuses_array(void)
{
@@ -241,6 +243,7 @@ void xframe_init(xbus_t *xbus, xframe_t *xframe, void *buf, size_t maxsize,
do_gettimeofday(&xframe->tv_created);
xframe->xframe_magic = XFRAME_MAGIC;
}
EXPORT_SYMBOL(xframe_init);
/*
* Return pointer to next packet slot in the frame
@@ -266,6 +269,7 @@ xpacket_t *xframe_next_packet(xframe_t *frm, int len)
atomic_add(len, &frm->frame_len);
return (xpacket_t *)(frm->packets + newlen - len);
}
EXPORT_SYMBOL(xframe_next_packet);
static DEFINE_SPINLOCK(serialize_dump_xframe);
@@ -371,6 +375,7 @@ void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe,
} while (1);
spin_unlock_irqrestore(&serialize_dump_xframe, flags);
}
EXPORT_SYMBOL(dump_xframe);
/**
*
@@ -402,6 +407,7 @@ error:
FREE_SEND_XFRAME(xbus, xframe);
return ret;
}
EXPORT_SYMBOL(send_pcm_frame);
static int really_send_cmd_frame(xbus_t *xbus, xframe_t *xframe)
{
@@ -462,6 +468,7 @@ int xbus_command_queue_tick(xbus_t *xbus)
xbus->usec_nosend = 0;
return ret;
}
EXPORT_SYMBOL(xbus_command_queue_tick);
static void xbus_command_queue_clean(xbus_t *xbus)
{
@@ -520,6 +527,7 @@ err:
FREE_SEND_XFRAME(xbus, xframe);
return ret;
}
EXPORT_SYMBOL(send_cmd_frame);
/*------------------------- Receive Tasklet Handling ---------------*/
@@ -571,6 +579,7 @@ void xbus_receive_xframe(xbus_t *xbus, xframe_t *xframe)
FREE_RECV_XFRAME(xbus, xframe);
}
}
EXPORT_SYMBOL(xbus_receive_xframe);
/*------------------------- Bus Management -------------------------*/
xpd_t *xpd_of(const xbus_t *xbus, int xpd_num)
@@ -579,6 +588,7 @@ xpd_t *xpd_of(const xbus_t *xbus, int xpd_num)
return NULL;
return xbus->xpds[xpd_num];
}
EXPORT_SYMBOL(xpd_of);
xpd_t *xpd_byaddr(const xbus_t *xbus, uint unit, uint subunit)
{
@@ -586,6 +596,7 @@ xpd_t *xpd_byaddr(const xbus_t *xbus, uint unit, uint subunit)
return NULL;
return xbus->xpds[XPD_IDX(unit, subunit)];
}
EXPORT_SYMBOL(xpd_byaddr);
int xbus_xpd_bind(xbus_t *xbus, xpd_t *xpd, int unit, int subunit)
{
@@ -1330,6 +1341,7 @@ bad_state:
xbus_statename(XBUS_STATE(xbus)), xbus_statename(newstate));
goto out;
}
EXPORT_SYMBOL(xbus_setstate);
int xbus_activate(xbus_t *xbus)
{
@@ -1346,6 +1358,7 @@ int xbus_activate(xbus_t *xbus)
xbus_request_sync(xbus, SYNC_MODE_NONE);
return 0;
}
EXPORT_SYMBOL(xbus_activate);
int xbus_connect(xbus_t *xbus)
{
@@ -1364,6 +1377,7 @@ int xbus_connect(xbus_t *xbus)
xbus_activate(xbus);
return 0;
}
EXPORT_SYMBOL(xbus_connect);
void xbus_deactivate(xbus_t *xbus)
{
@@ -1383,6 +1397,7 @@ void xbus_deactivate(xbus_t *xbus)
xbus_unregister_dahdi_device(xbus);
xbus_release_xpds(xbus); /* taken in xpd_alloc() [kref_init] */
}
EXPORT_SYMBOL(xbus_deactivate);
void xbus_disconnect(xbus_t *xbus)
{
@@ -1406,6 +1421,7 @@ void xbus_disconnect(xbus_t *xbus)
xbus_sysfs_transport_remove(xbus); /* Device-Model */
put_xbus(__func__, xbus); /* from xbus_new() [kref_init()] */
}
EXPORT_SYMBOL(xbus_disconnect);
static xbus_t *xbus_alloc(void)
{
@@ -1478,6 +1494,7 @@ void xbus_free(xbus_t *xbus)
spin_unlock_irqrestore(&xbuses_lock, flags);
KZFREE(xbus);
}
EXPORT_SYMBOL(xbus_free);
xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size,
struct device *transport_device, void *priv)
@@ -1572,6 +1589,7 @@ nobus:
xbus_free(xbus);
return NULL;
}
EXPORT_SYMBOL(xbus_new);
/*------------------------- Proc handling --------------------------*/
@@ -1584,6 +1602,7 @@ void xbus_reset_counters(xbus_t *xbus)
xbus->counters[i] = 0;
}
}
EXPORT_SYMBOL(xbus_reset_counters);
static bool xpds_done(xbus_t *xbus)
{
@@ -1927,6 +1946,7 @@ struct xbus_ops *transportops_get(xbus_t *xbus)
/* fall through */
return ops;
}
EXPORT_SYMBOL(transportops_get);
void transportops_put(xbus_t *xbus)
{
@@ -1938,6 +1958,7 @@ void transportops_put(xbus_t *xbus)
if (atomic_dec_and_test(&xbus->transport.transport_refcount))
wake_up(&xbus->transport.transport_unused);
}
EXPORT_SYMBOL(transportops_put);
/*------------------------- Initialization -------------------------*/
static void xbus_core_cleanup(void)
@@ -1984,25 +2005,3 @@ void xbus_core_shutdown(void)
xbus_core_cleanup();
xpp_driver_exit();
}
EXPORT_SYMBOL(xpd_of);
EXPORT_SYMBOL(xpd_byaddr);
EXPORT_SYMBOL(xbus_num);
EXPORT_SYMBOL(xbus_setstate);
EXPORT_SYMBOL(xbus_statename);
EXPORT_SYMBOL(xbus_new);
EXPORT_SYMBOL(xbus_free);
EXPORT_SYMBOL(xbus_connect);
EXPORT_SYMBOL(xbus_activate);
EXPORT_SYMBOL(xbus_deactivate);
EXPORT_SYMBOL(xbus_disconnect);
EXPORT_SYMBOL(xbus_receive_xframe);
EXPORT_SYMBOL(xbus_reset_counters);
EXPORT_SYMBOL(xframe_next_packet);
EXPORT_SYMBOL(dump_xframe);
EXPORT_SYMBOL(send_pcm_frame);
EXPORT_SYMBOL(send_cmd_frame);
EXPORT_SYMBOL(xframe_init);
EXPORT_SYMBOL(transportops_get);
EXPORT_SYMBOL(transportops_put);
EXPORT_SYMBOL(xbus_command_queue_tick);

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

@@ -45,7 +45,9 @@ static DEF_PARM(int, disable_pcm, 0, 0644, "Disable all PCM transmissions");
#ifdef DEBUG_PCMTX
DEF_PARM(int, pcmtx, -1, 0644,
"Forced PCM value to transmit (negative to disable)");
EXPORT_SYMBOL(pcmtx);
DEF_PARM(int, pcmtx_chan, 0, 0644, "channel to force PCM value");
EXPORT_SYMBOL(pcmtx_chan);
#endif
static DEF_PARM_BOOL(disable_pll_sync, 0, 0644,
"Disable automatic adjustment of AB clocks");
@@ -328,6 +330,7 @@ const char *sync_mode_name(enum sync_mode mode)
return NULL;
return sync_mode_names[mode];
}
EXPORT_SYMBOL(sync_mode_name);
/*
* Caller must aquire/release the 'ref_ticker_lock' spinlock
@@ -431,6 +434,7 @@ out:
spin_unlock_irqrestore(&ref_ticker_lock, flags2);
spin_unlock_irqrestore(&xbus->lock, flags);
}
EXPORT_SYMBOL(got_new_syncer);
void xbus_request_sync(xbus_t *xbus, enum sync_mode mode)
{
@@ -457,6 +461,7 @@ void xbus_request_sync(xbus_t *xbus, enum sync_mode mode)
xbus_set_command_timer(xbus, 1);
}
}
EXPORT_SYMBOL(xbus_request_sync);
static void reset_sync_counters(void)
{
@@ -569,6 +574,7 @@ void dahdi_sync_tick(struct dahdi_span *span, int is_master)
noop:
return;
}
EXPORT_SYMBOL(dahdi_sync_tick);
#endif
/*
@@ -695,6 +701,7 @@ void elect_syncer(const char *msg)
update_sync_master(the_xbus, force_dahdi_sync);
spin_unlock_irqrestore(&elect_syncer_lock, flags);
}
EXPORT_SYMBOL(elect_syncer);
/*
* This function should be called with the xpd already locked
@@ -706,6 +713,7 @@ void update_wanted_pcm_mask(xpd_t *xpd, xpp_line_t new_mask, uint new_pcm_len)
XPD_DBG(SIGNAL, xpd, "pcm_len=%d wanted_pcm_mask=0x%X\n",
PHONEDEV(xpd).pcm_len, PHONEDEV(xpd).wanted_pcm_mask);
}
EXPORT_SYMBOL(update_wanted_pcm_mask);
/*
* This function is used by FXS/FXO. The pcm_mask argument signifies
@@ -743,6 +751,7 @@ void generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask)
update_wanted_pcm_mask(xpd, pcm_mask, pcm_len);
spin_unlock_irqrestore(&PHONEDEV(xpd).lock_recompute_pcm, flags);
}
EXPORT_SYMBOL(generic_card_pcm_recompute);
void fill_beep(u_char *buf, int num, int duration)
{
@@ -931,6 +940,7 @@ void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack)
XPD_COUNTER(xpd, PCM_WRITE)++;
spin_unlock_irqrestore(&xpd->lock, flags);
}
EXPORT_SYMBOL(generic_card_pcm_fromspan);
void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack)
{
@@ -983,12 +993,12 @@ out:
XPD_COUNTER(xpd, PCM_READ)++;
spin_unlock_irqrestore(&xpd->lock, flags);
}
EXPORT_SYMBOL(generic_card_pcm_tospan);
int generic_echocancel_timeslot(xpd_t *xpd, int pos)
{
return xpd->addr.unit * 32 + pos;
}
EXPORT_SYMBOL(generic_echocancel_timeslot);
int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask)
@@ -1009,7 +1019,6 @@ int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask)
CALL_EC_METHOD(ec_update, xpd->xbus, xpd->xbus);
return 0;
}
EXPORT_SYMBOL(generic_echocancel_setmask);
static int copy_pcm_tospan(xbus_t *xbus, xframe_t *xframe)
@@ -1090,6 +1099,7 @@ int generic_timing_priority(xpd_t *xpd)
{
return PHONEDEV(xpd).timing_priority;
}
EXPORT_SYMBOL(generic_timing_priority);
static void xbus_tick(xbus_t *xbus)
{
@@ -1338,19 +1348,3 @@ int xbus_pcm_init(void *toplevel)
void xbus_pcm_shutdown(void)
{
}
EXPORT_SYMBOL(xbus_request_sync);
EXPORT_SYMBOL(got_new_syncer);
EXPORT_SYMBOL(elect_syncer);
#ifdef DAHDI_SYNC_TICK
EXPORT_SYMBOL(dahdi_sync_tick);
#endif
EXPORT_SYMBOL(update_wanted_pcm_mask);
EXPORT_SYMBOL(generic_card_pcm_recompute);
EXPORT_SYMBOL(generic_card_pcm_tospan);
EXPORT_SYMBOL(generic_card_pcm_fromspan);
EXPORT_SYMBOL(generic_timing_priority);
#ifdef DEBUG_PCMTX
EXPORT_SYMBOL(pcmtx);
EXPORT_SYMBOL(pcmtx_chan);
#endif

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

@@ -799,12 +799,14 @@ int xpd_driver_register(struct device_driver *driver)
}
return ret;
}
EXPORT_SYMBOL(xpd_driver_register);
void xpd_driver_unregister(struct device_driver *driver)
{
DBG(DEVICES, "%s\n", driver->name);
driver_unregister(driver);
}
EXPORT_SYMBOL(xpd_driver_unregister);
static void xpd_release(struct device *dev)
{
@@ -947,7 +949,6 @@ int echocancel_xpd(xpd_t *xpd, int on)
return ret;
}
EXPORT_SYMBOL(echocancel_xpd);
/*--------- Sysfs Device handling ----*/
@@ -1060,6 +1061,3 @@ void xpp_driver_exit(void)
driver_unregister(&xpp_driver);
bus_unregister(&toplevel_bus_type);
}
EXPORT_SYMBOL(xpd_driver_register);
EXPORT_SYMBOL(xpd_driver_unregister);

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

@@ -19,6 +19,7 @@ void xframe_queue_init(struct xframe_queue *q,
q->name = name;
q->priv = priv;
}
EXPORT_SYMBOL(xframe_queue_init);
void xframe_queue_clearstats(struct xframe_queue *q)
{
@@ -26,6 +27,7 @@ void xframe_queue_clearstats(struct xframe_queue *q)
//q->overflows = 0; /* Never clear overflows */
q->worst_lag_usec = 0L;
}
EXPORT_SYMBOL(xframe_queue_clearstats);
static void __xframe_dump_queue(struct xframe_queue *q)
{
@@ -88,6 +90,7 @@ bool xframe_enqueue(struct xframe_queue *q, xframe_t *xframe)
spin_unlock_irqrestore(&q->lock, flags);
return ret;
}
EXPORT_SYMBOL(xframe_enqueue);
static xframe_t *__xframe_dequeue(struct xframe_queue *q)
{
@@ -124,11 +127,13 @@ xframe_t *xframe_dequeue(struct xframe_queue *q)
spin_unlock_irqrestore(&q->lock, flags);
return frm;
}
EXPORT_SYMBOL(xframe_dequeue);
void xframe_queue_disable(struct xframe_queue *q, bool disabled)
{
q->disabled = disabled;
}
EXPORT_SYMBOL(xframe_queue_disable);
void xframe_queue_clear(struct xframe_queue *q)
{
@@ -144,11 +149,13 @@ void xframe_queue_clear(struct xframe_queue *q)
XBUS_DBG(DEVICES, xbus, "%s: finished queue clear (%d items)\n",
q->name, i);
}
EXPORT_SYMBOL(xframe_queue_clear);
uint xframe_queue_count(struct xframe_queue *q)
{
return q->count;
}
EXPORT_SYMBOL(xframe_queue_count);
/*------------------------- Frame Alloc/Dealloc --------------------*/
@@ -289,6 +296,7 @@ xframe_t *get_xframe(struct xframe_queue *q)
//XBUS_INFO(xbus, "%s\n", __func__);
return xframe;
}
EXPORT_SYMBOL(get_xframe);
void put_xframe(struct xframe_queue *q, xframe_t *xframe)
{
@@ -306,13 +314,4 @@ void put_xframe(struct xframe_queue *q, xframe_t *xframe)
}
xframe_queue_adjust(q);
}
EXPORT_SYMBOL(xframe_queue_init);
EXPORT_SYMBOL(xframe_queue_clearstats);
EXPORT_SYMBOL(xframe_enqueue);
EXPORT_SYMBOL(xframe_dequeue);
EXPORT_SYMBOL(xframe_queue_disable);
EXPORT_SYMBOL(xframe_queue_clear);
EXPORT_SYMBOL(xframe_queue_count);
EXPORT_SYMBOL(get_xframe);
EXPORT_SYMBOL(put_xframe);

39
drivers/dahdi/xpp/xpp_dahdi.c
View File

@@ -57,6 +57,7 @@ struct proc_dir_entry *xpp_proc_toplevel = NULL;
#define DELAY_UNTIL_DIALTONE 3000
DEF_PARM(int, debug, 0, 0644, "Print DBG statements");
EXPORT_SYMBOL(debug);
static DEF_PARM_BOOL(prefmaster, 0, 0644,
"Do we want to be dahdi preferred sync master");
// DEF_ARRAY(int, pcmtx, 4, 0, "Forced PCM values to transmit");
@@ -99,7 +100,6 @@ void xbus_flip_bit(xbus_t *xbus, unsigned int bitnum0, unsigned int bitnum1)
if (num == parport_xbuses[1])
flip_parport_bit(bitnum1);
}
EXPORT_SYMBOL(xbus_flip_bit);
#endif
@@ -142,12 +142,14 @@ xpd_t *get_xpd(const char *msg, xpd_t *xpd)
kref_get(&xpd->kref);
return xpd;
}
EXPORT_SYMBOL(get_xpd);
void put_xpd(const char *msg, xpd_t *xpd)
{
XPD_DBG(DEVICES, xpd, "%s: refcount_xpd=%d\n", msg, refcount_xpd(xpd));
kref_put(&xpd->kref, xpd_destroy);
}
EXPORT_SYMBOL(put_xpd);
static void xpd_proc_remove(xbus_t *xbus, xpd_t *xpd)
{
@@ -217,6 +219,7 @@ void xpd_free(xpd_t *xpd)
*/
put_xbus(__func__, xbus); /* was taken in xpd_alloc() */
}
EXPORT_SYMBOL(xpd_free);
/*
* Synchronous part of XPD detection.
@@ -254,6 +257,7 @@ int create_xpd(xbus_t *xbus, const xproto_table_t *proto_table, int unit,
}
return 0;
}
EXPORT_SYMBOL(create_xpd);
#ifdef CONFIG_PROC_FS
@@ -596,6 +600,7 @@ err:
}
return NULL;
}
EXPORT_SYMBOL(xpd_alloc);
/*
* The xpd isn't open by anyone, we can unregister it and free it
@@ -635,6 +640,7 @@ void update_xpd_status(xpd_t *xpd, int alarm_flag)
span->alarms = alarm_flag;
dahdi_alarm_notify(span);
}
EXPORT_SYMBOL(update_xpd_status);
/*
* Used to block/pass PCM during onhook-transfers. E.g:
@@ -652,6 +658,7 @@ void oht_pcm(xpd_t *xpd, int pos, bool pass)
}
CALL_PHONE_METHOD(card_pcm_recompute, xpd, 0);
}
EXPORT_SYMBOL(oht_pcm);
/*
* Update our hookstate -- for PCM block/pass
@@ -667,6 +674,7 @@ void mark_offhook(xpd_t *xpd, int pos, bool to_offhook)
}
CALL_PHONE_METHOD(card_pcm_recompute, xpd, 0);
}
EXPORT_SYMBOL(mark_offhook);
/*
* Send a signalling notification to Asterisk
@@ -682,6 +690,7 @@ void notify_rxsig(xpd_t *xpd, int pos, enum dahdi_rxsig rxsig)
if (SPAN_REGISTERED(xpd))
dahdi_hooksig(XPD_CHAN(xpd, pos), rxsig);
}
EXPORT_SYMBOL(notify_rxsig);
/*
* Called when hardware state changed:
@@ -706,6 +715,7 @@ void hookstate_changed(xpd_t *xpd, int pos, bool to_offhook)
notify_rxsig(xpd, pos,
(to_offhook) ? DAHDI_RXSIG_OFFHOOK : DAHDI_RXSIG_ONHOOK);
}
EXPORT_SYMBOL(hookstate_changed);
#define XPP_MAX_LEN 512
@@ -750,6 +760,7 @@ int xpp_open(struct dahdi_chan *chan)
CALL_PHONE_METHOD(card_open, xpd, pos);
return 0;
}
EXPORT_SYMBOL(xpp_open);
int xpp_close(struct dahdi_chan *chan)
{
@@ -767,6 +778,7 @@ int xpp_close(struct dahdi_chan *chan)
atomic_dec(&PHONEDEV(xpd).open_counter); /* from xpp_open() */
return 0;
}
EXPORT_SYMBOL(xpp_close);
void report_bad_ioctl(const char *msg, xpd_t *xpd, int pos, unsigned int cmd)
{
@@ -781,6 +793,7 @@ void report_bad_ioctl(const char *msg, xpd_t *xpd, int pos, unsigned int cmd)
XPD_NOTICE(xpd, " IOC_NR=%d\n", _IOC_NR(cmd));
XPD_NOTICE(xpd, " IOC_SIZE=0x%02X\n", _IOC_SIZE(cmd));
}
EXPORT_SYMBOL(report_bad_ioctl);
int xpp_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long arg)
{
@@ -804,6 +817,7 @@ int xpp_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long arg)
}
return 0;
}
EXPORT_SYMBOL(xpp_ioctl);
int xpp_hooksig(struct dahdi_chan *chan, enum dahdi_txsig txsig)
{
@@ -828,7 +842,6 @@ int xpp_hooksig(struct dahdi_chan *chan, enum dahdi_txsig txsig)
txsig);
return CALL_PHONE_METHOD(card_hooksig, xpd, pos, txsig);
}
EXPORT_SYMBOL(xpp_hooksig);
/* Req: Set the requested chunk size. This is the unit in which you must
@@ -871,6 +884,7 @@ int xpp_maint(struct dahdi_span *span, int cmd)
update_xpd_status(xpd, DAHDI_ALARM_LOOPBACK);
return ret;
}
EXPORT_SYMBOL(xpp_maint);
#ifdef CONFIG_DAHDI_WATCHDOG
/*
@@ -951,7 +965,6 @@ const char *xpp_echocan_name(const struct dahdi_chan *chan)
}
return "XPP";
}
EXPORT_SYMBOL(xpp_echocan_name);
int xpp_echocan_create(struct dahdi_chan *chan,
@@ -983,7 +996,6 @@ int xpp_echocan_create(struct dahdi_chan *chan,
CALL_EC_METHOD(ec_update, xbus, xbus);
return ret;
}
EXPORT_SYMBOL(xpp_echocan_create);
void xpp_span_assigned(struct dahdi_span *span)
@@ -997,7 +1009,6 @@ void xpp_span_assigned(struct dahdi_span *span)
dahdi_alarm_notify(&phonedev->span);
}
}
EXPORT_SYMBOL(xpp_span_assigned);
static const struct dahdi_span_ops xpp_span_ops = {
@@ -1038,7 +1049,6 @@ void xpd_set_spanname(xpd_t *xpd)
snprintf(span->desc, MAX_SPANDESC, "Xorcom XPD [%s].%d: %s",
xpd->xbus->label, span->offset + 1, xpd->type_name);
}
EXPORT_SYMBOL(xpd_set_spanname);
static void xpd_init_span(xpd_t *xpd, unsigned offset, int cn)
@@ -1211,23 +1221,6 @@ static void __exit xpp_dahdi_cleanup(void)
do_cleanup();
}
EXPORT_SYMBOL(debug);
EXPORT_SYMBOL(create_xpd);
EXPORT_SYMBOL(get_xpd);
EXPORT_SYMBOL(put_xpd);
EXPORT_SYMBOL(xpd_alloc);
EXPORT_SYMBOL(xpd_free);
EXPORT_SYMBOL(update_xpd_status);
EXPORT_SYMBOL(oht_pcm);
EXPORT_SYMBOL(mark_offhook);
EXPORT_SYMBOL(notify_rxsig);
EXPORT_SYMBOL(hookstate_changed);
EXPORT_SYMBOL(xpp_open);
EXPORT_SYMBOL(xpp_close);
EXPORT_SYMBOL(xpp_ioctl);
EXPORT_SYMBOL(xpp_maint);
EXPORT_SYMBOL(report_bad_ioctl);
MODULE_DESCRIPTION("XPP Dahdi Driver");
MODULE_AUTHOR("Oron Peled <oron@actcom.co.il>");
MODULE_LICENSE("GPL");

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

@@ -43,6 +43,7 @@ bool valid_xpd_addr(const struct xpd_addr *addr)
return ((addr->subunit & ~BITMASK(SUBUNIT_BITS)) == 0)
&& ((addr->unit & ~BITMASK(UNIT_BITS)) == 0);
}
EXPORT_SYMBOL(valid_xpd_addr);
/*------ General Protocol Management ----------------------------*/
@@ -55,6 +56,7 @@ const xproto_entry_t *xproto_card_entry(const xproto_table_t *table,
xe = &table->entries[opcode];
return (xe->handler != NULL) ? xe : NULL;
}
EXPORT_SYMBOL(xproto_card_entry);
const xproto_entry_t *xproto_global_entry(__u8 opcode)
{
@@ -64,6 +66,7 @@ const xproto_entry_t *xproto_global_entry(__u8 opcode)
//DBG(GENERAL, "opcode=0x%X xe=%p\n", opcode, xe);
return xe;
}
EXPORT_SYMBOL(xproto_global_entry);
xproto_handler_t xproto_global_handler(__u8 opcode)
{
@@ -136,6 +139,7 @@ void notify_bad_xpd(const char *funcname, xbus_t *xbus,
XBUS_NOTICE(xbus, "%s: non-existing address (%1d%1d): %s\n", funcname,
addr.unit, addr.subunit, msg);
}
EXPORT_SYMBOL(notify_bad_xpd);
static int packet_process(xbus_t *xbus, xpacket_t *pack)
{
@@ -312,6 +316,7 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe)
xbus->max_rx_process = usec;
return ret;
}
EXPORT_SYMBOL(xframe_receive);
#define VERBOSE_DEBUG 1
#define ERR_REPORT_LIMIT 20
@@ -357,6 +362,7 @@ void dump_packet(const char *msg, const xpacket_t *packet, bool debug)
#endif
printk("\n");
}
EXPORT_SYMBOL(dump_packet);
void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus,
__u8 unit, xportno_t port, const reg_cmd_t *regcmd)
@@ -425,6 +431,7 @@ void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus,
PORT_DBG(REGS, xbus, unit, port, "%s: %s %c%c %s %s\n", msg, port_buf,
action, modifier, reg_buf, data_buf);
}
EXPORT_SYMBOL(dump_reg_cmd);
const char *xproto_name(xpd_type_t xpd_type)
{
@@ -436,6 +443,7 @@ const char *xproto_name(xpd_type_t xpd_type)
return NULL;
return proto_table->name;
}
EXPORT_SYMBOL(xproto_name);
#define CHECK_XOP(xops, f) \
if (!(xops)->f) { \
@@ -492,6 +500,7 @@ int xproto_register(const xproto_table_t *proto_table)
xprotocol_tables[type] = proto_table;
return 0;
}
EXPORT_SYMBOL(xproto_register);
void xproto_unregister(const xproto_table_t *proto_table)
{
@@ -511,14 +520,4 @@ void xproto_unregister(const xproto_table_t *proto_table)
__func__, name, type);
xprotocol_tables[type] = NULL;
}
EXPORT_SYMBOL(dump_packet);
EXPORT_SYMBOL(dump_reg_cmd);
EXPORT_SYMBOL(xframe_receive);
EXPORT_SYMBOL(notify_bad_xpd);
EXPORT_SYMBOL(valid_xpd_addr);
EXPORT_SYMBOL(xproto_global_entry);
EXPORT_SYMBOL(xproto_card_entry);
EXPORT_SYMBOL(xproto_name);
EXPORT_SYMBOL(xproto_register);
EXPORT_SYMBOL(xproto_unregister);