linux/drivers/net/wireless/ralink/rt2x00/rt2800usb.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
	Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
	Copyright (C) 2009 - 2010 Ivo van Doorn <[email protected]>
	Copyright (C) 2009 Mattias Nissler <[email protected]>
	Copyright (C) 2009 Felix Fietkau <[email protected]>
	Copyright (C) 2009 Xose Vazquez Perez <[email protected]>
	Copyright (C) 2009 Axel Kollhofer <[email protected]>
	<http://rt2x00.serialmonkey.com>

 */

/*
	Module: rt2800usb
	Abstract: rt2800usb device specific routines.
	Supported chipsets: RT2800U.
 */

#include <linux/delay.h>
#include <linux/etherdevice.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/usb.h>

#include "rt2x00.h"
#include "rt2x00usb.h"
#include "rt2800lib.h"
#include "rt2800.h"
#include "rt2800usb.h"

/*
 * Allow hardware encryption to be disabled.
 */
static bool modparam_nohwcrypt;
module_param_named(nohwcrypt, modparam_nohwcrypt, bool, 0444);
MODULE_PARM_DESC(…) …;

static bool rt2800usb_hwcrypt_disabled(struct rt2x00_dev *rt2x00dev)
{ … }

/*
 * Queue handlers.
 */
static void rt2800usb_start_queue(struct data_queue *queue)
{ … }

static void rt2800usb_stop_queue(struct data_queue *queue)
{ … }

#define TXSTATUS_READ_INTERVAL …

static bool rt2800usb_tx_sta_fifo_read_completed(struct rt2x00_dev *rt2x00dev,
						 int urb_status, u32 tx_status)
{ … }

static void rt2800usb_async_read_tx_status(struct rt2x00_dev *rt2x00dev)
{ … }

static void rt2800usb_tx_dma_done(struct queue_entry *entry)
{ … }

static enum hrtimer_restart rt2800usb_tx_sta_fifo_timeout(struct hrtimer *timer)
{ … }

/*
 * Firmware functions
 */
static int rt2800usb_autorun_detect(struct rt2x00_dev *rt2x00dev)
{ … }

static char *rt2800usb_get_firmware_name(struct rt2x00_dev *rt2x00dev)
{ … }

static int rt2800usb_write_firmware(struct rt2x00_dev *rt2x00dev,
				    const u8 *data, const size_t len)
{ … }

/*
 * Device state switch handlers.
 */
static int rt2800usb_init_registers(struct rt2x00_dev *rt2x00dev)
{ … }

static int rt2800usb_enable_radio(struct rt2x00_dev *rt2x00dev)
{ … }

static void rt2800usb_disable_radio(struct rt2x00_dev *rt2x00dev)
{ … }

static int rt2800usb_set_state(struct rt2x00_dev *rt2x00dev,
			       enum dev_state state)
{ … }

static int rt2800usb_set_device_state(struct rt2x00_dev *rt2x00dev,
				      enum dev_state state)
{ … }

static unsigned int rt2800usb_get_dma_done(struct data_queue *queue)
{ … }

/*
 * TX descriptor initialization
 */
static __le32 *rt2800usb_get_txwi(struct queue_entry *entry)
{ … }

static void rt2800usb_write_tx_desc(struct queue_entry *entry,
				    struct txentry_desc *txdesc)
{ … }

/*
 * TX data initialization
 */
static int rt2800usb_get_tx_data_len(struct queue_entry *entry)
{ … }

/*
 * TX control handlers
 */
static void rt2800usb_work_txdone(struct work_struct *work)
{ … }

/*
 * RX control handlers
 */
static void rt2800usb_fill_rxdone(struct queue_entry *entry,
				  struct rxdone_entry_desc *rxdesc)
{ … }

/*
 * Device probe functions.
 */
static int rt2800usb_efuse_detect(struct rt2x00_dev *rt2x00dev)
{ … }

static int rt2800usb_read_eeprom(struct rt2x00_dev *rt2x00dev)
{ … }

static int rt2800usb_probe_hw(struct rt2x00_dev *rt2x00dev)
{ … }

static const struct ieee80211_ops rt2800usb_mac80211_ops = …;

static const struct rt2800_ops rt2800usb_rt2800_ops = …;

static const struct rt2x00lib_ops rt2800usb_rt2x00_ops = …;

static void rt2800usb_queue_init(struct data_queue *queue)
{ … }

static const struct rt2x00_ops rt2800usb_ops = …;

/*
 * rt2800usb module information.
 */
static const struct usb_device_id rt2800usb_device_table[] = …;

MODULE_AUTHOR(…);
MODULE_VERSION(…);
MODULE_DESCRIPTION(…) …;
MODULE_DEVICE_TABLE(usb, rt2800usb_device_table);
MODULE_FIRMWARE(…);
MODULE_LICENSE(…) …;

static int rt2800usb_probe(struct usb_interface *usb_intf,
			   const struct usb_device_id *id)
{ … }

static struct usb_driver rt2800usb_driver = …;

module_usb_driver(…) …;