1// SPDX-License-Identifier: GPL-2.0-or-later
2/* ZD1211 USB-WLAN driver for Linux
3 *
4 * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
5 * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
6 */
7
8#include <linux/errno.h>
9#include <linux/string.h>
10
11#include "zd_def.h"
12#include "zd_rf.h"
13#include "zd_mac.h"
14#include "zd_chip.h"
15
16static const char * const rfs[] = {
17	[0]		= "unknown RF0",
18	[1]		= "unknown RF1",
19	[UW2451_RF]	= "UW2451_RF",
20	[UCHIP_RF]	= "UCHIP_RF",
21	[AL2230_RF]	= "AL2230_RF",
22	[AL7230B_RF]	= "AL7230B_RF",
23	[THETA_RF]	= "THETA_RF",
24	[AL2210_RF]	= "AL2210_RF",
25	[MAXIM_NEW_RF]	= "MAXIM_NEW_RF",
26	[UW2453_RF]	= "UW2453_RF",
27	[AL2230S_RF]	= "AL2230S_RF",
28	[RALINK_RF]	= "RALINK_RF",
29	[INTERSIL_RF]	= "INTERSIL_RF",
30	[RF2959_RF]	= "RF2959_RF",
31	[MAXIM_NEW2_RF]	= "MAXIM_NEW2_RF",
32	[PHILIPS_RF]	= "PHILIPS_RF",
33};
34
35const char *zd_rf_name(u8 type)
36{
37	if (type & 0xf0)
38		type = 0;
39	return rfs[type];
40}
41
42void zd_rf_init(struct zd_rf *rf)
43{
44	memset(rf, 0, sizeof(*rf));
45
46	/* default to update channel integration, as almost all RF's do want
47	 * this */
48	rf->update_channel_int = 1;
49}
50
51void zd_rf_clear(struct zd_rf *rf)
52{
53	if (rf->clear)
54		rf->clear(rf);
55	ZD_MEMCLEAR(rf, sizeof(*rf));
56}
57
58int zd_rf_init_hw(struct zd_rf *rf, u8 type)
59{
60	int r = 0;
61	int t;
62	struct zd_chip *chip = zd_rf_to_chip(rf);
63
64	ZD_ASSERT(mutex_is_locked(&chip->mutex));
65	switch (type) {
66	case RF2959_RF:
67		r = zd_rf_init_rf2959(rf);
68		break;
69	case AL2230_RF:
70	case AL2230S_RF:
71		r = zd_rf_init_al2230(rf);
72		break;
73	case AL7230B_RF:
74		r = zd_rf_init_al7230b(rf);
75		break;
76	case MAXIM_NEW_RF:
77	case UW2453_RF:
78		r = zd_rf_init_uw2453(rf);
79		break;
80	default:
81		dev_err(zd_chip_dev(chip),
82			"RF %s %#x is not supported\n", zd_rf_name(type), type);
83		rf->type = 0;
84		return -ENODEV;
85	}
86
87	if (r)
88		return r;
89
90	rf->type = type;
91
92	r = zd_chip_lock_phy_regs(chip);
93	if (r)
94		return r;
95	t = rf->init_hw(rf);
96	r = zd_chip_unlock_phy_regs(chip);
97	if (t)
98		r = t;
99	return r;
100}
101
102int zd_rf_scnprint_id(struct zd_rf *rf, char *buffer, size_t size)
103{
104	return scnprintf(buffer, size, "%s", zd_rf_name(rf->type));
105}
106
107int zd_rf_set_channel(struct zd_rf *rf, u8 channel)
108{
109	int r;
110
111	ZD_ASSERT(mutex_is_locked(&zd_rf_to_chip(rf)->mutex));
112	if (channel < MIN_CHANNEL24)
113		return -EINVAL;
114	if (channel > MAX_CHANNEL24)
115		return -EINVAL;
116	dev_dbg_f(zd_chip_dev(zd_rf_to_chip(rf)), "channel: %d\n", channel);
117
118	r = rf->set_channel(rf, channel);
119	if (r >= 0)
120		rf->channel = channel;
121	return r;
122}
123
124int zd_switch_radio_on(struct zd_rf *rf)
125{
126	int r, t;
127	struct zd_chip *chip = zd_rf_to_chip(rf);
128
129	ZD_ASSERT(mutex_is_locked(&chip->mutex));
130	r = zd_chip_lock_phy_regs(chip);
131	if (r)
132		return r;
133	t = rf->switch_radio_on(rf);
134	r = zd_chip_unlock_phy_regs(chip);
135	if (t)
136		r = t;
137	return r;
138}
139
140int zd_switch_radio_off(struct zd_rf *rf)
141{
142	int r, t;
143	struct zd_chip *chip = zd_rf_to_chip(rf);
144
145	/* TODO: move phy regs handling to zd_chip */
146	ZD_ASSERT(mutex_is_locked(&chip->mutex));
147	r = zd_chip_lock_phy_regs(chip);
148	if (r)
149		return r;
150	t = rf->switch_radio_off(rf);
151	r = zd_chip_unlock_phy_regs(chip);
152	if (t)
153		r = t;
154	return r;
155}
156
157int zd_rf_patch_6m_band_edge(struct zd_rf *rf, u8 channel)
158{
159	if (!rf->patch_6m_band_edge)
160		return 0;
161
162	return rf->patch_6m_band_edge(rf, channel);
163}
164
165int zd_rf_generic_patch_6m(struct zd_rf *rf, u8 channel)
166{
167	return zd_chip_generic_patch_6m_band(zd_rf_to_chip(rf), channel);
168}
169
170