From bcd3691c8a54de660d996ff36fa9ad098aa651c9 Mon Sep 17 00:00:00 2001
From: Werner Almesberger <werner@openmoko.org>
Date: Thu, 11 Nov 2010 10:10:13 -0300
Subject: [PATCH] The Great ATSPI Renaming, part 6: change atrf API from
 atspi_* to atrf_*

- include/atrf.h, lib/atrf.c (struct atspi_dsc): renamed to "struct
  atrf_dsc"
- include/atrf.h, lib/atrf.c (atspi_*): renamed all functions to atrf_*
- include/misctxrx.h, lib/misctxrx.c (wait_for_interrupt): updated for API
  name change
- atspi-id/atspi-id.c (show_usb_info, show_info, main),
  atspi-reset/atspi-reset.c (main), atspi-rssi/atspi-rssi.c (sweep, main),
  atspi-rssi/gui.h (gui), atspi-rssi/gui.c (sweep, gui),
  atspi-trim/atspi-trim.c (main), atspi-txrx/atspi-txrx.c (init_txrx,
  set_channel, set_power, receive, transmit, test_mode, main):
  updated for API name change
---
 tools/atspi-id/atspi-id.c       | 22 +++++------
 tools/atspi-reset/atspi-reset.c |  8 ++--
 tools/atspi-rssi/atspi-rssi.c   | 18 ++++-----
 tools/atspi-rssi/gui.c          |  8 ++--
 tools/atspi-rssi/gui.h          |  2 +-
 tools/atspi-trim/atspi-trim.c   |  8 ++--
 tools/atspi-txrx/atspi-txrx.c   | 66 ++++++++++++++++-----------------
 tools/include/atrf.h            | 28 +++++++-------
 tools/include/misctxrx.h        |  2 +-
 tools/lib/atrf.c                | 32 ++++++++--------
 tools/lib/misctxrx.c            |  8 ++--
 11 files changed, 101 insertions(+), 101 deletions(-)

diff --git a/tools/atspi-id/atspi-id.c b/tools/atspi-id/atspi-id.c
index 0ef1f30..f283454 100644
--- a/tools/atspi-id/atspi-id.c
+++ b/tools/atspi-id/atspi-id.c
@@ -71,7 +71,7 @@ static int get_build(usb_dev_handle *dev, char *buf, size_t size)
 }
 
 
-static void show_usb_info(struct atspi_dsc *dsc)
+static void show_usb_info(struct atrf_dsc *dsc)
 {
 	usb_dev_handle *dev;
 	const struct usb_device *device;
@@ -79,7 +79,7 @@ static void show_usb_info(struct atspi_dsc *dsc)
 	char buf[BUF_SIZE+1];	/* +1 for terminating \0 */
 	int len;
 
-	dev = atspi_usb_handle(dsc);
+	dev = atrf_usb_handle(dsc);
 	if (!dev)
 		return;
 	device = usb_device(dev);
@@ -102,7 +102,7 @@ static void show_usb_info(struct atspi_dsc *dsc)
 #else /* HAVE_USB */
 
 
-static void show_usb_info(struct atspi_dsc *dsc)
+static void show_usb_info(struct atrf_dsc *dsc)
 {
 }
 
@@ -110,16 +110,16 @@ static void show_usb_info(struct atspi_dsc *dsc)
 #endif /* !HAVE_USB */
 
 
-static void show_info(struct atspi_dsc *dsc)
+static void show_info(struct atrf_dsc *dsc)
 {
 	uint8_t part, version, man_id_0, man_id_1;
 
 	show_usb_info(dsc);
 
-	part = atspi_reg_read(dsc, REG_PART_NUM);
-	version = atspi_reg_read(dsc, REG_VERSION_NUM);
-	man_id_0 = atspi_reg_read(dsc, REG_MAN_ID_0);
-	man_id_1 = atspi_reg_read(dsc, REG_MAN_ID_1);
+	part = atrf_reg_read(dsc, REG_PART_NUM);
+	version = atrf_reg_read(dsc, REG_VERSION_NUM);
+	man_id_0 = atrf_reg_read(dsc, REG_MAN_ID_0);
+	man_id_1 = atrf_reg_read(dsc, REG_MAN_ID_1);
 	printf("%10spart 0x%02x version %u manufacturer xxxx%02x%02x\n", "",
 	    part, version, man_id_1, man_id_0);
 }
@@ -134,17 +134,17 @@ static void usage(const char *name)
 
 int main(int argc, const char **argv)
 {
-	struct atspi_dsc *dsc;
+	struct atrf_dsc *dsc;
 
 	if (argc != 1)
 		usage(*argv);
-	dsc = atspi_open();
+	dsc = atrf_open();
 	if (!dsc)
 		return 1;
 
 	show_info(dsc);
 
-	atspi_close(dsc);
+	atrf_close(dsc);
 
 	return 0;
 }
diff --git a/tools/atspi-reset/atspi-reset.c b/tools/atspi-reset/atspi-reset.c
index 40032cd..84873c1 100644
--- a/tools/atspi-reset/atspi-reset.c
+++ b/tools/atspi-reset/atspi-reset.c
@@ -31,7 +31,7 @@ static void usage(const char *name)
 
 int main(int argc, const char **argv)
 {
-	struct atspi_dsc *dsc;
+	struct atrf_dsc *dsc;
 	int txrx = 1;
 
 	switch (argc) {
@@ -48,14 +48,14 @@ int main(int argc, const char **argv)
 		usage(*argv);
 	}
 
-	dsc = atspi_open();
+	dsc = atrf_open();
 	if (!dsc)
 		return 1;
 
         if (txrx)
-                atspi_reset_rf(dsc);
+                atrf_reset_rf(dsc);
         else
-                atspi_reset(dsc);
+                atrf_reset(dsc);
         return 0;
 }
 
diff --git a/tools/atspi-rssi/atspi-rssi.c b/tools/atspi-rssi/atspi-rssi.c
index 034b42e..79eb282 100644
--- a/tools/atspi-rssi/atspi-rssi.c
+++ b/tools/atspi-rssi/atspi-rssi.c
@@ -32,18 +32,18 @@ static struct timeval t0;
 static volatile int run = 1;
 
 
-static void sweep(struct atspi_dsc *dsc)
+static void sweep(struct atrf_dsc *dsc)
 {
 	int chan, rssi;
 	struct timeval t;
 
 	for (chan = 11; chan <= 26; chan++) {
-		atspi_reg_write(dsc, REG_PHY_CC_CCA, chan);
+		atrf_reg_write(dsc, REG_PHY_CC_CCA, chan);
 		/* 150 us, according to AVR2001 section 3.5 */
 		wait_for_interrupt(dsc, IRQ_PLL_LOCK, IRQ_PLL_LOCK, 10, 20);
 
 		gettimeofday(&t, NULL);
-		rssi = atspi_reg_read(dsc, REG_PHY_RSSI) & RSSI_MASK;
+		rssi = atrf_reg_read(dsc, REG_PHY_RSSI) & RSSI_MASK;
 		t.tv_sec -= t0.tv_sec;
 		t.tv_usec -= t0.tv_usec;
 		printf("%d %f %d\n",
@@ -77,7 +77,7 @@ static void usage(const char *name)
 
 int main(int argc, char **argv)
 {
-	struct atspi_dsc *dsc;
+	struct atrf_dsc *dsc;
 	unsigned long arg = 0, i;
 	char *end;
 	int c;
@@ -115,12 +115,12 @@ int main(int argc, char **argv)
 
 	signal(SIGINT, die);
 
-	dsc = atspi_open();
+	dsc = atrf_open();
 	if (!dsc)
 		return 1;
 
-	atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TRX_OFF);
-	atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_RX_ON);
+	atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TRX_OFF);
+	atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_RX_ON);
 	/*
 	 * We'll wait for the PLL lock after selecting the channel.
 	 */
@@ -133,9 +133,9 @@ int main(int argc, char **argv)
 			sweep(dsc);
 	}
 
-	atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TRX_OFF);
+	atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TRX_OFF);
 
-	atspi_close(dsc);
+	atrf_close(dsc);
 
 	return 0;
 }
diff --git a/tools/atspi-rssi/gui.c b/tools/atspi-rssi/gui.c
index 5803503..7039c14 100644
--- a/tools/atspi-rssi/gui.c
+++ b/tools/atspi-rssi/gui.c
@@ -67,16 +67,16 @@ static void shift_grid(int *z, int nx, int ny)
 }
 
 
-static void sweep(struct atspi_dsc *dsc, int *z)
+static void sweep(struct atrf_dsc *dsc, int *z)
 {
 	int chan;
 
 	for (chan = 11; chan <= 26; chan++) {
-		atspi_reg_write(dsc, REG_PHY_CC_CCA, chan);
+		atrf_reg_write(dsc, REG_PHY_CC_CCA, chan);
 		/* 150 us, according to AVR2001 section 3.5 */
 		wait_for_interrupt(dsc, IRQ_PLL_LOCK, IRQ_PLL_LOCK, 10, 20);
 
-		*z++ = Z_STEP*atspi_reg_read(dsc, REG_PHY_RSSI) & RSSI_MASK;
+		*z++ = Z_STEP*atrf_reg_read(dsc, REG_PHY_RSSI) & RSSI_MASK;
 #if 0
 		if (chan >= 13 && chan <= 19 )
 			z[-1] = 3*28-(chan-16)*(chan-16)*(chan-16)*(chan-16);
@@ -121,7 +121,7 @@ static void label_channels(SDL_Surface *s, int sx, int x0, int y0)
 }
 
 
-void gui(struct atspi_dsc *dsc)
+void gui(struct atrf_dsc *dsc)
 {
 	SDL_Surface *surf;
 	int z[N_CHAN*N_TIME];
diff --git a/tools/atspi-rssi/gui.h b/tools/atspi-rssi/gui.h
index 69ce037..b089c4d 100644
--- a/tools/atspi-rssi/gui.h
+++ b/tools/atspi-rssi/gui.h
@@ -16,6 +16,6 @@
 #include "atrf.h"
 
 
-void gui(struct atspi_dsc *dsc);
+void gui(struct atrf_dsc *dsc);
 
 #endif /* !GUI_H */
diff --git a/tools/atspi-trim/atspi-trim.c b/tools/atspi-trim/atspi-trim.c
index 691ecb0..a5ab2c7 100644
--- a/tools/atspi-trim/atspi-trim.c
+++ b/tools/atspi-trim/atspi-trim.c
@@ -28,7 +28,7 @@ static void usage(const char *name)
 
 int main(int argc, const char **argv)
 {
-	struct atspi_dsc *dsc;
+	struct atrf_dsc *dsc;
 	int trim = -1;
 	char *end;
 
@@ -44,15 +44,15 @@ int main(int argc, const char **argv)
 		usage(*argv);
 	}
 
-	dsc = atspi_open();
+	dsc = atrf_open();
 	if (!dsc)
 		return 1;
 
 	if (trim == -1) {
-		trim = atspi_reg_read(dsc, REG_XOSC_CTRL) & XTAL_TRIM_MASK;
+		trim = atrf_reg_read(dsc, REG_XOSC_CTRL) & XTAL_TRIM_MASK;
 		printf("%d (%d.%d pF)\n", trim, trim*3/10, trim*3 % 10);
 	} else {
-		atspi_reg_write(dsc, REG_XOSC_CTRL,
+		atrf_reg_write(dsc, REG_XOSC_CTRL,
 		    (XTAL_MODE_INT << XTAL_MODE_SHIFT) | trim);
 	}
 
diff --git a/tools/atspi-txrx/atspi-txrx.c b/tools/atspi-txrx/atspi-txrx.c
index 9233d9b..7be6f08 100644
--- a/tools/atspi-txrx/atspi-txrx.c
+++ b/tools/atspi-txrx/atspi-txrx.c
@@ -51,37 +51,37 @@ static double tx_pwr[] = {
 static volatile int run = 1;
 
 
-static struct atspi_dsc *init_txrx(int trim)
+static struct atrf_dsc *init_txrx(int trim)
 {
-	struct atspi_dsc *dsc;
+	struct atrf_dsc *dsc;
 
-	dsc = atspi_open();
+	dsc = atrf_open();
 	if (!dsc)
 		exit(1);
 	
-	atspi_reset_rf(dsc);
-	atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TRX_OFF);
+	atrf_reset_rf(dsc);
+	atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TRX_OFF);
 #ifdef HAVE_USB /* @@@ yeah, ugly */
-	atspi_reg_write(dsc, REG_XOSC_CTRL,
+	atrf_reg_write(dsc, REG_XOSC_CTRL,
 	    (XTAL_MODE_INT << XTAL_MODE_SHIFT) | trim);
 #else
-	atspi_reg_write(dsc, REG_XOSC_CTRL, XTAL_MODE_EXT << XTAL_MODE_SHIFT);
+	atrf_reg_write(dsc, REG_XOSC_CTRL, XTAL_MODE_EXT << XTAL_MODE_SHIFT);
 #endif
-	atspi_reg_write(dsc, REG_TRX_CTRL_0, 0); /* disable CLKM */
+	atrf_reg_write(dsc, REG_TRX_CTRL_0, 0); /* disable CLKM */
 
-	(void) atspi_reg_read(dsc, REG_IRQ_STATUS);
+	(void) atrf_reg_read(dsc, REG_IRQ_STATUS);
 
 	return dsc;
 }
 
 
-static void set_channel(struct atspi_dsc *dsc, int channel)
+static void set_channel(struct atrf_dsc *dsc, int channel)
 {
-	atspi_reg_write(dsc, REG_PHY_CC_CCA, (1 << CCA_MODE_SHIFT) | channel);
+	atrf_reg_write(dsc, REG_PHY_CC_CCA, (1 << CCA_MODE_SHIFT) | channel);
 }
 
 
-static void set_power(struct atspi_dsc *dsc, double power, int crc)
+static void set_power(struct atrf_dsc *dsc, double power, int crc)
 {
 	int n;
 
@@ -90,17 +90,17 @@ static void set_power(struct atspi_dsc *dsc, double power, int crc)
 			break;
 	if (fabs(tx_pwr[n]-power) > 0.01)
 		fprintf(stderr, "TX power %.1f dBm\n", tx_pwr[n]);
-	atspi_reg_write(dsc, REG_PHY_TX_PWR, (crc ? TX_AUTO_CRC_ON : 0) | n);
+	atrf_reg_write(dsc, REG_PHY_TX_PWR, (crc ? TX_AUTO_CRC_ON : 0) | n);
 }
 
 
-static void receive(struct atspi_dsc *dsc)
+static void receive(struct atrf_dsc *dsc)
 {
 	uint8_t buf[MAX_PSDU+1]; /* PSDU+LQI */
 	int n, ok, i;
 	uint8_t ed, lqi;
 
-	atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_RX_ON);
+	atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_RX_ON);
 	/*
 	 * 180 us, according to AVR2001 section 4.2. We time out after
 	 * nominally 200 us.
@@ -113,15 +113,15 @@ static void receive(struct atspi_dsc *dsc)
 	if (!run)
 		return;
 
-	n = atspi_buf_read(dsc, buf, sizeof(buf));
+	n = atrf_buf_read(dsc, buf, sizeof(buf));
 	if (n < 0)
 		exit(1);
 	if (n < 3) {
 		fprintf(stderr, "%d bytes received\n", n);
 		exit(1);
 	}
-	ed = atspi_reg_read(dsc, REG_PHY_ED_LEVEL);
-	ok = !!(atspi_reg_read(dsc, REG_PHY_RSSI) & RX_CRC_VALID);
+	ed = atrf_reg_read(dsc, REG_PHY_ED_LEVEL);
+	ok = !!(atrf_reg_read(dsc, REG_PHY_RSSI) & RX_CRC_VALID);
 	lqi = buf[n-1];
 	fprintf(stderr, "%d bytes payload, CRC %s, LQI %u, ED %d dBm\n",
 	    n-3, ok ? "OK" : "BAD", lqi, -91+ed);
@@ -131,11 +131,11 @@ static void receive(struct atspi_dsc *dsc)
 }
 
 
-static void transmit(struct atspi_dsc *dsc, const char *msg, int times)
+static void transmit(struct atrf_dsc *dsc, const char *msg, int times)
 {
 	uint8_t buf[MAX_PSDU];
 
-	atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_PLL_ON);
+	atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_PLL_ON);
 	/*
 	 * 180 us, according to AVR2001 section 4.3. We time out after
 	 * nominally 200 us.
@@ -146,11 +146,11 @@ static void transmit(struct atspi_dsc *dsc, const char *msg, int times)
 	 * We need to copy the message to append the CRC placeholders.
 	 */
 	strcpy((void *) buf, msg);
-	atspi_buf_write(dsc, buf, strlen(msg)+2);
+	atrf_buf_write(dsc, buf, strlen(msg)+2);
 
 	while (run && times--) {
 		/* @@@ should wait for clear channel */
-		atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TX_START);
+		atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TX_START);
 
 		/* wait up to 10 ms (nominally) */
 		wait_for_interrupt(dsc, IRQ_TRX_END,
@@ -159,26 +159,26 @@ static void transmit(struct atspi_dsc *dsc, const char *msg, int times)
 }
 
 
-static void test_mode(struct atspi_dsc *dsc, uint8_t cont_tx)
+static void test_mode(struct atrf_dsc *dsc, uint8_t cont_tx)
 {
-	atspi_buf_write(dsc, "", 1);
-	atspi_reg_write(dsc, REG_CONT_TX_0, CONT_TX_MAGIC);
-	atspi_reg_write(dsc, REG_CONT_TX_1, cont_tx);
+	atrf_buf_write(dsc, "", 1);
+	atrf_reg_write(dsc, REG_CONT_TX_0, CONT_TX_MAGIC);
+	atrf_reg_write(dsc, REG_CONT_TX_1, cont_tx);
 
-	if (!atspi_test_mode(dsc)) {
-		atspi_reset_rf(dsc);
+	if (!atrf_test_mode(dsc)) {
+		atrf_reset_rf(dsc);
 		fprintf(stderr, "device does not support test mode\n");
 		exit(1);
 	}
 
-	atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_PLL_ON);
+	atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_PLL_ON);
 	wait_for_interrupt(dsc, IRQ_PLL_LOCK, IRQ_PLL_LOCK, 10, 20);
 
-	atspi_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TX_START);
+	atrf_reg_write(dsc, REG_TRX_STATE, TRX_CMD_TX_START);
 
 	while (run)
 		sleep(1);
-	atspi_reset_rf(dsc);
+	atrf_reset_rf(dsc);
 }
 
 
@@ -214,7 +214,7 @@ int main(int argc, char *const *argv)
 	uint8_t cont_tx = 0;
 	char *end;
 	int c, freq;
-	struct atspi_dsc *dsc;
+	struct atrf_dsc *dsc;
 
 	while ((c = getopt(argc, argv, "c:f:p:t:T:")) != EOF)
 		switch (c) {
@@ -291,7 +291,7 @@ int main(int argc, char *const *argv)
 		usage(*argv);
 	}
 
-	atspi_close(dsc);
+	atrf_close(dsc);
 
 	return 0;
 }
diff --git a/tools/include/atrf.h b/tools/include/atrf.h
index aa436ae..430e7a1 100644
--- a/tools/include/atrf.h
+++ b/tools/include/atrf.h
@@ -16,27 +16,27 @@
 #include <stdint.h>
 
 
-struct atspi_dsc;
+struct atrf_dsc;
 
 
-void *atspi_usb_handle(struct atspi_dsc *dsc); /* hack for atspi-id */
+void *atrf_usb_handle(struct atrf_dsc *dsc); /* hack for atspi-id */
 
-struct atspi_dsc *atspi_open(void);
-void atspi_close(struct atspi_dsc *dsc);
+struct atrf_dsc *atrf_open(void);
+void atrf_close(struct atrf_dsc *dsc);
 
-int atspi_error(struct atspi_dsc *dsc);
-int atspi_clear_error(struct atspi_dsc *dsc);
+int atrf_error(struct atrf_dsc *dsc);
+int atrf_clear_error(struct atrf_dsc *dsc);
 
-void atspi_reset(struct atspi_dsc *dsc);
-void atspi_reset_rf(struct atspi_dsc *dsc);
-int atspi_test_mode(struct atspi_dsc *dsc);
+void atrf_reset(struct atrf_dsc *dsc);
+void atrf_reset_rf(struct atrf_dsc *dsc);
+int atrf_test_mode(struct atrf_dsc *dsc);
 
-void atspi_reg_write(struct atspi_dsc *dsc, uint8_t reg, uint8_t value);
-uint8_t atspi_reg_read(struct atspi_dsc *dsc, uint8_t reg);
+void atrf_reg_write(struct atrf_dsc *dsc, uint8_t reg, uint8_t value);
+uint8_t atrf_reg_read(struct atrf_dsc *dsc, uint8_t reg);
 
-void atspi_buf_write(struct atspi_dsc *dsc, const void *buf, int size);
-int atspi_buf_read(struct atspi_dsc *dsc, void *buf, int size);
+void atrf_buf_write(struct atrf_dsc *dsc, const void *buf, int size);
+int atrf_buf_read(struct atrf_dsc *dsc, void *buf, int size);
 
-int atspi_interrupt(struct atspi_dsc *dsc);
+int atrf_interrupt(struct atrf_dsc *dsc);
 
 #endif /* !ATRF_H */
diff --git a/tools/include/misctxrx.h b/tools/include/misctxrx.h
index 7961abf..0bf4305 100644
--- a/tools/include/misctxrx.h
+++ b/tools/include/misctxrx.h
@@ -18,7 +18,7 @@
 #include "atrf.h"
 
 
-uint8_t wait_for_interrupt(struct atspi_dsc *dsc, uint8_t wait_for,
+uint8_t wait_for_interrupt(struct atrf_dsc *dsc, uint8_t wait_for,
     uint8_t ignore, int sleep_us, int timeout);
 
 #endif /* !MISCTXRX_H */
diff --git a/tools/lib/atrf.c b/tools/lib/atrf.c
index c5df4c7..42d84ac 100644
--- a/tools/lib/atrf.c
+++ b/tools/lib/atrf.c
@@ -1,5 +1,5 @@
 /*
- * lib/atspi.c - ATSPI access functions library
+ * lib/atrf.c - ATSPI access functions library
  *
  * Written 2010 by Werner Almesberger
  * Copyright 2010 Werner Almesberger
@@ -22,13 +22,13 @@ extern struct atrf_driver atusb_driver;
 extern struct atrf_driver atusd_driver;
 
 
-struct atspi_dsc {
+struct atrf_dsc {
 	struct atrf_driver *driver;
 	void *handle;
 };
 
 
-void *atspi_usb_handle(struct atspi_dsc *dsc)
+void *atrf_usb_handle(struct atrf_dsc *dsc)
 {
 #ifdef HAVE_USB
 	return dsc->handle;
@@ -38,22 +38,22 @@ void *atspi_usb_handle(struct atspi_dsc *dsc)
 }
 
 
-int atspi_error(struct atspi_dsc *dsc)
+int atrf_error(struct atrf_dsc *dsc)
 {
 	return dsc->driver->error ? dsc->driver->error(dsc->handle) : 0;
 }
 
 
-int atspi_clear_error(struct atspi_dsc *dsc)
+int atrf_clear_error(struct atrf_dsc *dsc)
 {
 	return dsc->driver->clear_error ?
 	    dsc->driver->clear_error(dsc->handle) : 0;
 }
 
 
-struct atspi_dsc *atspi_open(void)
+struct atrf_dsc *atrf_open(void)
 {
-	struct atspi_dsc *dsc;
+	struct atrf_dsc *dsc;
 	struct atrf_driver *driver;
 	void *handle;
 
@@ -78,7 +78,7 @@ struct atspi_dsc *atspi_open(void)
 }
 
 
-void atspi_close(struct atspi_dsc *dsc)
+void atrf_close(struct atrf_dsc *dsc)
 {
 	if (dsc->driver->close)
 		dsc->driver->close(dsc->handle);
@@ -86,20 +86,20 @@ void atspi_close(struct atspi_dsc *dsc)
 }
 
 
-void atspi_reset(struct atspi_dsc *dsc)
+void atrf_reset(struct atrf_dsc *dsc)
 {
 	if (dsc->driver->reset)
 		dsc->driver->reset(dsc->handle);
 }
 
 
-void atspi_reset_rf(struct atspi_dsc *dsc)
+void atrf_reset_rf(struct atrf_dsc *dsc)
 {
 	dsc->driver->reset_rf(dsc->handle);
 }
 
 
-int atspi_test_mode(struct atspi_dsc *dsc)
+int atrf_test_mode(struct atrf_dsc *dsc)
 {
 	if (!dsc->driver->test_mode)
 		return 0;
@@ -108,31 +108,31 @@ int atspi_test_mode(struct atspi_dsc *dsc)
 }
 
 
-void atspi_reg_write(struct atspi_dsc *dsc, uint8_t reg, uint8_t value)
+void atrf_reg_write(struct atrf_dsc *dsc, uint8_t reg, uint8_t value)
 {
 	dsc->driver->reg_write(dsc->handle, reg, value);
 }
 
 
-uint8_t atspi_reg_read(struct atspi_dsc *dsc, uint8_t reg)
+uint8_t atrf_reg_read(struct atrf_dsc *dsc, uint8_t reg)
 {
 	return dsc->driver->reg_read(dsc->handle, reg);
 }
 
 
-void atspi_buf_write(struct atspi_dsc *dsc, const void *buf, int size)
+void atrf_buf_write(struct atrf_dsc *dsc, const void *buf, int size)
 {
 	dsc->driver->buf_write(dsc->handle, buf, size);
 }
 
 
-int atspi_buf_read(struct atspi_dsc *dsc, void *buf, int size)
+int atrf_buf_read(struct atrf_dsc *dsc, void *buf, int size)
 {
 	return dsc->driver->buf_read(dsc->handle, buf, size);
 }
 
 
-int atspi_interrupt(struct atspi_dsc *dsc)
+int atrf_interrupt(struct atrf_dsc *dsc)
 {
 	return
 	    dsc->driver->interrupt ? dsc->driver->interrupt(dsc->handle) : 1;
diff --git a/tools/lib/misctxrx.c b/tools/lib/misctxrx.c
index 66a5223..14afa08 100644
--- a/tools/lib/misctxrx.c
+++ b/tools/lib/misctxrx.c
@@ -31,7 +31,7 @@ static void die(int sig)
 }
 
 
-uint8_t wait_for_interrupt(struct atspi_dsc *dsc, uint8_t wait_for,
+uint8_t wait_for_interrupt(struct atrf_dsc *dsc, uint8_t wait_for,
     uint8_t ignore, int sleep_us, int timeout)
 {
 	uint8_t irq = 0, show;
@@ -40,13 +40,13 @@ uint8_t wait_for_interrupt(struct atspi_dsc *dsc, uint8_t wait_for,
 	run = 1;
 	old_sig = signal(SIGINT, die);
 	while (run) {
-		while (run && !atspi_interrupt(dsc)) {
+		while (run && !atrf_interrupt(dsc)) {
 			usleep(sleep_us);
 			if (timeout && !--timeout)
 				return 0;
 		}
-		irq = atspi_reg_read(dsc, REG_IRQ_STATUS);
-		if (atspi_error(dsc))
+		irq = atrf_reg_read(dsc, REG_IRQ_STATUS);
+		if (atrf_error(dsc))
 			exit(1);
 		if (!irq)
 			continue;