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