From c1cb77c64311aa04ba06f2aefa9d71f5459ffc42 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phane=20Fillod=2C=20F8CFE?=
 <fillods@users.sourceforge.net>
Date: Mon, 4 Jun 2001 21:17:53 +0000
Subject: [PATCH] new automatic backend loading and sparse rig_model scheme

git-svn-id: https://hamlib.svn.sourceforge.net/svnroot/hamlib/trunk@529 7ae35d74-ebe9-4afe-98af-79ac388436b8
---
 include/hamlib/riglist.h | 374 +++++++++++++++++++++++----------------
 src/register.c           | 184 ++++++++++++++++---
 src/rig.c                |  47 ++---
 tests/dumpcaps.c         |  13 +-
 tests/dumpmem.c          |   4 +-
 tests/listrigs.c         |  20 ++-
 tests/rigctl.c           |   4 +-
 tests/rigmatrix.c        |  10 +-
 tests/testcaps.c         |   4 +-
 tests/testrig.c          |   2 +
 tests/testtrn.c          |  16 +-
 11 files changed, 450 insertions(+), 228 deletions(-)

diff --git a/include/hamlib/riglist.h b/include/hamlib/riglist.h
index 697de5c2d..edaaadeb8 100644
--- a/include/hamlib/riglist.h
+++ b/include/hamlib/riglist.h
@@ -4,7 +4,7 @@
  * This include defines the list of known rigs.
  *
  *
- * 	$Id: riglist.h,v 1.12 2001-06-02 17:48:46 f4cfe Exp $	 *
+ * 	$Id: riglist.h,v 1.13 2001-06-04 21:17:52 f4cfe Exp $	 *
  *
  *
  * This program is free software; you can redistribute it and/or
@@ -26,227 +26,301 @@
 #ifndef _RIGLIST_H
 #define _RIGLIST_H 1
 
+#define RIG_MAKE_MODEL(a,b) ((a)*100+(b))
+#define RIG_BACKEND_NUM(a) ((a)/100)
 
-enum rig_model_e {
-	RIG_MODEL_DUMMY = 0,
+#define RIG_MODEL_NONE 0
+
+#define RIG_DUMMY 0
+#define RIG_BACKEND_DUMMY "dummy"
+#define RIG_MODEL_DUMMY RIG_MAKE_MODEL(RIG_DUMMY, 1)
 
 	/*
 	 * Yaesu 
 	 */
-	RIG_MODEL_FT847,
-	RIG_MODEL_FT1000,
-	RIG_MODEL_FT1000D,
-	RIG_MODEL_FT1000MP,
-	RIG_MODEL_FT747,
-	RIG_MODEL_FT757,
-	RIG_MODEL_FT757GXII,
-	RIG_MODEL_FT575,
-	RIG_MODEL_FT767,
-	RIG_MODEL_FT736R,
-	RIG_MODEL_FT840,
-	RIG_MODEL_FT820,
-	RIG_MODEL_FT900,
-	RIG_MODEL_FT920,
-	RIG_MODEL_FT890,
-	RIG_MODEL_FT990,
-	RIG_MODEL_FRG100,	/* same as FT890/990 ? */
-	RIG_MODEL_FRG9600,
-	RIG_MODEL_FRG8800,
+#define RIG_YAESU 1
+#define RIG_BACKEND_YAESU "yaesu"
+#define RIG_MODEL_FT847 RIG_MAKE_MODEL(RIG_YAESU, 1)
+#define RIG_MODEL_FT1000 RIG_MAKE_MODEL(RIG_YAESU, 2)
+#define RIG_MODEL_FT1000D RIG_MAKE_MODEL(RIG_YAESU, 3)
+#define RIG_MODEL_FT1000MP RIG_MAKE_MODEL(RIG_YAESU, 4)
+#define RIG_MODEL_FT747 RIG_MAKE_MODEL(RIG_YAESU, 5)
+#define RIG_MODEL_FT757 RIG_MAKE_MODEL(RIG_YAESU, 6)
+#define RIG_MODEL_FT757GXII RIG_MAKE_MODEL(RIG_YAESU, 7)
+#define RIG_MODEL_FT575 RIG_MAKE_MODEL(RIG_YAESU, 8)
+#define RIG_MODEL_FT767 RIG_MAKE_MODEL(RIG_YAESU, 9)
+#define RIG_MODEL_FT736R RIG_MAKE_MODEL(RIG_YAESU, 10)
+#define RIG_MODEL_FT840 RIG_MAKE_MODEL(RIG_YAESU, 11)
+#define RIG_MODEL_FT820 RIG_MAKE_MODEL(RIG_YAESU, 12)
+#define RIG_MODEL_FT900 RIG_MAKE_MODEL(RIG_YAESU, 13)
+#define RIG_MODEL_FT920 RIG_MAKE_MODEL(RIG_YAESU, 14)
+#define RIG_MODEL_FT890 RIG_MAKE_MODEL(RIG_YAESU, 15)
+#define RIG_MODEL_FT990 RIG_MAKE_MODEL(RIG_YAESU, 16)
+#define RIG_MODEL_FRG100 RIG_MAKE_MODEL(RIG_YAESU, 17)
+#define RIG_MODEL_FRG9600 RIG_MAKE_MODEL(RIG_YAESU, 18)
+#define RIG_MODEL_FRG8800 RIG_MAKE_MODEL(RIG_YAESU, 19)
 
 	/*
 	 * Kenwood
 	 */
-	RIG_MODEL_TS50,
-	RIG_MODEL_TS440,
-	RIG_MODEL_TS450S,
-	RIG_MODEL_TS570D,
-	RIG_MODEL_TS690S,
-	RIG_MODEL_TS711,
-	RIG_MODEL_TS790,
-	RIG_MODEL_TS811,
-	RIG_MODEL_TS850,
-	RIG_MODEL_TS870S,
-	RIG_MODEL_TS940,
-	RIG_MODEL_TS950,
-	RIG_MODEL_TS950SDX,
-	RIG_MODEL_R5000,
+#define RIG_KENWOOD 2
+#define RIG_BACKEND_KENWOOD "kenwood"
+#define RIG_MODEL_TS50 RIG_MAKE_MODEL(RIG_KENWOOD, 1)
+#define RIG_MODEL_TS440 RIG_MAKE_MODEL(RIG_KENWOOD, 2)
+#define RIG_MODEL_TS450S RIG_MAKE_MODEL(RIG_KENWOOD, 3)
+#define RIG_MODEL_TS570D RIG_MAKE_MODEL(RIG_KENWOOD, 4)
+#define RIG_MODEL_TS690S RIG_MAKE_MODEL(RIG_KENWOOD, 5)
+#define RIG_MODEL_TS711 RIG_MAKE_MODEL(RIG_KENWOOD, 6)
+#define RIG_MODEL_TS790 RIG_MAKE_MODEL(RIG_KENWOOD, 7)
+#define RIG_MODEL_TS811 RIG_MAKE_MODEL(RIG_KENWOOD, 8)
+#define RIG_MODEL_TS850 RIG_MAKE_MODEL(RIG_KENWOOD, 9)
+#define RIG_MODEL_TS870S RIG_MAKE_MODEL(RIG_KENWOOD, 10)
+#define RIG_MODEL_TS940 RIG_MAKE_MODEL(RIG_KENWOOD, 11)
+#define RIG_MODEL_TS950 RIG_MAKE_MODEL(RIG_KENWOOD, 12)
+#define RIG_MODEL_TS950SDX RIG_MAKE_MODEL(RIG_KENWOOD, 13)
+#define RIG_MODEL_TS2000 RIG_MAKE_MODEL(RIG_KENWOOD, 14)
+#define RIG_MODEL_R5000 RIG_MAKE_MODEL(RIG_KENWOOD, 15)
 
 	/*
 	 * Icom
 	 */
-	RIG_MODEL_ICALL,	/* do-it-all, for debug purpose */
-	RIG_MODEL_IC1271,
-	RIG_MODEL_IC1275,
-	RIG_MODEL_IC271,
-	RIG_MODEL_IC275,
-	RIG_MODEL_IC375,
-	RIG_MODEL_IC471,
-	RIG_MODEL_IC475,
-	RIG_MODEL_IC575,
-	RIG_MODEL_IC706,
-	RIG_MODEL_IC706MKII,
-	RIG_MODEL_IC706MKIIG,
-	RIG_MODEL_IC707,
-	RIG_MODEL_IC718,
-	RIG_MODEL_IC725,
-	RIG_MODEL_IC726,
-	RIG_MODEL_IC728,
-	RIG_MODEL_IC729,
-	RIG_MODEL_IC731,
-	RIG_MODEL_IC735,
-	RIG_MODEL_IC736,
-	RIG_MODEL_IC737,
-	RIG_MODEL_IC738,
-	RIG_MODEL_IC746,
-	RIG_MODEL_IC751,
-	RIG_MODEL_IC751A,
-	RIG_MODEL_IC756,
-	RIG_MODEL_IC756PRO,
-	RIG_MODEL_IC761,
-	RIG_MODEL_IC765,
-	RIG_MODEL_IC775,
-	RIG_MODEL_IC781,
-	RIG_MODEL_IC820,
-	RIG_MODEL_IC821,
-	RIG_MODEL_IC821H,
-	RIG_MODEL_IC970,
-	RIG_MODEL_ICR10,
-	RIG_MODEL_ICR71,
-	RIG_MODEL_ICR72,
-	RIG_MODEL_ICR75,
-	RIG_MODEL_ICR7000,
-	RIG_MODEL_ICR7100,
-	RIG_MODEL_ICR8500,
-	RIG_MODEL_ICR9000,
-	RIG_MODEL_PCR1000,
-	RIG_MODEL_PCR100,
-
+#define RIG_ICOM 3
+#define RIG_BACKEND_ICOM "icom"
+	/* do-it-all, for debug purpose */
+#define RIG_MODEL_ICALL RIG_MAKE_MODEL(RIG_ICOM, 0)
+#define RIG_MODEL_IC1271 RIG_MAKE_MODEL(RIG_ICOM, 1)
+#define RIG_MODEL_IC1275 RIG_MAKE_MODEL(RIG_ICOM, 2)
+#define RIG_MODEL_IC271 RIG_MAKE_MODEL(RIG_ICOM, 3)
+#define RIG_MODEL_IC275 RIG_MAKE_MODEL(RIG_ICOM, 4)
+#define RIG_MODEL_IC375 RIG_MAKE_MODEL(RIG_ICOM, 5)
+#define RIG_MODEL_IC471 RIG_MAKE_MODEL(RIG_ICOM, 6)
+#define RIG_MODEL_IC475 RIG_MAKE_MODEL(RIG_ICOM, 7)
+#define RIG_MODEL_IC575 RIG_MAKE_MODEL(RIG_ICOM, 8)
+#define RIG_MODEL_IC706 RIG_MAKE_MODEL(RIG_ICOM, 9)
+#define RIG_MODEL_IC706MKII RIG_MAKE_MODEL(RIG_ICOM, 10)
+#define RIG_MODEL_IC706MKIIG RIG_MAKE_MODEL(RIG_ICOM, 11)
+#define RIG_MODEL_IC707 RIG_MAKE_MODEL(RIG_ICOM, 12)
+#define RIG_MODEL_IC718 RIG_MAKE_MODEL(RIG_ICOM, 13)
+#define RIG_MODEL_IC725 RIG_MAKE_MODEL(RIG_ICOM, 14)
+#define RIG_MODEL_IC726 RIG_MAKE_MODEL(RIG_ICOM, 15)
+#define RIG_MODEL_IC728 RIG_MAKE_MODEL(RIG_ICOM, 16)
+#define RIG_MODEL_IC729 RIG_MAKE_MODEL(RIG_ICOM, 17)
+#define RIG_MODEL_IC731 RIG_MAKE_MODEL(RIG_ICOM, 18)
+#define RIG_MODEL_IC735 RIG_MAKE_MODEL(RIG_ICOM, 19)
+#define RIG_MODEL_IC736 RIG_MAKE_MODEL(RIG_ICOM, 20)
+#define RIG_MODEL_IC737 RIG_MAKE_MODEL(RIG_ICOM, 21)
+#define RIG_MODEL_IC738 RIG_MAKE_MODEL(RIG_ICOM, 22)
+#define RIG_MODEL_IC746 RIG_MAKE_MODEL(RIG_ICOM, 23)
+#define RIG_MODEL_IC751 RIG_MAKE_MODEL(RIG_ICOM, 24)
+#define RIG_MODEL_IC751A RIG_MAKE_MODEL(RIG_ICOM, 25)
+#define RIG_MODEL_IC756 RIG_MAKE_MODEL(RIG_ICOM, 26)
+#define RIG_MODEL_IC756PRO RIG_MAKE_MODEL(RIG_ICOM, 27)
+#define RIG_MODEL_IC761 RIG_MAKE_MODEL(RIG_ICOM, 28)
+#define RIG_MODEL_IC765 RIG_MAKE_MODEL(RIG_ICOM, 29)
+#define RIG_MODEL_IC775 RIG_MAKE_MODEL(RIG_ICOM, 30)
+#define RIG_MODEL_IC781 RIG_MAKE_MODEL(RIG_ICOM, 31)
+#define RIG_MODEL_IC820 RIG_MAKE_MODEL(RIG_ICOM, 32)
+#define RIG_MODEL_IC821 RIG_MAKE_MODEL(RIG_ICOM, 33)
+#define RIG_MODEL_IC821H RIG_MAKE_MODEL(RIG_ICOM, 34)
+#define RIG_MODEL_IC970 RIG_MAKE_MODEL(RIG_ICOM, 35)
+#define RIG_MODEL_ICR10 RIG_MAKE_MODEL(RIG_ICOM, 36)
+#define RIG_MODEL_ICR71 RIG_MAKE_MODEL(RIG_ICOM, 37)
+#define RIG_MODEL_ICR72 RIG_MAKE_MODEL(RIG_ICOM, 38)
+#define RIG_MODEL_ICR75 RIG_MAKE_MODEL(RIG_ICOM, 39)
+#define RIG_MODEL_ICR7000 RIG_MAKE_MODEL(RIG_ICOM, 40)
+#define RIG_MODEL_ICR7100 RIG_MAKE_MODEL(RIG_ICOM, 41)
+#define RIG_MODEL_ICR8500 RIG_MAKE_MODEL(RIG_ICOM, 42)
+#define RIG_MODEL_ICR9000 RIG_MAKE_MODEL(RIG_ICOM, 43)
 	/*
 	 * Optoelectronics (CI-V)
 	 */
-	RIG_MODEL_MINISCOUT,
-	RIG_MODEL_XPLORER,
+#define RIG_MODEL_MINISCOUT RIG_MAKE_MODEL(RIG_ICOM, 44)
+#define RIG_MODEL_XPLORER RIG_MAKE_MODEL(RIG_ICOM, 45)
 
 	/*
 	 * TenTec (CI-V)
 	 */
-	RIG_MODEL_OMNIVI,
-	RIG_MODEL_OMNIVIP,	/* OMNI-IV+ */
+#define RIG_MODEL_OMNIVI RIG_MAKE_MODEL(RIG_ICOM, 46)
+#define RIG_MODEL_OMNIVIP RIG_MAKE_MODEL(RIG_ICOM, 47) /* OMNI-IV+ */
+
+	/*
+	 * Icom PCR
+	 */
+#define RIG_PCR 4
+#define RIG_BACKEND_PCR "pcr"
+#define RIG_MODEL_PCR1000 RIG_MAKE_MODEL(RIG_PCR, 1)
+#define RIG_MODEL_PCR100 RIG_MAKE_MODEL(RIG_PCR, 2)
 
 	/*
 	 * AOR
 	 */
-	RIG_MODEL_AR8200,
-	RIG_MODEL_AR8000,
-	RIG_MODEL_AR7030,
-	RIG_MODEL_AR5000,
-	RIG_MODEL_AR3030,
-	RIG_MODEL_AR3000A,
-	RIG_MODEL_AR3000,
-	RIG_MODEL_AR2700,
-	RIG_MODEL_AR2500,
-	RIG_MODEL_AR16,
+#define RIG_AOR 5
+#define RIG_BACKEND_AOR "aor"
+#define RIG_MODEL_AR8200 RIG_MAKE_MODEL(RIG_AOR, 1)
+#define RIG_MODEL_AR8000 RIG_MAKE_MODEL(RIG_AOR, 2)
+#define RIG_MODEL_AR7030 RIG_MAKE_MODEL(RIG_AOR, 3)
+#define RIG_MODEL_AR5000 RIG_MAKE_MODEL(RIG_AOR, 4)
+#define RIG_MODEL_AR3030 RIG_MAKE_MODEL(RIG_AOR, 5)
+#define RIG_MODEL_AR3000A RIG_MAKE_MODEL(RIG_AOR, 6)
+#define RIG_MODEL_AR3000 RIG_MAKE_MODEL(RIG_AOR, 7)
+#define RIG_MODEL_AR2700 RIG_MAKE_MODEL(RIG_AOR, 8)
+#define RIG_MODEL_AR2500 RIG_MAKE_MODEL(RIG_AOR, 9)
+#define RIG_MODEL_AR16 RIG_MAKE_MODEL(RIG_AOR, 10)
 
 	/*
 	 * JRC
 	 */
-	RIG_MODEL_JST145,
-	RIG_MODEL_JST245,
-	RIG_MODEL_CMH530,
-	RIG_MODEL_NRD345,
-	RIG_MODEL_NRD525,
-	RIG_MODEL_NRD535,
-	RIG_MODEL_NRD545,
+#define RIG_JRC 6
+#define RIG_BACKEND_JRC "jrc"
+#define RIG_MODEL_JST145 RIG_MAKE_MODEL(RIG_JRC, 1)
+#define RIG_MODEL_JST245 RIG_MAKE_MODEL(RIG_JRC, 2)
+#define RIG_MODEL_CMH530 RIG_MAKE_MODEL(RIG_JRC, 3)
+#define RIG_MODEL_NRD345 RIG_MAKE_MODEL(RIG_JRC, 4)
+#define RIG_MODEL_NRD525 RIG_MAKE_MODEL(RIG_JRC, 5)
+#define RIG_MODEL_NRD535 RIG_MAKE_MODEL(RIG_JRC, 6)
+#define RIG_MODEL_NRD545 RIG_MAKE_MODEL(RIG_JRC, 7)
 
 	/*
 	 * Radio Shack
+	 * Actualy, they might be either Icom or Uniden. TBC --SF
 	 */
-	RIG_MODEL_RS64,		/* PRO-64 */
-	RIG_MODEL_RS2005,	/* w/ OptoElectronics OS456 Board */
-	RIG_MODEL_RS2006,	/* w/ OptoElectronics OS456 Board */
-	RIG_MODEL_RS2035,	/* w/ OptoElectronics OS435 Board */
-	RIG_MODEL_RS2042,	/* w/ OptoElectronics OS435 Board */
-	RIG_MODEL_RS2041,	/* PRO-2041 */
-	RIG_MODEL_RS2052,	/* PRO-2052 */
+#define RIG_RADIOSHACK 7
+#define RIG_BACKEND_RADIOSHACK "radioshack"
+#define RIG_MODEL_RS64 RIG_MAKE_MODEL(RIG_RADIOSHACK, 1)		/* PRO-64 */
+#define RIG_MODEL_RS2005 RIG_MAKE_MODEL(RIG_RADIOSHACK, 2)	/* w/ OptoElectronics OS456 Board */
+#define RIG_MODEL_RS2006 RIG_MAKE_MODEL(RIG_RADIOSHACK, 3)	/* w/ OptoElectronics OS456 Board */
+#define RIG_MODEL_RS2035 RIG_MAKE_MODEL(RIG_RADIOSHACK, 4)	/* w/ OptoElectronics OS435 Board */
+#define RIG_MODEL_RS2042 RIG_MAKE_MODEL(RIG_RADIOSHACK, 5)	/* w/ OptoElectronics OS435 Board */
+#define RIG_MODEL_RS2041 RIG_MAKE_MODEL(RIG_RADIOSHACK, 6)	/* PRO-2041 */
+#define RIG_MODEL_RS2052 RIG_MAKE_MODEL(RIG_RADIOSHACK, 7)	/* PRO-2052 */
 
 	/*
 	 * Uniden
 	 */
-	RIG_MODEL_BC780,	/* Uniden BC780 - Trunk Tracker "Desktop Radio" */
-	RIG_MODEL_BC245,
-	RIG_MODEL_BC895,
+#define RIG_UNIDEN 8
+#define RIG_BACKEND_UNIDEN "uniden"
+#define RIG_MODEL_BC780 RIG_MAKE_MODEL(RIG_UNIDEN, 1)	/* Uniden BC780 - Trunk Tracker "Desktop Radio" */
+#define RIG_MODEL_BC245 RIG_MAKE_MODEL(RIG_UNIDEN, 2)
+#define RIG_MODEL_BC895 RIG_MAKE_MODEL(RIG_UNIDEN, 3)
 
 	/*
 	 * Drake
 	 */
-	RIG_MODEL_DKR8,
-	RIG_MODEL_DKR8A,
+#define RIG_DRAKE 9
+#define RIG_BACKEND_DRAKE "drake"
+#define RIG_MODEL_DKR8 RIG_MAKE_MODEL(RIG_DRAKE, 1)
+#define RIG_MODEL_DKR8A RIG_MAKE_MODEL(RIG_DRAKE, 2)
 
 	/*
 	 * Lowe
 	 */
-	RIG_MODEL_HF150,
-	RIG_MODEL_HF225,
-	RIG_MODEL_HF250,
+#define RIG_LOWE 10
+#define RIG_BACKEND_LOWE "lowe"
+#define RIG_MODEL_HF150 RIG_MAKE_MODEL(RIG_LOWE, 1)
+#define RIG_MODEL_HF225 RIG_MAKE_MODEL(RIG_LOWE, 2)
+#define RIG_MODEL_HF250 RIG_MAKE_MODEL(RIG_LOWE, 3)
 
 	/*
 	 * Racal
 	 */
-	RIG_MODEL_RA3790,
-	RIG_MODEL_RA3720,
+#define RIG_RACAL 11
+#define RIG_BACKEND_RACAL "racal"
+#define RIG_MODEL_RA3790 RIG_MAKE_MODEL(RIG_RACAL, 1)
+#define RIG_MODEL_RA3720 RIG_MAKE_MODEL(RIG_RACAL, 2)
 
 	/*
 	 * Watkins-Johnson
 	 */
-	RIG_MODEL_HF1000,
-	RIG_MODEL_HF1000A,
-	RIG_MODEL_WJ8711,
+#define RIG_WJ 12
+#define RIG_BACKEND_WJ "wj"
+#define RIG_MODEL_HF1000 RIG_MAKE_MODEL(RIG_WJ, 1)
+#define RIG_MODEL_HF1000A RIG_MAKE_MODEL(RIG_WJ, 2)
+#define RIG_MODEL_WJ8711 RIG_MAKE_MODEL(RIG_WJ, 3)
 
 	/*
 	 * Rohde & Schwarz
 	 */
-	RIG_MODEL_ESM500,
-	RIG_MODEL_EK890,
-	RIG_MODEL_EK891,
-	RIG_MODEL_EK895,
-	RIG_MODEL_EK070,
+#define RIG_EK 13
+#define RIG_BACKEND_EK "ek"
+#define RIG_MODEL_ESM500 RIG_MAKE_MODEL(RIG_EK, 1)
+#define RIG_MODEL_EK890 RIG_MAKE_MODEL(RIG_EK, 2)
+#define RIG_MODEL_EK891 RIG_MAKE_MODEL(RIG_EK, 3)
+#define RIG_MODEL_EK895 RIG_MAKE_MODEL(RIG_EK, 4)
+#define RIG_MODEL_EK070 RIG_MAKE_MODEL(RIG_EK, 5)
 
 	/*
 	 * Skanti
 	 */
-	RIG_MODEL_TRP7000,
-	RIG_MODEL_TRP8000,
-	RIG_MODEL_TRP9000,
+#define RIG_SKANTI 14
+#define RIG_BACKEND_SKANTI "skanti"
+#define RIG_MODEL_TRP7000 RIG_MAKE_MODEL(RIG_SKANTI, 1)
+#define RIG_MODEL_TRP8000 RIG_MAKE_MODEL(RIG_SKANTI, 2)
+#define RIG_MODEL_TRP9000 RIG_MAKE_MODEL(RIG_SKANTI, 3)
 
 	/*
 	 * WiNRADiO/LinRADiO, by Rosetta?
 	 */
-	RIG_MODEL_WR1000,	/* WR-1000i */
-	RIG_MODEL_WR1500,	/* WR-1500i and WR-1500e */
-	RIG_MODEL_WR1550,	/* WR-1550e */
-	RIG_MODEL_WR3100,
-	RIG_MODEL_WR3150,	/* WR-3150i */
-	RIG_MODEL_WR3500,
-	RIG_MODEL_WR3700,
+#define RIG_WINRADIO 15
+#define RIG_BACKEND_WINRADIO "winradio"
+#define RIG_MODEL_WR1000 RIG_MAKE_MODEL(RIG_WINRADIO, 1)
+#define RIG_MODEL_WR1500 RIG_MAKE_MODEL(RIG_WINRADIO, 2)
+#define RIG_MODEL_WR1550 RIG_MAKE_MODEL(RIG_WINRADIO, 3)
+#define RIG_MODEL_WR3100 RIG_MAKE_MODEL(RIG_WINRADIO, 4)
+#define RIG_MODEL_WR3150 RIG_MAKE_MODEL(RIG_WINRADIO, 5)
+#define RIG_MODEL_WR3500 RIG_MAKE_MODEL(RIG_WINRADIO, 6)
+#define RIG_MODEL_WR3700 RIG_MAKE_MODEL(RIG_WINRADIO, 7)
 
 	/*
 	 * Ten Tec
 	 */
-	RIG_MODEL_TT550,	/* Pegasus */
-	RIG_MODEL_TT538,	/* Jupiter */
-	RIG_MODEL_RX320,
-	RIG_MODEL_RX340,
+#define RIG_TENTEC 16
+#define RIG_BACKEND_TENTEC "tentec"
+#define RIG_MODEL_TT550 RIG_MAKE_MODEL(RIG_MODEL_TENTEC, 1)	/* Pegasus */
+#define RIG_MODEL_TT538 RIG_MAKE_MODEL(RIG_MODEL_TENTEC, 2)	/* Jupiter */
+#define RIG_MODEL_RX320 RIG_MAKE_MODEL(RIG_MODEL_TENTEC, 3)
+#define RIG_MODEL_RX340 RIG_MAKE_MODEL(RIG_MODEL_TENTEC, 4)
 
-	RIG_MODEL_KWZ30,	/* KNEISNER +DOERING */
-	RIG_MODEL_E1800,	/* DASA-Telefunken */
-	RIG_MODEL_EKD500,	/* RFT */
-	RIG_MODEL_DX77,		/* Alinco */
+#define RIG_ALINCO 17
+#define RIG_BACKEND_ALINCO "alinco"
+#define RIG_MODEL_DX77 RIG_MAKE_MODEL(RIG_ALINCO, 1)		/* Alinco */
 
+	/*
+	 * TODO:
+		RIG_MODEL_KWZ30,	KNEISNER +DOERING
+		RIG_MODEL_E1800,	DASA-Telefunken
+		RIG_EKD500,	RFT
+	*/
 
-	/* etc. */
-};
+typedef int rig_model_t;
 
-typedef enum rig_model_e rig_model_t;
+#define RIG_BACKEND_LIST {		\
+		{ RIG_DUMMY, RIG_BACKEND_DUMMY }, \
+		{ RIG_YAESU, RIG_BACKEND_YAESU }, \
+		{ RIG_KENWOOD, RIG_BACKEND_KENWOOD }, \
+		{ RIG_ICOM, RIG_BACKEND_ICOM }, \
+		{ RIG_PCR, RIG_BACKEND_PCR }, \
+		{ RIG_AOR, RIG_BACKEND_AOR }, \
+		{ RIG_JRC, RIG_BACKEND_JRC }, \
+		{ RIG_RADIOSHACK, RIG_BACKEND_RADIOSHACK }, \
+		{ RIG_UNIDEN, RIG_BACKEND_UNIDEN }, \
+		{ RIG_DRAKE, RIG_BACKEND_DRAKE }, \
+		{ RIG_LOWE, RIG_BACKEND_LOWE }, \
+		{ RIG_RACAL, RIG_BACKEND_RACAL }, \
+		{ RIG_WJ, RIG_BACKEND_WJ }, \
+		{ RIG_EK, RIG_BACKEND_EK }, \
+		{ RIG_SKANTI, RIG_BACKEND_SKANTI }, \
+		{ RIG_WINRADIO, RIG_BACKEND_WINRADIO }, \
+		{ RIG_TENTEC, RIG_BACKEND_TENTEC }, \
+		{ RIG_ALINCO, RIG_BACKEND_ALINCO }, \
+		{ 0, NULL }, /* end */  \
+}
 
+/*
+ * struct rig_backend_list {
+ *		rig_model_t model;
+ *		const char *backend;
+ * } rig_backend_list[] = RIG_LIST;
+ *
+ */
 
 #endif /* _RIGLIST_H */
diff --git a/src/register.c b/src/register.c
index 80fdfea89..e65d86e26 100644
--- a/src/register.c
+++ b/src/register.c
@@ -2,7 +2,7 @@
    register.c  - Copyright (C) 2000 Stephane Fillod and Frank Singleton
    Provides registering for dynamically loadable backends.
 
-   $Id: register.c,v 1.4 2001-06-02 17:54:43 f4cfe Exp $
+   $Id: register.c,v 1.5 2001-06-04 21:17:52 f4cfe Exp $
 
    Hamlib is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
@@ -41,7 +41,26 @@
 # define PATH_MAX       1024
 #endif
 
+#define RIG_BACKEND_MAX 32
 
+/*
+ * RIG_BACKEND_LIST is defined in riglist.h, please keep it up to data,
+ * 	ie. each time you give birth to a new backend
+ * Also, it should be possible to register "external" backend,
+ * that is backend that were not known by Hamlib at compile time.
+ * Maybe, riglist.h should reserve some numbers for them? --SF
+ */
+static struct {
+	int be_num;
+	const char *be_name;
+    rig_model_t (*be_probe)(port_t *);
+} rig_backend_list[RIG_BACKEND_MAX] = RIG_BACKEND_LIST;
+
+
+/*
+ * This struct to keep track of known rig models.
+ * It is chained, and used in a hash table, see below.
+ */
 struct rig_list {
 		const struct rig_caps *caps;
 		lt_dlhandle handle;			/* handle returned by lt_dlopen() */
@@ -57,6 +76,9 @@ struct rig_list {
  */
 static struct rig_list *rig_hash_table[RIGLSTHASHSZ] = { NULL, };
 
+
+static int rig_lookup_backend(rig_model_t rig_model);
+
 /*
  * Basically, this is a hash insert function that doesn't check for dup!
  */
@@ -70,7 +92,7 @@ int rig_register(const struct rig_caps *caps)
 
 		rig_debug(RIG_DEBUG_VERBOSE, "rig_register (%d)\n",caps->rig_model);
 
-#ifdef WANT_DUP_CHECK
+#ifndef DONT_WANT_DUP_CHECK
 		if (rig_get_caps(caps->rig_model)!=NULL)
 				return -RIG_EINVAL;
 #endif
@@ -104,6 +126,59 @@ const struct rig_caps *rig_get_caps(rig_model_t rig_model)
 		return NULL;	/* sorry, caps not registered! */
 }
 
+/*
+ * lookup for backend index in rig_backend_list table,
+ * according to BACKEND_NUM
+ * return -1 if not found.
+ */
+static int rig_lookup_backend(rig_model_t rig_model)
+{
+		int i;
+
+		for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
+				if (RIG_BACKEND_NUM(rig_model) == 
+								rig_backend_list[i].be_num)
+						return i;
+		}
+		return -1;
+}
+
+/*
+ * rig_check_backend
+ * check the backend declaring this model has been loaded
+ * and if not loaded already, load it!
+ * This permits seamless operation in rig_init.
+ */
+int rig_check_backend(rig_model_t rig_model)
+{
+		const struct rig_caps *caps;
+		int be_idx;
+		int retval;
+		
+		/* already loaded ? */
+		caps = rig_get_caps(rig_model);
+		if (caps)
+				return RIG_OK;
+
+		be_idx = rig_lookup_backend(rig_model);
+
+		/*
+		 * Never heard about this backend family!
+		 */
+		if (be_idx == -1) {
+			rig_debug(RIG_DEBUG_VERBOSE, "rig_check_backend: unsupported "
+							"backend %d for model %d\n", 
+							RIG_BACKEND_NUM(rig_model), rig_model
+							);
+			return -RIG_ENAVAIL;
+		}
+				
+		retval = rig_load_backend(rig_backend_list[be_idx].be_name);
+
+		return retval;
+}
+
+
 
 int rig_unregister(rig_model_t rig_model)
 {
@@ -146,6 +221,38 @@ int rig_list_foreach(int (*cfunc)(const struct rig_caps*, void *),void *data)
 	return RIG_OK;
 }
 
+/*
+ * rig_probe_all
+ * called straight by rig_probe
+ */
+rig_model_t rig_probe_all(port_t *p)
+{
+	int i;
+	rig_model_t rig_model;
+
+	for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
+			if (rig_backend_list[i].be_probe) {
+					rig_model = (*rig_backend_list[i].be_probe)(p);
+					if (rig_model != RIG_MODEL_NONE)
+							return rig_model;
+			}
+	}
+	return RIG_MODEL_NONE;
+}
+
+
+int rig_load_all_backends()
+{
+	int i;
+
+	for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
+			rig_load_backend(rig_backend_list[i].be_name);
+	}
+	return RIG_OK;
+}
+
+
+#define MAXFUNCNAMELEN 64
 /*
  * rig_load_backend
  * Dynamically load a rig backend through dlopen mechanism
@@ -154,47 +261,66 @@ int rig_load_backend(const char *be_name)
 {
 # define PREFIX "libhamlib-"
 # define POSTFIX ".so" /* ".so.%u" */
-		lt_dlhandle be_handle;
-	    int (*be_init)(void *);
-		int status;
-		char libname[PATH_MAX];
-		char initfuncname[64]="init_";
+	lt_dlhandle be_handle;
+    int (*be_init)(void *);
+	int status;
+	char libname[PATH_MAX];
+	char initfname[MAXFUNCNAMELEN]  = "init_";
+	char probefname[MAXFUNCNAMELEN] = "probe_";
+	int i;
 
-	/* lt_dlinit may be called several times */
+	/*
+	 * lt_dlinit may be called several times
+	 */
 	status = lt_dlinit();
 	if (status) {
-    		rig_debug(RIG_DEBUG_ERR, "rig_backend_load: lt_dlinit for %s failed: %d\n",
-					      be_name, status);
+    		rig_debug(RIG_DEBUG_ERR, "rig_backend_load: lt_dlinit for %s "
+							"failed: %d\n", be_name, status);
     		return -RIG_EINTERNAL;
 	}
 
-		rig_debug(RIG_DEBUG_VERBOSE, "rig: loading backend %s\n",be_name);
+	rig_debug(RIG_DEBUG_VERBOSE, "rig: loading backend %s\n",be_name);
 
-		/*
-		 * add hamlib directory here
-		 */
-		snprintf (libname, sizeof (libname), PREFIX"%s"POSTFIX, be_name);
+	/*
+	 * add hamlib directory here
+	 */
+	snprintf (libname, sizeof (libname), PREFIX"%s"POSTFIX, be_name);
 
-		be_handle = lt_dlopen (libname);
+	be_handle = lt_dlopen (libname);
 
-		if (!be_handle) {
-			rig_debug(RIG_DEBUG_ERR, "rig: lt_dlopen(\"%s\") failed (%s)\n",
-							libname, lt_dlerror());
+	if (!be_handle) {
+		rig_debug(RIG_DEBUG_ERR, "rig: lt_dlopen(\"%s\") failed (%s)\n",
+						libname, lt_dlerror());
+		return -RIG_EINVAL;
+    }
+
+
+    strncat(initfname, be_name, MAXFUNCNAMELEN);
+    be_init = (int (*)(void *)) lt_dlsym (be_handle, initfname);
+	if (!be_init) {
+			rig_debug(RIG_DEBUG_ERR, "rig: dlsym(%s) failed (%s)\n",
+						initfname, lt_dlerror());
+			lt_dlclose(be_handle);
 			return -RIG_EINVAL;
-	    }
+	}
 
 
-	    strcat(initfuncname, be_name);
-	    be_init = (int (*)(void *)) lt_dlsym (be_handle, initfuncname);
-		if (!be_init) {
-				rig_debug(RIG_DEBUG_ERR, "rig: dlsym(%s) failed (%s)\n",
-							initfuncname, lt_dlerror());
-				lt_dlclose(be_handle);
-				return -RIG_EINVAL;
+	/*
+	 * register probe function if present
+	 * NOTE: rig_load_backend might have been called upon a backend
+	 * 	not in riglist.h! In this case, do nothing.
+	 */
+	for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
+		if (!strncmp(be_name, rig_backend_list[i].be_name, 64)) {
+    			strncat(probefname, be_name, MAXFUNCNAMELEN);
+    			rig_backend_list[i].be_probe = (rig_model_t (*)(port_t *))
+						lt_dlsym (be_handle, probefname);
+				break;
 		}
+	}
 
-		status = (*be_init)(be_handle);
+	status = (*be_init)(be_handle);
 
-	 	return status;
+ 	return status;
 }
 
diff --git a/src/rig.c b/src/rig.c
index 24aee6a0e..ec55aa9c2 100644
--- a/src/rig.c
+++ b/src/rig.c
@@ -2,7 +2,7 @@
    Copyright (C) 2000,2001 Stephane Fillod and Frank Singleton
    This file is part of the hamlib package.
 
-   $Id: rig.c,v 1.31 2001-06-04 17:01:21 f4cfe Exp $
+   $Id: rig.c,v 1.32 2001-06-04 21:17:52 f4cfe Exp $
 
    Hamlib is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
@@ -231,6 +231,8 @@ RIG *rig_init(rig_model_t rig_model)
 
 		rig_debug(RIG_DEBUG_VERBOSE,"rig:rig_init called \n");
 
+		rig_check_backend(rig_model);
+
 		caps = rig_get_caps(rig_model);
 		if (!caps)
 				return NULL;
@@ -2614,37 +2616,26 @@ int rig_reset(RIG *rig, reset_t reset)
 }
 
 
-
-#if 0
-
-/* CAUTION: this is really Experimental, It never worked!!
- * try to guess a rig, can be very buggy! (but fun if it works!)
- * FIXME: finish me and handle nicely errors
- * TODO: rewrite rig_probe, it's the wrong approach.
- * 		 Each rig backend should provide a rigbe_probe function
- * 		 so with help of rig_list_foreach we can probe them all. --SF
+/**
+ *      rig_probe - try to guess a rig
+ *      @p:		A pointer describing a port connected to the rig
+ *
+ *      The rig_probe() function try to guess a rig, can be very buggy!
+ *      (but fun if it works!)
+ *		CAUTION: this is really Experimental, It never worked 
+ *		(never tested tough)!!
+ *
+ *      RETURN VALUE: The rig_probe() function returns the rig model id
+ *      according to the rig_model_t type if found, or %RIG_MODEL_NONE
+ *      otherwise.
  */
-RIG *rig_probe(const char *port_path)
+rig_model_t rig_probe(port_t *p)
 {
-		RIG *rig;
-		int i;
+		if (!p)
+				return RIG_MODEL_NONE;
 
-		for (i = 0; rig_base[i]; i++) {
-			if (rig_base[i]->rig_probe != NULL) {
-				rig = rig_init(rig_base[i]->rig_model);
-				strncpy(rig->state.rig_path, port_path, FILPATHLEN);
-				rig_open(rig);
-				if (rig && rig_base[i]->rig_probe(rig) == 0) {
-					return rig;
-				} else {
-					rig_close(rig);
-					rig_cleanup(rig);
-				}
-			}
-		}
-		return NULL;
+		return rig_probe_all(p);
 }
-#endif
 
 /**
  *      rig_set_level - set a radio level setting
diff --git a/tests/dumpcaps.c b/tests/dumpcaps.c
index 7eecb04c1..7074ce3aa 100644
--- a/tests/dumpcaps.c
+++ b/tests/dumpcaps.c
@@ -3,7 +3,7 @@
  * This programs dumps the capabilities of a backend rig.
  *
  *
- *    $Id: dumpcaps.c,v 1.25 2001-06-03 19:54:05 f4cfe Exp $  
+ *    $Id: dumpcaps.c,v 1.26 2001-06-04 21:17:52 f4cfe Exp $  
  *
  *
  * This program is free software; you can redistribute it and/or
@@ -42,12 +42,14 @@ int main (int argc, char *argv[])
 	int status,i;
 	char freqbuf[20];
 	int backend_warnings=0;
+	int rig_model;
 
 	if (argc != 2) {
 			fprintf(stderr,"%s <rig_num>\n",argv[0]);
 			exit(1);
 	}
 
+#if 0
   	status = rig_load_backend("icom");
 	status |= rig_load_backend("ft747");
 	status |= rig_load_backend("ft847");
@@ -61,10 +63,15 @@ int main (int argc, char *argv[])
 		printf("rig_load_backend: error = %s \n", rigerror(status));
 		exit(3);
 	}
+#endif
 
-	caps = rig_get_caps(atoi(argv[1]));
+	rig_model = atoi(argv[1]);
+	
+	rig_check_backend(rig_model);
+
+	caps = rig_get_caps(rig_model);
 	if (!caps) {
-			fprintf(stderr,"Unknown rig num: %d\n",atoi(argv[1]));
+			fprintf(stderr,"Unknown rig num: %d\n", rig_model);
 			fprintf(stderr,"Please check riglist.h\n");
 			exit(2);
 	}
diff --git a/tests/dumpmem.c b/tests/dumpmem.c
index 6ab9b86b3..4540564d1 100644
--- a/tests/dumpmem.c
+++ b/tests/dumpmem.c
@@ -3,7 +3,7 @@
  * This programs dumps the mmeory contents of a rig.
  *
  *
- *    $Id: dumpmem.c,v 1.2 2001-06-04 17:01:21 f4cfe Exp $  
+ *    $Id: dumpmem.c,v 1.3 2001-06-04 21:17:53 f4cfe Exp $  
  *
  *
  * This program is free software; you can redistribute it and/or
@@ -45,6 +45,7 @@ int main (int argc, char *argv[])
 			exit(1);
 	}
 
+#if 0
   	status = rig_load_backend("icom");
 	status |= rig_load_backend("ft747");
 	status |= rig_load_backend("ft847");
@@ -58,6 +59,7 @@ int main (int argc, char *argv[])
 		printf("rig_load_backend: error = %s \n", rigerror(status));
 		exit(3);
 	}
+#endif
 
   	my_rig = rig_init(atoi(argv[1]));
 
diff --git a/tests/listrigs.c b/tests/listrigs.c
index 1525aac6f..6c6901e94 100644
--- a/tests/listrigs.c
+++ b/tests/listrigs.c
@@ -3,7 +3,7 @@
  * This programs list all the available the rig capabilities.
  *
  *
- *    $Id: listrigs.c,v 1.8 2001-06-02 18:11:21 f4cfe Exp $  
+ *    $Id: listrigs.c,v 1.9 2001-06-04 21:17:53 f4cfe Exp $  
  *
  *
  * This program is free software; you can redistribute it and/or
@@ -97,19 +97,15 @@ int main (int argc, char *argv[])
 { 
 	int status;
 
+#if 0
 	status = rig_load_backend("icom");
 	if (status != RIG_OK ) {
 		printf("rig_load_backend: error = %s \n", rigerror(status));
 		exit(3);
 	}
-	status = rig_load_backend("ft747");
+	status = rig_load_backend("yaesu");
 	if (status != RIG_OK ) {
-		printf("rig_load_backend: ft747 error = %s \n", rigerror(status));
-		exit(3);
-	}
-	status = rig_load_backend("ft847");
-	if (status != RIG_OK ) {
-		printf("rig_load_backend: ft847 error = %s \n", rigerror(status));
+		printf("rig_load_backend: yaesu error = %s \n", rigerror(status));
 		exit(3);
 	}
 	status = rig_load_backend("kenwood");
@@ -127,8 +123,16 @@ int main (int argc, char *argv[])
 		printf("rig_load_backend: pcr error = %s \n", rigerror(status));
 		exit(3);
 	}
+	status = rig_load_backend("alinco");
+	if (status != RIG_OK ) {
+		printf("rig_load_backend: alinco error = %s \n", rigerror(status));
+		exit(3);
+	}
 	rig_load_backend("winradio");	/* may not be compiled .. */
 	rig_load_backend("dummy");
+#endif
+
+	rig_load_all_backends();
 
 	printf("Rig#\tMfg\tModel       \tVers.\tStatus\tType\n");
 	status = rig_list_foreach(print_caps_sum,NULL);
diff --git a/tests/rigctl.c b/tests/rigctl.c
index 8fe99e449..9e7bba436 100644
--- a/tests/rigctl.c
+++ b/tests/rigctl.c
@@ -7,7 +7,7 @@
  * TODO: be more generic and add command line option to run 
  * 		in non-interactive mode
  *
- * $Id: rigctl.c,v 1.14 2001-06-04 17:01:21 f4cfe Exp $  
+ * $Id: rigctl.c,v 1.15 2001-06-04 21:17:53 f4cfe Exp $  
  *
  *
  * This program is free software; you can redistribute it and/or
@@ -174,6 +174,7 @@ int main (int argc, char *argv[])
 	 * allocate memory, setup & open port 
 	 */
 
+#if 0
   	retcode = rig_load_backend("icom");
 	retcode |= rig_load_backend("ft747");
 	retcode |= rig_load_backend("ft847");
@@ -187,6 +188,7 @@ int main (int argc, char *argv[])
 		printf("rig_load_backend: error = %s \n", rigerror(retcode));
 		exit(3);
 	}
+#endif
 
 	opt_ptr = opt_string;
 	for (i=0; i<MAXNBOPT-1 && test_list[i].cmd; i++) {
diff --git a/tests/rigmatrix.c b/tests/rigmatrix.c
index 2eeae0511..4577b0853 100644
--- a/tests/rigmatrix.c
+++ b/tests/rigmatrix.c
@@ -4,7 +4,7 @@
  * The code is rather ugly since this is only a try out.
  *
  *
- *    $Id: rigmatrix.c,v 1.12 2001-06-02 18:11:21 f4cfe Exp $  
+ *    $Id: rigmatrix.c,v 1.13 2001-06-04 21:17:53 f4cfe Exp $  
  *
  *
  * This program is free software; you can redistribute it and/or
@@ -299,9 +299,6 @@ int print_caps_level(const struct rig_caps *caps, void *data)
 	
 	print_yn(level & RIG_LEVEL_PREAMP);
 	print_yn(level & RIG_LEVEL_ATT);
-#if 0
-	print_yn(level & RIG_LEVEL_ANT);	/* deprecated */
-#endif
 	print_yn(level & RIG_LEVEL_AF);
 	print_yn(level & RIG_LEVEL_RF);
 	print_yn(level & RIG_LEVEL_SQL);
@@ -541,6 +538,7 @@ int main (int argc, char *argv[])
 	time_t gentime;
 	int set_or_get;
 
+#if 0
 	status = rig_load_backend("icom");
 	if (status != RIG_OK ) {
 		printf("rig_load_backend: error = %s \n", rigerror(status));
@@ -573,6 +571,10 @@ int main (int argc, char *argv[])
 	}
 	rig_load_backend("winradio");	/* may not be compiled ... */
 	rig_load_backend("dummy");
+#endif
+
+	rig_load_all_backends();
+
 
 	printf("<TABLE BORDER=1>");
 	printf("<TR><TD>Model</TD><TD>Mfg</TD><TD>Vers.</TD><TD>Status</TD>"
diff --git a/tests/testcaps.c b/tests/testcaps.c
index 363c8f0b5..394451a95 100644
--- a/tests/testcaps.c
+++ b/tests/testcaps.c
@@ -4,7 +4,7 @@
  * like the passband info..
  *
  *
- *    $Id: testcaps.c,v 1.1 2001-04-24 20:04:47 f4cfe Exp $  
+ *    $Id: testcaps.c,v 1.2 2001-06-04 21:17:53 f4cfe Exp $  
  *
  *
  * This program is free software; you can redistribute it and/or
@@ -46,6 +46,7 @@ int main (int argc, char *argv[])
 			exit(1);
 	}
 
+#if 0
   	status = rig_load_backend("icom");
 	status |= rig_load_backend("ft747");
 	status |= rig_load_backend("ft847");
@@ -59,6 +60,7 @@ int main (int argc, char *argv[])
 		printf("rig_load_backend: error = %s \n", rigerror(status));
 		exit(3);
 	}
+#endif
 
 	pbrig = rig_init(atoi(argv[1]));
 	if (!pbrig) {
diff --git a/tests/testrig.c b/tests/testrig.c
index ca517d87e..dc15d4b0f 100644
--- a/tests/testrig.c
+++ b/tests/testrig.c
@@ -27,6 +27,7 @@ int main (int argc, char *argv[])
 	 * allocate memory, setup & open port 
 	 */
 
+#if 0
   	retcode = rig_load_backend("icom");
 	retcode = rig_load_backend("ft747");
 
@@ -34,6 +35,7 @@ int main (int argc, char *argv[])
 		printf("rig_load_backend: error = %s \n", rigerror(retcode));
 		exit(3);
 	}
+#endif
 
 	my_rig = rig_init(atoi(argv[1]));
 		
diff --git a/tests/testtrn.c b/tests/testtrn.c
index fbe43457b..da74161f0 100644
--- a/tests/testtrn.c
+++ b/tests/testtrn.c
@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
+#include <stdlib.h>
 #include <hamlib/rig.h>
 
 #define SERIAL_PORT "/dev/ttyS0"
@@ -16,12 +17,16 @@ int myfreq_event(RIG *rig, vfo_t vfo, freq_t freq)
 }
 
 
-int main ()
+int main (int argc, char *argv[])
 { 
 	RIG *my_rig;		/* handle to rig (nstance) */
 	int retcode;		/* generic return code from functions */
 	int i;
 
+	if (argc != 2) {
+		fprintf(stderr,"%s <rig_num>\n", argv[0]);
+		exit(1);
+	}
 
 	printf("testrig:hello, I am your main() !\n");
 
@@ -29,15 +34,20 @@ int main ()
 	 * allocate memory, setup & open port 
 	 */
 
+#if 0
 	retcode = rig_load_backend("icom");
 	if (retcode != RIG_OK ) {
 		printf("rig_load_backend: error = %s \n", rigerror(retcode));
 		exit(3);
 	}
+#endif
 
-	my_rig = rig_init(RIG_MODEL_IC706MKIIG);
-	if (!my_rig)
+	my_rig = rig_init(atoi(argv[1]));
+	if (!my_rig) {
+			fprintf(stderr,"Unknown rig num: %d\n",atoi(argv[1]));
+			fprintf(stderr,"Please check riglist.h\n");
 			exit(1); /* whoops! something went wrong (mem alloc?) */
+	}
 
 	strncpy(my_rig->state.rigport.path, SERIAL_PORT, FILPATHLEN);