xpp: style - place EXPORT_SYMBOL() (manually)

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

10 files changed, 73 insertions, 98 deletions

diff --git a/drivers/dahdi/xpp/card_global.c b/drivers/dahdi/xpp/card_global.c
index aa90f8f..7965d68 100644
--- a/drivers/dahdi/xpp/card_global.c
+++ b/drivers/dahdi/xpp/card_global.c
@@ -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);
diff --git a/drivers/dahdi/xpp/dahdi_debug.c b/drivers/dahdi/xpp/dahdi_debug.c
index 1f0775a..1fe4e65 100644
--- a/drivers/dahdi/xpp/dahdi_debug.c
+++ b/drivers/dahdi/xpp/dahdi_debug.c
@@ -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);
diff --git a/drivers/dahdi/xpp/mmapbus.c b/drivers/dahdi/xpp/mmapbus.c
index 72f4a39..ddf083f 100644
--- a/drivers/dahdi/xpp/mmapbus.c
+++ b/drivers/dahdi/xpp/mmapbus.c
@@ -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>");
diff --git a/drivers/dahdi/xpp/parport_debug.c b/drivers/dahdi/xpp/parport_debug.c
index 40eb148..bfb8ef3 100644
--- a/drivers/dahdi/xpp/parport_debug.c
+++ b/drivers/dahdi/xpp/parport_debug.c
@@ -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)
diff --git a/drivers/dahdi/xpp/xbus-core.c b/drivers/dahdi/xpp/xbus-core.c
index 7115bac..28538e3 100644
--- a/drivers/dahdi/xpp/xbus-core.c
+++ b/drivers/dahdi/xpp/xbus-core.c
@@ -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);
diff --git a/drivers/dahdi/xpp/xbus-pcm.c b/drivers/dahdi/xpp/xbus-pcm.c
index 65abdb8..15ea9d2 100644
--- a/drivers/dahdi/xpp/xbus-pcm.c
+++ b/drivers/dahdi/xpp/xbus-pcm.c
@@ -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
diff --git a/drivers/dahdi/xpp/xbus-sysfs.c b/drivers/dahdi/xpp/xbus-sysfs.c
index b89a2a8..51c633c 100644
--- a/drivers/dahdi/xpp/xbus-sysfs.c
+++ b/drivers/dahdi/xpp/xbus-sysfs.c
@@ -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);
diff --git a/drivers/dahdi/xpp/xframe_queue.c b/drivers/dahdi/xpp/xframe_queue.c
index 3967671..5ef5a9d 100644
--- a/drivers/dahdi/xpp/xframe_queue.c
+++ b/drivers/dahdi/xpp/xframe_queue.c
@@ -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);
diff --git a/drivers/dahdi/xpp/xpp_dahdi.c b/drivers/dahdi/xpp/xpp_dahdi.c
index 3e8e8a9..ae3ea45 100644
--- a/drivers/dahdi/xpp/xpp_dahdi.c
+++ b/drivers/dahdi/xpp/xpp_dahdi.c
@@ -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");
diff --git a/drivers/dahdi/xpp/xproto.c b/drivers/dahdi/xpp/xproto.c
index 87ac043..7d0c506 100644
--- a/drivers/dahdi/xpp/xproto.c
+++ b/drivers/dahdi/xpp/xproto.c
@@ -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);