usb.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0-only
/*
 * NXP Wireless LAN device driver: USB specific handling
 *
 * Copyright 2011-2020 NXP
 */

#include "main.h"
#include "usb.h"

#define USB_VERSION …

static struct mwifiex_if_ops usb_ops;

static const struct usb_device_id mwifiex_usb_table[] = …;

MODULE_DEVICE_TABLE(usb, mwifiex_usb_table);

static int mwifiex_usb_submit_rx_urb(struct urb_context *ctx, int size);

/* This function handles received packet. Necessary action is taken based on
 * cmd/event/data.
 */
static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
			    struct sk_buff *skb, u8 ep)
{ … }

static void mwifiex_usb_rx_complete(struct urb *urb)
{ … }

static void mwifiex_usb_tx_complete(struct urb *urb)
{ … }

static int mwifiex_usb_submit_rx_urb(struct urb_context *ctx, int size)
{ … }

static void mwifiex_usb_free(struct usb_card_rec *card)
{ … }

/* This function probes an mwifiex device and registers it. It allocates
 * the card structure, initiates the device registration and initialization
 * procedure by adding a logical interface.
 */
static int mwifiex_usb_probe(struct usb_interface *intf,
			     const struct usb_device_id *id)
{ … }

/* Kernel needs to suspend all functions separately. Therefore all
 * registered functions must have drivers with suspend and resume
 * methods. Failing that the kernel simply removes the whole card.
 *
 * If already not suspended, this function allocates and sends a
 * 'host sleep activate' request to the firmware and turns off the traffic.
 */
static int mwifiex_usb_suspend(struct usb_interface *intf, pm_message_t message)
{ … }

/* Kernel needs to suspend all functions separately. Therefore all
 * registered functions must have drivers with suspend and resume
 * methods. Failing that the kernel simply removes the whole card.
 *
 * If already not resumed, this function turns on the traffic and
 * sends a 'host sleep cancel' request to the firmware.
 */
static int mwifiex_usb_resume(struct usb_interface *intf)
{ … }

static void mwifiex_usb_disconnect(struct usb_interface *intf)
{ … }

static void mwifiex_usb_coredump(struct device *dev)
{ … }

static struct usb_driver mwifiex_usb_driver = …;

static int mwifiex_write_data_sync(struct mwifiex_adapter *adapter, u8 *pbuf,
				   u32 *len, u8 ep, u32 timeout)
{ … }

static int mwifiex_read_data_sync(struct mwifiex_adapter *adapter, u8 *pbuf,
				  u32 *len, u8 ep, u32 timeout)
{ … }

static void mwifiex_usb_port_resync(struct mwifiex_adapter *adapter)
{ … }

static bool mwifiex_usb_is_port_ready(struct mwifiex_private *priv)
{ … }

static inline u8 mwifiex_usb_data_sent(struct mwifiex_adapter *adapter)
{ … }

static int mwifiex_usb_construct_send_urb(struct mwifiex_adapter *adapter,
					  struct usb_tx_data_port *port, u8 ep,
					  struct urb_context *context,
					  struct sk_buff *skb_send)
{ … }

static int mwifiex_usb_prepare_tx_aggr_skb(struct mwifiex_adapter *adapter,
					   struct usb_tx_data_port *port,
					   struct sk_buff **skb_send)
{ … }

/* This function prepare data packet to be send under usb tx aggregation
 * protocol, check current usb aggregation status, link packet to aggrgation
 * list if possible, work flow as below:
 * (1) if only 1 packet available, add usb tx aggregation header and send.
 * (2) if packet is able to aggregated, link it to current aggregation list.
 * (3) if packet is not able to aggregated, aggregate and send exist packets
 *     in aggrgation list. Then, link packet in the list if there is more
 *     packet in transmit queue, otherwise try to transmit single packet.
 */
static int mwifiex_usb_aggr_tx_data(struct mwifiex_adapter *adapter, u8 ep,
				    struct sk_buff *skb,
				    struct mwifiex_tx_param *tx_param,
				    struct usb_tx_data_port *port)
{ … }

static void mwifiex_usb_tx_aggr_tmo(struct timer_list *t)
{ … }

/* This function write a command/data packet to card. */
static int mwifiex_usb_host_to_card(struct mwifiex_adapter *adapter, u8 ep,
				    struct sk_buff *skb,
				    struct mwifiex_tx_param *tx_param)
{ … }

static int mwifiex_usb_tx_init(struct mwifiex_adapter *adapter)
{ … }

static int mwifiex_usb_rx_init(struct mwifiex_adapter *adapter)
{ … }

/* This function register usb device and initialize parameter. */
static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
{ … }

static void mwifiex_usb_cleanup_tx_aggr(struct mwifiex_adapter *adapter)
{ … }

static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
{ … }

static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
				    struct mwifiex_fw_image *fw)
{ … }

static int mwifiex_usb_dnld_fw(struct mwifiex_adapter *adapter,
			struct mwifiex_fw_image *fw)
{ … }

static void mwifiex_submit_rx_urb(struct mwifiex_adapter *adapter, u8 ep)
{ … }

static int mwifiex_usb_cmd_event_complete(struct mwifiex_adapter *adapter,
				       struct sk_buff *skb)
{ … }

/* This function wakes up the card. */
static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
{ … }

static void mwifiex_usb_submit_rem_rx_urbs(struct mwifiex_adapter *adapter)
{ … }

/* This function is called after the card has woken up. */
static inline int
mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
{ … }

static struct mwifiex_if_ops usb_ops = …;

module_usb_driver(…) …;

MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_VERSION(…);
MODULE_LICENSE(…) …;
MODULE_FIRMWARE(…);
MODULE_FIRMWARE(…);
MODULE_FIRMWARE(…);
MODULE_FIRMWARE(…);
linux/drivers/net/wireless/marvell/mwifiex/usb.c
