add support for 4 new radios: AL2210, CGT, Maxim New, Maxim New2

untested because of lack of hardware. if you have a ZD1211 adapter
with one of these radios, please drop us a mail.

code written by Florian Stoehr <ich AT florian-stoehr DOT de>

2 files changed, 477 insertions, 9 deletions

diff --git a/sys/dev/usb/if_zyd.c b/sys/dev/usb/if_zyd.c
index 87ee6386a2d..1acb92189df 100644
--- a/sys/dev/usb/if_zyd.c
+++ b/sys/dev/usb/if_zyd.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: if_zyd.c,v 1.36 2006/11/13 20:06:38 damien Exp $	*/
+/*	$OpenBSD: if_zyd.c,v 1.37 2006/11/16 19:43:52 damien Exp $	*/
 
 /*-
  * Copyright (c) 2006 by Damien Bergamini <damien.bergamini@free.fr>
@@ -146,6 +146,18 @@ int		zyd_al2230_set_channel(struct zyd_rf *, uint8_t);
 int		zyd_al7230B_init(struct zyd_rf *);
 int		zyd_al7230B_switch_radio(struct zyd_rf *, int);
 int		zyd_al7230B_set_channel(struct zyd_rf *, uint8_t);
+int		zyd_al2210_init(struct zyd_rf *);
+int		zyd_al2210_switch_radio(struct zyd_rf *, int);
+int		zyd_al2210_set_channel(struct zyd_rf *, uint8_t);
+int		zyd_gct_init(struct zyd_rf *);
+int		zyd_gct_switch_radio(struct zyd_rf *, int);
+int		zyd_gct_set_channel(struct zyd_rf *, uint8_t);
+int		zyd_maxim_init(struct zyd_rf *);
+int		zyd_maxim_switch_radio(struct zyd_rf *, int);
+int		zyd_maxim_set_channel(struct zyd_rf *, uint8_t);
+int		zyd_maxim2_init(struct zyd_rf *);
+int		zyd_maxim2_switch_radio(struct zyd_rf *, int);
+int		zyd_maxim2_set_channel(struct zyd_rf *, uint8_t);
 int		zyd_rf_attach(struct zyd_softc *, uint8_t);
 const char	*zyd_rf_name(uint8_t);
 int		zyd_hw_init(struct zyd_softc *);
@@ -1064,6 +1076,294 @@ zyd_al7230B_set_channel(struct zyd_rf *rf, uint8_t chan)
 #undef N
 }
 
+/*
+ * AL2210 RF methods.
+ */
+int
+zyd_al2210_init(struct zyd_rf *rf)
+{
+#define N(a)	(sizeof (a) / sizeof ((a)[0]))
+	struct zyd_softc *sc = rf->rf_sc;
+	static const struct zyd_phy_pair phyini[] = ZYD_AL2210_PHY;
+	static const uint32_t rfini[] = ZYD_AL2210_RF;
+	uint32_t tmp;
+	int i, error;
+
+	(void)zyd_write32(sc, ZYD_CR18, 2);
+
+	/* init RF-dependent PHY registers */
+	for (i = 0; i < N(phyini); i++) {
+		error = zyd_write16(sc, phyini[i].reg, phyini[i].val);
+		if (error != 0)
+			return error;
+	}
+	/* init AL2210 radio */
+	for (i = 0; i < N(rfini); i++) {
+		if ((error = zyd_rfwrite(sc, rfini[i])) != 0)
+			return error;
+	}
+	(void)zyd_write16(sc, ZYD_CR47, 0x1e);
+	(void)zyd_read32(sc, ZYD_CR_RADIO_PD, &tmp);
+	(void)zyd_write32(sc, ZYD_CR_RADIO_PD, tmp & ~1);
+	(void)zyd_write32(sc, ZYD_CR_RADIO_PD, tmp | 1);
+	(void)zyd_write32(sc, ZYD_CR_RFCFG, 0x05);
+	(void)zyd_write32(sc, ZYD_CR_RFCFG, 0x00);
+	(void)zyd_write16(sc, ZYD_CR47, 0x1e);
+	(void)zyd_write32(sc, ZYD_CR18, 3);
+
+	return 0;
+#undef N
+}
+
+int
+zyd_al2210_switch_radio(struct zyd_rf *rf, int on)
+{
+	/* vendor driver does nothing for this RF chip */
+
+	return 0;
+}
+
+int
+zyd_al2210_set_channel(struct zyd_rf *rf, uint8_t chan)
+{
+	struct zyd_softc *sc = rf->rf_sc;
+	static const uint32_t rfprog[] = ZYD_AL2210_CHANTABLE;
+	uint32_t tmp;
+
+	(void)zyd_write32(sc, ZYD_CR18, 2);
+	(void)zyd_write16(sc, ZYD_CR47, 0x1e);
+	(void)zyd_read32(sc, ZYD_CR_RADIO_PD, &tmp);
+	(void)zyd_write32(sc, ZYD_CR_RADIO_PD, tmp & ~1);
+	(void)zyd_write32(sc, ZYD_CR_RADIO_PD, tmp | 1);
+	(void)zyd_write32(sc, ZYD_CR_RFCFG, 0x05);
+
+	(void)zyd_write32(sc, ZYD_CR_RFCFG, 0x00);
+	(void)zyd_write16(sc, ZYD_CR47, 0x1e);
+
+	/* actually set the channel */
+	(void)zyd_rfwrite(sc, rfprog[chan - 1]);
+
+	(void)zyd_write32(sc, ZYD_CR18, 3);
+
+	return 0;
+}
+
+/*
+ * GCT RF methods.
+ */
+int
+zyd_gct_init(struct zyd_rf *rf)
+{
+#define N(a)	(sizeof (a) / sizeof ((a)[0]))
+	struct zyd_softc *sc = rf->rf_sc;
+	static const struct zyd_phy_pair phyini[] = ZYD_GCT_PHY;
+	static const uint32_t rfini[] = ZYD_GCT_RF;
+	int i, error;
+
+	/* init RF-dependent PHY registers */
+	for (i = 0; i < N(phyini); i++) {
+		error = zyd_write16(sc, phyini[i].reg, phyini[i].val);
+		if (error != 0)
+			return error;
+	}
+	/* init cgt radio */
+	for (i = 0; i < N(rfini); i++) {
+		if ((error = zyd_rfwrite(sc, rfini[i])) != 0)
+			return error;
+	}
+	return 0;
+#undef N
+}
+
+int
+zyd_gct_switch_radio(struct zyd_rf *rf, int on)
+{
+	/* vendor driver does nothing for this RF chip */
+
+	return 0;
+}
+
+int
+zyd_gct_set_channel(struct zyd_rf *rf, uint8_t chan)
+{
+	struct zyd_softc *sc = rf->rf_sc;
+	static const uint32_t rfprog[] = ZYD_GCT_CHANTABLE;
+
+	(void)zyd_rfwrite(sc, 0x1c0000);
+	(void)zyd_rfwrite(sc, rfprog[chan - 1]);
+	(void)zyd_rfwrite(sc, 0x1c0008);
+
+	return 0;
+}
+
+/*
+ * Maxim RF methods.
+ */
+int
+zyd_maxim_init(struct zyd_rf *rf)
+{
+#define N(a)	(sizeof (a) / sizeof ((a)[0]))
+	struct zyd_softc *sc = rf->rf_sc;
+	static const struct zyd_phy_pair phyini[] = ZYD_MAXIM_PHY;
+	static const uint32_t rfini[] = ZYD_MAXIM_RF;
+	uint16_t tmp;
+	int i, error;
+
+	/* init RF-dependent PHY registers */
+	for (i = 0; i < N(phyini); i++) {
+		error = zyd_write16(sc, phyini[i].reg, phyini[i].val);
+		if (error != 0)
+			return error;
+	}
+	(void)zyd_read16(sc, ZYD_CR203, &tmp);
+	(void)zyd_write16(sc, ZYD_CR203, tmp & ~(1 << 4));
+
+	/* init maxim radio */
+	for (i = 0; i < N(rfini); i++) {
+		if ((error = zyd_rfwrite(sc, rfini[i])) != 0)
+			return error;
+	}
+	(void)zyd_read16(sc, ZYD_CR203, &tmp);
+	(void)zyd_write16(sc, ZYD_CR203, tmp | (1 << 4));
+
+	return 0;
+#undef N
+}
+
+int
+zyd_maxim_switch_radio(struct zyd_rf *rf, int on)
+{
+	/* vendor driver does nothing for this RF chip */
+
+	return 0;
+}
+
+int
+zyd_maxim_set_channel(struct zyd_rf *rf, uint8_t chan)
+{
+#define N(a)	(sizeof (a) / sizeof ((a)[0]))
+	struct zyd_softc *sc = rf->rf_sc;
+	static const struct zyd_phy_pair phyini[] = ZYD_MAXIM_PHY;
+	static const uint32_t rfini[] = ZYD_MAXIM_RF;
+	static const uint32_t rfprog_f[] = ZYD_MAXIM_CHANTABLE_F;
+	static const uint32_t rfprog_n[] = ZYD_MAXIM_CHANTABLE_N;
+	uint16_t tmp;
+	int i, error;
+
+	/*
+	 * Do the same as we do when initializing it, except for the channel
+	 * values coming from the two channel tables.
+	 */
+
+	/* init RF-dependent PHY registers */
+	for (i = 0; i < N(phyini); i++) {
+		error = zyd_write16(sc, phyini[i].reg, phyini[i].val);
+		if (error != 0)
+			return error;
+	}
+	(void)zyd_read16(sc, ZYD_CR203, &tmp);
+	(void)zyd_write16(sc, ZYD_CR203, tmp & ~(1 << 4));
+
+	/* first two values taken from the chantables */
+	(void)zyd_rfwrite(sc, rfprog_f[chan - 1]);
+	(void)zyd_rfwrite(sc, rfprog_n[chan - 1]);
+
+	/* init maxim radio - skipping the two first values */
+	for (i = 2; i < N(rfini); i++) {
+		if ((error = zyd_rfwrite(sc, rfini[i])) != 0)
+			return error;
+	}
+	(void)zyd_read16(sc, ZYD_CR203, &tmp);
+	(void)zyd_write16(sc, ZYD_CR203, tmp | (1 << 4));
+
+	return 0;
+#undef N
+}
+
+/*
+ * Maxim2 RF methods.
+ */
+int
+zyd_maxim2_init(struct zyd_rf *rf)
+{
+#define N(a)	(sizeof (a) / sizeof ((a)[0]))
+	struct zyd_softc *sc = rf->rf_sc;
+	static const struct zyd_phy_pair phyini[] = ZYD_MAXIM2_PHY;
+	static const uint32_t rfini[] = ZYD_MAXIM2_RF;
+	uint16_t tmp;
+	int i, error;
+
+	/* init RF-dependent PHY registers */
+	for (i = 0; i < N(phyini); i++) {
+		error = zyd_write16(sc, phyini[i].reg, phyini[i].val);
+		if (error != 0)
+			return error;
+	}
+	(void)zyd_read16(sc, ZYD_CR203, &tmp);
+	(void)zyd_write16(sc, ZYD_CR203, tmp & ~(1 << 4));
+
+	/* init maxim2 radio */
+	for (i = 0; i < N(rfini); i++) {
+		if ((error = zyd_rfwrite(sc, rfini[i])) != 0)
+			return error;
+	}
+	(void)zyd_read16(sc, ZYD_CR203, &tmp);
+	(void)zyd_write16(sc, ZYD_CR203, tmp | (1 << 4));
+
+	return 0;
+#undef N
+}
+
+int
+zyd_maxim2_switch_radio(struct zyd_rf *rf, int on)
+{
+	/* vendor driver does nothing for this RF chip */
+
+	return 0;
+}
+
+int
+zyd_maxim2_set_channel(struct zyd_rf *rf, uint8_t chan)
+{
+#define N(a)	(sizeof (a) / sizeof ((a)[0]))
+	struct zyd_softc *sc = rf->rf_sc;
+	static const struct zyd_phy_pair phyini[] = ZYD_MAXIM2_PHY;
+	static const uint32_t rfini[] = ZYD_MAXIM2_RF;
+	static const uint32_t rfprog_f[] = ZYD_MAXIM2_CHANTABLE_F;
+	static const uint32_t rfprog_n[] = ZYD_MAXIM2_CHANTABLE_N;
+	uint16_t tmp;
+	int i, error;
+
+	/*
+	 * Do the same as we do when initializing it, except for the channel
+	 * values coming from the two channel tables.
+	 */
+
+	/* init RF-dependent PHY registers */
+	for (i = 0; i < N(phyini); i++) {
+		error = zyd_write16(sc, phyini[i].reg, phyini[i].val);
+		if (error != 0)
+			return error;
+	}
+	(void)zyd_read16(sc, ZYD_CR203, &tmp);
+	(void)zyd_write16(sc, ZYD_CR203, tmp & ~(1 << 4));
+
+	/* first two values taken from the chantables */
+	(void)zyd_rfwrite(sc, rfprog_f[chan - 1]);
+	(void)zyd_rfwrite(sc, rfprog_n[chan - 1]);
+
+	/* init maxim2 radio - skipping the two first values */
+	for (i = 2; i < N(rfini); i++) {
+		if ((error = zyd_rfwrite(sc, rfini[i])) != 0)
+			return error;
+	}
+	(void)zyd_read16(sc, ZYD_CR203, &tmp);
+	(void)zyd_write16(sc, ZYD_CR203, tmp | (1 << 4));
+
+	return 0;
+#undef N
+}
+
 int
 zyd_rf_attach(struct zyd_softc *sc, uint8_t type)
 {
@@ -1089,6 +1389,30 @@ zyd_rf_attach(struct zyd_softc *sc, uint8_t type)
 		rf->switch_radio = zyd_al7230B_switch_radio;
 		rf->set_channel  = zyd_al7230B_set_channel;
 		rf->width        = 24;	/* 24-bit RF values */
+	case ZYD_RF_AL2210:
+		rf->init         = zyd_al2210_init;
+		rf->switch_radio = zyd_al2210_switch_radio;
+		rf->set_channel  = zyd_al2210_set_channel;
+		rf->width        = 24;	/* 24-bit RF values */
+		break;
+	case ZYD_RF_GCT:
+		rf->init         = zyd_gct_init;
+		rf->switch_radio = zyd_gct_switch_radio;
+		rf->set_channel  = zyd_gct_set_channel;
+		rf->width        = 21;	/* 21-bit RF values */
+		break;
+	case ZYD_RF_MAXIM_NEW:
+		rf->init         = zyd_maxim_init;
+		rf->switch_radio = zyd_maxim_switch_radio;
+		rf->set_channel  = zyd_maxim_set_channel;
+		rf->width        = 18;	/* 18-bit RF values */
+		break;
+	case ZYD_RF_MAXIM_NEW2:
+		rf->init         = zyd_maxim2_init;
+		rf->switch_radio = zyd_maxim2_switch_radio;
+		rf->set_channel  = zyd_maxim2_set_channel;
+		rf->width        = 18;	/* 18-bit RF values */
+		break;
 	default:
 		printf("%s: sorry, radio \"%s\" is not supported yet\n",
 		    USBDEVNAME(sc->sc_dev), zyd_rf_name(type));
diff --git a/sys/dev/usb/if_zydreg.h b/sys/dev/usb/if_zydreg.h
index 365ba362602..91f01ac2f2e 100644
--- a/sys/dev/usb/if_zydreg.h
+++ b/sys/dev/usb/if_zydreg.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: if_zydreg.h,v 1.14 2006/11/03 19:34:56 damien Exp $	*/
+/*	$OpenBSD: if_zydreg.h,v 1.15 2006/11/16 19:43:53 damien Exp $	*/
 
 /*-
  * Copyright (c) 2006 by Damien Bergamini <damien.bergamini@free.fr>
@@ -143,20 +143,20 @@
 /*
  * RF IDs.
  */
-#define ZYD_RF_UW2451		0x2
-#define ZYD_RF_UCHIP		0x3
+#define ZYD_RF_UW2451		0x2	/* not supported yet */
+#define ZYD_RF_UCHIP		0x3	/* not supported yet */
 #define ZYD_RF_AL2230		0x4
 #define ZYD_RF_AL7230B		0x5
-#define ZYD_RF_THETA		0x6
+#define ZYD_RF_THETA		0x6	/* not supported yet */
 #define ZYD_RF_AL2210		0x7
 #define ZYD_RF_MAXIM_NEW	0x8
 #define ZYD_RF_GCT		0x9
-#define ZYD_RF_PV2000		0xa
-#define ZYD_RF_RALINK		0xb
-#define ZYD_RF_INTERSIL		0xc
+#define ZYD_RF_PV2000		0xa	/* not supported yet */
+#define ZYD_RF_RALINK		0xb	/* not supported yet */
+#define ZYD_RF_INTERSIL		0xc	/* not supported yet */
 #define ZYD_RF_RFMD		0xd
 #define ZYD_RF_MAXIM_NEW2	0xe
-#define ZYD_RF_PHILIPS		0xf
+#define ZYD_RF_PHILIPS		0xf	/* not supported yet */
 
 /*
  * PHY registers (8 bits, not documented).
@@ -671,6 +671,150 @@
 	{ 0x03ec00, 0x866660 }						\
 }
 
+#define ZYD_AL2210_PHY							\
+{									\
+	{ ZYD_CR9,   0xe0 }, { ZYD_CR10, 0x91 }, { ZYD_CR12,  0x90 },	\
+	{ ZYD_CR15,  0xd0 }, { ZYD_CR16, 0x40 }, { ZYD_CR17,  0x58 },	\
+	{ ZYD_CR18,  0x04 }, { ZYD_CR23, 0x66 }, { ZYD_CR24,  0x14 },	\
+	{ ZYD_CR26,  0x90 }, { ZYD_CR31, 0x80 }, { ZYD_CR34,  0x06 },	\
+	{ ZYD_CR35,  0x3e }, { ZYD_CR38, 0x38 }, { ZYD_CR46,  0x90 },	\
+	{ ZYD_CR47,  0x1e }, { ZYD_CR64, 0x64 }, { ZYD_CR79,  0xb5 },	\
+	{ ZYD_CR80,  0x38 }, { ZYD_CR81, 0x30 }, { ZYD_CR113, 0xc0 },	\
+	{ ZYD_CR127, 0x03 }						\
+}
+
+#define ZYD_AL2210_RF							\
+{									\
+	0x2396c0, 0x00fcb1, 0x358132, 0x0108b3, 0xc77804, 0x456415,	\
+	0xff2226, 0x806667, 0x7860f8, 0xbb01c9, 0x00000a, 0x00000b	\
+}
+
+#define ZYD_AL2210_CHANTABLE						\
+{									\
+	0x0196c0, 0x019710, 0x019760, 0x0197b0,	0x019800, 0x019850,	\
+	0x0198a0, 0x0198f0, 0x019940, 0x019990, 0x0199e0, 0x019a30,	\
+	0x019a80, 0x019b40 						\
+}
+
+#define ZYD_GCT_PHY							\
+{									\
+	{ ZYD_CR47,  0x1e }, { ZYD_CR15, 0xdc }, { ZYD_CR113, 0xc0 },	\
+	{ ZYD_CR20,  0x0c }, { ZYD_CR17, 0x65 }, { ZYD_CR34,  0x04 },	\
+	{ ZYD_CR35,  0x35 }, { ZYD_CR24, 0x20 }, { ZYD_CR9,   0xe0 },	\
+	{ ZYD_CR127, 0x02 }, { ZYD_CR10, 0x91 }, { ZYD_CR23,  0x7f },	\
+	{ ZYD_CR27,  0x10 }, { ZYD_CR28, 0x7a }, { ZYD_CR79,  0xb5 },	\
+	{ ZYD_CR64,  0x80 }, { ZYD_CR33, 0x28 }, { ZYD_CR38,  0x30 }	\
+}
+
+#define ZYD_GCT_RF							\
+{									\
+	0x1f0000, 0x1f0000, 0x1f0200, 0x1f0600, 0x1f8600, 0x1f8600,	\
+	0x002050, 0x1f8000, 0x1f8200, 0x1f8600, 0x1c0000, 0x10c458,	\
+	0x088e92, 0x187b82, 0x0401b4, 0x140816, 0x0c7000, 0x1c0000,	\
+	0x02ccae, 0x128023, 0x0a0000, 0x1a0000, 0x06e380, 0x16cb94,	\
+	0x0e1740, 0x014980, 0x116240, 0x090000, 0x192304, 0x05112f,	\
+	0x0d54a8, 0x0f8000, 0x1c0008, 0x1c0000, 0x1a0000, 0x1c0008,	\
+	0x150000, 0x0c7000, 0x150800, 0x150000				\
+}
+
+#define ZYD_GCT_CHANTABLE						\
+{									\
+	0x1a0000, 0x1a8000, 0x1a4000, 0x1ac000,	0x1a2000, 0x1aa000,	\
+	0x1a6000, 0x1ae000, 0x1a1000, 0x1a9000, 0x1a5000, 0x1ad000,	\
+	0x1a3000, 0x1ab000						\
+}
+
+#define ZYD_MAXIM_PHY							\
+{									\
+	{ ZYD_CR23,  0x40 }, { ZYD_CR15,  0x20 }, { ZYD_CR28,  0x3e },	\
+	{ ZYD_CR29,  0x00 }, { ZYD_CR26,  0x11 }, { ZYD_CR44,  0x33 },	\
+	{ ZYD_CR106, 0x2a }, { ZYD_CR107, 0x1a }, { ZYD_CR109, 0x2b },	\
+	{ ZYD_CR110, 0x2b }, { ZYD_CR111, 0x2b }, { ZYD_CR112, 0x2b },	\
+	{ ZYD_CR10,  0x89 }, { ZYD_CR17,  0x20 }, { ZYD_CR26,  0x93 },	\
+	{ ZYD_CR34,  0x30 }, { ZYD_CR35,  0x40 }, { ZYD_CR41,  0x24 },	\
+	{ ZYD_CR44,  0x32 }, { ZYD_CR46,  0x90 }, { ZYD_CR89,  0x18 },	\
+	{ ZYD_CR92,  0x0a }, { ZYD_CR101, 0x13 }, { ZYD_CR102, 0x27 },	\
+	{ ZYD_CR106, 0x20 }, { ZYD_CR107, 0x24 }, { ZYD_CR109, 0x09 },	\
+	{ ZYD_CR110, 0x13 }, { ZYD_CR111, 0x13 }, { ZYD_CR112, 0x13 },	\
+	{ ZYD_CR113, 0x27 }, { ZYD_CR114, 0x27 }, { ZYD_CR115, 0x24 },	\
+	{ ZYD_CR116, 0x24 }, { ZYD_CR117, 0xf4 }, { ZYD_CR118, 0xfa },	\
+	{ ZYD_CR120, 0x4f }, { ZYD_CR121, 0x77 }, { ZYD_CR122, 0xfe },	\
+	{ ZYD_CR10,  0x89 }, { ZYD_CR17,  0x20 }, { ZYD_CR26,  0x93 },	\
+	{ ZYD_CR34,  0x30 }, { ZYD_CR35,  0x40 }, { ZYD_CR41,  0x24 },	\
+	{ ZYD_CR44,  0x32 }, { ZYD_CR46,  0x90 }, { ZYD_CR89,  0x18 },	\
+	{ ZYD_CR92,  0x0a }, { ZYD_CR101, 0x13 }, { ZYD_CR102, 0x27 },	\
+	{ ZYD_CR106, 0x20 }, { ZYD_CR107, 0x24 }, { ZYD_CR109, 0x13 },	\
+	{ ZYD_CR110, 0x27 }, { ZYD_CR111, 0x27 }, { ZYD_CR112, 0x13 },	\
+	{ ZYD_CR113, 0x27 }, { ZYD_CR114, 0x27 }, { ZYD_CR115, 0x24 },	\
+	{ ZYD_CR116, 0x24 }, { ZYD_CR117, 0xf4 }, { ZYD_CR118, 0x00 },	\
+	{ ZYD_CR120, 0x4f }, { ZYD_CR121, 0x06 }, { ZYD_CR122, 0xfe },	\
+	{ ZYD_CR150, 0x0d }						\
+}
+
+#define ZYD_MAXIM_RF							\
+{									\
+	0x00ccd4, 0x030a03, 0x000400, 0x000ca1, 0x010072, 0x018645,	\
+	0x004006, 0x0000a7, 0x008258, 0x003fc9, 0x00040a, 0x00000b,	\
+	0x00026c							\
+}
+
+#define ZYD_MAXIM_CHANTABLE_F						\
+{									\
+	0x0ccd4, 0x22224, 0x37774, 0x0ccd4, 0x22224, 0x37774, 0x0ccd4,	\
+	0x22224, 0x37774, 0x0ccd4, 0x22224, 0x37774, 0x0ccd4, 0x199a4	\
+}
+
+#define ZYD_MAXIM_CHANTABLE_N						\
+{									\
+	0x30a03, 0x00a13, 0x10a13, 0x30a13, 0x00a23, 0x10a23, 0x30a23,	\
+	0x00a33, 0x10a33, 0x30a33, 0x00a43, 0x10a43, 0x30a43, 0x20a53	\
+}
+
+#define ZYD_MAXIM2_PHY							\
+{									\
+	{ ZYD_CR23,  0x40 }, { ZYD_CR15,  0x20 }, { ZYD_CR28,  0x3e },	\
+	{ ZYD_CR29,  0x00 }, { ZYD_CR26,  0x11 }, { ZYD_CR44,  0x33 },	\
+	{ ZYD_CR106, 0x2a }, { ZYD_CR107, 0x1a }, { ZYD_CR109, 0x2b },	\
+	{ ZYD_CR110, 0x2b }, { ZYD_CR111, 0x2b }, { ZYD_CR112, 0x2b },	\
+	{ ZYD_CR10,  0x89 }, { ZYD_CR17,  0x20 }, { ZYD_CR26,  0x93 },	\
+	{ ZYD_CR34,  0x30 }, { ZYD_CR35,  0x40 }, { ZYD_CR41,  0x24 },	\
+	{ ZYD_CR44,  0x32 }, { ZYD_CR46,  0x90 }, { ZYD_CR89,  0x18 },	\
+	{ ZYD_CR92,  0x0a }, { ZYD_CR101, 0x13 }, { ZYD_CR102, 0x27 },	\
+	{ ZYD_CR106, 0x20 }, { ZYD_CR107, 0x24 }, { ZYD_CR109, 0x09 },	\
+	{ ZYD_CR110, 0x13 }, { ZYD_CR111, 0x13 }, { ZYD_CR112, 0x13 },	\
+	{ ZYD_CR113, 0x27 }, { ZYD_CR114, 0x27 }, { ZYD_CR115, 0x24 },	\
+	{ ZYD_CR116, 0x24 }, { ZYD_CR117, 0xf4 }, { ZYD_CR118, 0xfa },	\
+	{ ZYD_CR120, 0x4f }, { ZYD_CR121, 0x77 }, { ZYD_CR122, 0xfe },	\
+	{ ZYD_CR10,  0x89 }, { ZYD_CR17,  0x20 }, { ZYD_CR26,  0x93 },	\
+	{ ZYD_CR34,  0x30 }, { ZYD_CR35,  0x40 }, { ZYD_CR41,  0x24 },	\
+	{ ZYD_CR44,  0x32 }, { ZYD_CR46,  0x90 }, { ZYD_CR79,  0x58 },	\
+	{ ZYD_CR80,  0x30 }, { ZYD_CR81,  0x30 }, { ZYD_CR89,  0x18 },	\
+	{ ZYD_CR92,  0x0a }, { ZYD_CR101, 0x13 }, { ZYD_CR102, 0x27 },	\
+	{ ZYD_CR106, 0x20 }, { ZYD_CR107, 0x24 }, { ZYD_CR109, 0x09 },	\
+	{ ZYD_CR110, 0x13 }, { ZYD_CR111, 0x13 }, { ZYD_CR112, 0x13 },	\
+	{ ZYD_CR113, 0x27 }, { ZYD_CR114, 0x27 }, { ZYD_CR115, 0x24 },	\
+	{ ZYD_CR116, 0x24 }, { ZYD_CR117, 0xf4 }, { ZYD_CR118, 0x00 },	\
+	{ ZYD_CR120, 0x4f }, { ZYD_CR121, 0x06 }, { ZYD_CR122, 0xfe }	\
+}
+
+#define ZYD_MAXIM2_RF							\
+{									\
+	0x33334, 0x10a03, 0x00400, 0x00ca1, 0x10072, 0x18645, 0x04006,	\
+	0x000a7, 0x08258, 0x03fc9, 0x0040a, 0x0000b, 0x0026c		\
+}
+
+#define ZYD_MAXIM2_CHANTABLE_F						\
+{									\
+	0x33334, 0x08884, 0x1ddd4, 0x33334, 0x08884, 0x1ddd4, 0x33334,	\
+	0x08884, 0x1ddd4, 0x33334, 0x08884, 0x1ddd4, 0x33334, 0x26664	\
+}
+
+#define ZYD_MAXIM2_CHANTABLE_N						\
+{									\
+	0x10a03, 0x20a13, 0x30a13, 0x10a13, 0x20a23, 0x30a23, 0x10a23,	\
+	0x20a33, 0x30a33, 0x10a33, 0x20a43, 0x30a43, 0x10a43, 0x20a53	\
+}
+
 /*
  * Control pipe requests.
  */