On Thu, 2014-01-30 at 21:25 +0530, Jahnavi wrote: > From: Jahnavi Meher <jahnavi.meher@xxxxxxxxxxxxxxxxxx> > > This patch has the loading of firmware, SDbus related functions > and the module initialization related functions. > > Signed-off-by: Jahnavi Meher <jahnavi.meher@xxxxxxxxxxxxxxxxxx> > --- > > Makefile | 9 > rsi_91x_dev_ops.c | 661 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ > rsi_91x_main.c | 94 +++++++ > 3 files changed, 764 insertions(+) > > diff -uprN a/drivers/net/wireless/rsi/91x/Makefile b/drivers/net/wireless/rsi/91x/Makefile > --- a/drivers/net/wireless/rsi/91x/Makefile 1970-01-01 05:30:00.000000000 +0530 > +++ b/drivers/net/wireless/rsi/91x/Makefile 2014-01-30 16:25:13.800523737 +0530 > @@ -0,0 +1,9 @@ > +ifeq ($(CONFIG_RSI_USB), y) > + ccflags-y =-DUSE_USB_INTF > +else > + ccflags-y =-DUSE_SDIO_INTF > +endif Like Johannes pointed out before, this isn't very nice. There should be three parts to your driver: 1) a common core that all bus types can use 2) USB bus specific code 3) SDIO bus specific code A great example of this kind of abstraction is the rt2x00 driver (drivers/net/wireless/rt2x00) which has both USB and PCI variants. Or even "libertas", though that's not a gold standard of anything. Then you have separate KConfig options for both USB and SDIO, and they can be either individually or *both* enabled at the same time, providing support for multiple bus types in the same kernel without requiring somebody to rebuild it. Dan > +ccflags-y += -Iinclude/ > +rsi_91x-y := rsi_91x_mac80211.o rsi_91x_mgmt.o rsi_91x_pkt.o \ > + rsi_91x_dev_ops.o rsi_91x_main.o > +obj-$(CONFIG_RSI_91x) := rsi_91x.o > diff -uprN a/drivers/net/wireless/rsi/91x/rsi_91x_dev_ops.c b/drivers/net/wireless/rsi/91x/rsi_91x_dev_ops.c > --- a/drivers/net/wireless/rsi/91x/rsi_91x_dev_ops.c 1970-01-01 05:30:00.000000000 +0530 > +++ b/drivers/net/wireless/rsi/91x/rsi_91x_dev_ops.c 2014-01-30 16:25:13.803524118 +0530 > @@ -0,0 +1,661 @@ > +/** > + * @file rsi_91x_dev_ops.c > + * @author > + * @version 1.0 > + * > + * @section LICENSE > + * Copyright (c) 2013 Redpine Signals Inc. > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR > + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN > + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF > + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + * > + * @section DESCRIPTION > + * > + * The file contains the initialization part of the SDBus driver and Loading of > + * the TA firmware. > + */ > + > +#include <linux/firmware.h> > +#include "../include/rsi_main.h" > +#include "../include/rsi_hw_intf.h" > +#include "../include/rsi_device_ops.h" > + > +static struct ta_metadata { > + unsigned char *name; > + unsigned int address; > +} metadata[] = { > + {"rsi_91x.fw", 0x00000000}, > +}; > + > +/** > + * This function prepares the skb. > + * > + * @param common Pointer to the driver private structure. > + * @param buffer Pointer to the packet data. > + * @param pkt_len Length of the packet. > + * @param extended_desc Extended descriptor. > + * @return Successfully created netbuf control block. > + */ > +static struct sk_buff *rsi_prepare_skb(struct rsi_common *common, > + unsigned char *buffer, > + unsigned int pkt_len, > + unsigned char extended_desc) > +{ > + struct ieee80211_tx_info *info; > + struct skb_info *rx_params; > + struct sk_buff *skb = NULL; > + unsigned char payload_offset; > + > + if (!pkt_len) { > + rsi_dbg(ERR_ZONE, "%s: Dummy pkt has come in\n", __func__); > + return NULL; > + } > + > + if (pkt_len > (RSI_RCV_BUFFER_LEN * 4)) { > + rsi_dbg(ERR_ZONE, "%s: Toooo big packet %d\n", __func__, > + pkt_len); > + pkt_len = RSI_RCV_BUFFER_LEN * 4; > + } > + > + if ((pkt_len < RSI_HEADER_SIZE) || (pkt_len < MIN_802_11_HDR_LEN)) { > + rsi_dbg(ERR_ZONE, "%s: Too small packet %d\n", __func__, > + pkt_len); > + } > + > + pkt_len -= extended_desc; > + skb = dev_alloc_skb(pkt_len + FRAME_DESC_SZ); > + if (skb == NULL) > + return NULL; > + > + payload_offset = (extended_desc + FRAME_DESC_SZ); > + skb_put(skb, pkt_len); > + memcpy((skb->data), (buffer + payload_offset), skb->len); > + > + info = IEEE80211_SKB_CB(skb); > + rx_params = (struct skb_info *)info->driver_data; > + rx_params->rssi = rsi_get_rssi(buffer); > + rx_params->channel = rsi_get_connected_channel(common->priv); > + > + return skb; > +} > + > +/** > + * This function read frames from the SD card. > + * > + * @param common Pointer to the driver private structure. > + * @return 0 on success, -1 on failure. > + */ > +static int rsi_read_pkt(struct rsi_common *common) > +{ > +#ifdef USE_SDIO_INTF > + struct rsi_hw *adapter = common->priv; > + struct rsi_common_ops *common_ops = common->common_ops; > + unsigned char num_blks = 0; > + unsigned int rcv_pkt_len = 0; > + int status = 0; > +#endif > + unsigned char *frame_desc = NULL; > + unsigned int index, length = 0; > + unsigned short actual_length = 0, offset; > + struct sk_buff *skb = NULL; > + unsigned int queueno; > + unsigned char extended_desc; > + > +#ifdef USE_SDIO_INTF > + status = common_ops->read_register(adapter, > + SDIO_RX_NUM_BLOCKS_REG, > + &num_blks); > + > + if (status) { > + rsi_dbg(ERR_ZONE, > + "%s: Failed to read pkt length from the card:\n", > + __func__); > + return status; > + } > + rcv_pkt_len = (num_blks * 256); > + > + common->rx_data_pkt = kmalloc(rcv_pkt_len, GFP_KERNEL); > + if (!common->rx_data_pkt) { > + rsi_dbg(ERR_ZONE, "%s: Failed in memory allocation\n", > + __func__); > + return -1; > + } > + > + status = common_ops->host_intf_read_pkt(adapter, > + common->rx_data_pkt, > + rcv_pkt_len); > + if (status) { > + rsi_dbg(ERR_ZONE, "%s: Failed to read packet from card\n", > + __func__); > + goto fail; > + } > +#endif > + index = 0; > + do { > + frame_desc = &common->rx_data_pkt[index]; > + actual_length = *(unsigned short *)&frame_desc[0]; > + offset = *(unsigned short *)&frame_desc[2]; > + > + queueno = rsi_get_queueno(frame_desc, offset); > + length = rsi_get_length(frame_desc, offset); > + extended_desc = rsi_get_extended_desc(frame_desc, offset); > + > + switch (queueno) { > + case RSI_WIFI_DATA_Q: > + skb = rsi_prepare_skb(common, > + (frame_desc + offset), > + length, > + extended_desc); > + if (skb == NULL) > + goto fail; > + > + rsi_indicate_pkt_to_os(common, skb); > + break; > + > + case RSI_WIFI_MGMT_Q: > + rsi_mgmt_pkt_recv(common, (frame_desc + offset)); > + break; > + > + default: > + rsi_dbg(ERR_ZONE, "%s: pkt from invalid queue: %d\n", > + __func__, queueno); > + common->common_ops->print(ERR_ZONE, > + common->rx_data_pkt, > + 200); > + goto fail; > + } > + > + index += actual_length; > +#ifdef USE_USB_INTF > + } while (0); > +#else > + rcv_pkt_len -= actual_length; > + } while (rcv_pkt_len); > + kfree(common->rx_data_pkt); > +#endif > + return 0; > +fail: > + kfree(common->rx_data_pkt); > + return -1; > +} > + > + > +#ifdef USE_SDIO_INTF > +/** > + * This function read and process the SDIO interrupts. > + * > + * @param common Pointer to the driver private structure. > + * @return None. > + */ > +void rsi_interrupt_handler(struct rsi_common *common) > +{ > + int status; > + enum SDIO_INTERRUPT_TYPE isr_type; > + unsigned char isr_status = 0; > + unsigned char fw_status = 0; > + struct rsi_common_ops *common_ops = common->common_ops; > + > + common->rx_info.sdio_int_counter++; > + > + do { > + mutex_lock(&common->tx_rxlock); > + status = common_ops->read_register(common->priv, > + RSI_FN1_INT_REGISTER, > + &isr_status); > + if (status) { > + rsi_dbg(ERR_ZONE, > + "%s: Failed to Read Intr Status Register\n", > + __func__); > + mutex_unlock(&common->tx_rxlock); > + return; > + } > + > + if (isr_status == 0) { > + common_ops->set_event(&common->tx_event); > + common->rx_info.sdio_intr_status_zero++; > + mutex_unlock(&common->tx_rxlock); > + return; > + } > + > + rsi_dbg(ISR_ZONE, "%s: Intr_status = %x %d %d\n", > + __func__, isr_status, (1 << MSDU_PKT_PENDING), > + (1 << FW_ASSERT_IND)); > + > + do { > + RSI_GET_SDIO_INTERRUPT_TYPE(isr_status, isr_type); > + > + switch (isr_type) { > + case BUFFER_AVAILABLE: > + common->rx_info.watch_bufferfull_count = 0; > + common->rx_info.buffer_full = false; > + common->rx_info.mgmt_buffer_full = false; > + common_ops->ack_interrupt(common->priv, > + (1 << PKT_BUFF_AVAILABLE)); > + common_ops->set_event((&common->tx_event)); > + rsi_dbg(ISR_ZONE, > + "%s: ==> BUFFER_AVILABLE <==\n", > + __func__); > + common->rx_info.buf_avilable_counter++; > + break; > + > + case FIRMWARE_ASSERT_IND: > + rsi_dbg(ERR_ZONE, > + "%s: ==> FIRMWARE Assert <==\n", > + __func__); > + status = common_ops->read_register(common->priv, > + SDIO_FW_STATUS_REG, > + &fw_status); > + if (status) { > + rsi_dbg(ERR_ZONE, > + "%s: Failed to read f/w reg\n", > + __func__); > + } else { > + rsi_dbg(ERR_ZONE, > + "%s: Firmware Status is 0x%x\n", > + __func__ , fw_status); > + common_ops->ack_interrupt(common->priv, > + (1 << FW_ASSERT_IND)); > + } > + > + common->fsm_state = FSM_CARD_NOT_READY; > + break; > + > + case MSDU_PACKET_PENDING: > + rsi_dbg(ISR_ZONE, "Pkt pending interrupt\n"); > + common->rx_info.total_sdio_msdu_pending_intr++; > + > + status = rsi_read_pkt(common); > + if (status) { > + rsi_dbg(ERR_ZONE, > + "%s: Failed to read pkt\n", > + __func__); > + mutex_unlock(&common->tx_rxlock); > + return; > + } > + break; > + default: > + common_ops->ack_interrupt(common->priv, > + isr_status); > + common->rx_info.total_sdio_unknown_intr++; > + isr_status = 0; > + rsi_dbg(ISR_ZONE, > + "Unknown Interrupt %x\n", > + isr_status); > + break; > + } > + isr_status ^= BIT(isr_type - 1); > + } while (isr_status); > + mutex_unlock(&common->tx_rxlock); > + } while (1); > + return; > +} > +EXPORT_SYMBOL(rsi_interrupt_handler); > +#endif > + > + > +#ifdef USE_SDIO_INTF > +/** > + * This function sets the AHB master access MS word in the SDIO slave registers. > + * > + * @param adapter Pointer to the adapter structure. > + * @param ms_word ms word need to be initialized. > + * @return status: 0 on success, -1 on failure. > + */ > +static int rsi_sdio_master_access_msword(struct rsi_hw *adapter, > + unsigned short ms_word) > +{ > + struct rsi_common *common = adapter->priv; > + struct rsi_common_ops *common_ops = common->common_ops; > + unsigned char byte; > + unsigned char reg_dmn = 0; > + int status = 0; > + > + byte = (unsigned char)(ms_word & 0x00FF); > + > + rsi_dbg(INIT_ZONE, > + "%s: MASTER_ACCESS_MSBYTE:0x%x\n", __func__, byte); > + > + status = common_ops->write_register(adapter, > + reg_dmn, > + SDIO_MASTER_ACCESS_MSBYTE, > + &byte); > + if (status) { > + rsi_dbg(ERR_ZONE, > + "%s: fail to access MASTER_ACCESS_MSBYTE\n", > + __func__); > + return -1; > + } > + > + byte = (unsigned char)(ms_word >> 8); > + > + rsi_dbg(INIT_ZONE, "%s:MASTER_ACCESS_LSBYTE:0x%x\n", __func__, byte); > + status = common_ops->write_register(adapter, > + reg_dmn, > + SDIO_MASTER_ACCESS_LSBYTE, > + &byte); > + return status; > +} > +#endif > + > +/** > + * This function includes the actual funtionality of copying the TA firmware to the card. > + * Basically this function includes opening the TA file,reading the TA file and > + * writing their values in blocks of data. > + * > + * @param common Pointer to the driver private structure. > + * @param fw Pointer to the firmware value to be written. > + * @param len length of firmware file. > + * @param num_blocks Number of blocks to be written to the card. > + * @return 0 on success and -1 on failure. > + */ > +static int rsi_copy_to_card(struct rsi_common *common, > + const unsigned char *fw, > + unsigned int len, > + unsigned int num_blocks) > +{ > + struct rsi_hw *adapter = common->priv; > + unsigned int indx, ii; > + unsigned int block_size = adapter->tx_blk_size; > + struct rsi_common_ops *common_ops = common->common_ops; > + unsigned int lsb_address; > +#ifdef USE_SDIO_INTF > + unsigned int data[] = { TA_HOLD_THREAD_VALUE, TA_SOFT_RST_CLR, > + TA_PC_ZERO, TA_RELEASE_THREAD_VALUE }; > + unsigned int address[] = { TA_HOLD_THREAD_REG, TA_SOFT_RESET_REG, > + TA_TH0_PC_REG, TA_RELEASE_THREAD_REG }; > +#endif > + unsigned int base_address; > + unsigned short msb_address; > + > + base_address = metadata[0].address; > + msb_address = base_address >> 16; > + > + for (indx = 0, ii = 0; ii < num_blocks; ii++, indx += block_size) { > + lsb_address = base_address; > +#ifdef USE_SDIO_INTF > + lsb_address = ((unsigned short) base_address | > + RSI_SD_REQUEST_MASTER); > +#endif > + if (common_ops->load_firmware(adapter, > + lsb_address, > + (unsigned char *)(fw + indx), > + block_size)) { > + rsi_dbg(ERR_ZONE, > + "%s: Unable to load %s blk\n", __func__, > + metadata[0].name); > + return -1; > + } > + rsi_dbg(INIT_ZONE, "%s: loading %s block: %d\n", > + __func__, metadata[0].name, ii); > + base_address += block_size; > +#ifdef USE_SDIO_INTF > + if ((base_address >> 16) != msb_address) { > + msb_address += 1; > + if (rsi_sdio_master_access_msword(adapter, > + msb_address)) { > + rsi_dbg(ERR_ZONE, > + "%s: Unable to set ms word reg\n", > + __func__); > + return -1; > + } > + } > +#endif > + } > + > + if (len % block_size) { > + lsb_address = base_address; > +#ifdef USE_SDIO_INTF > + lsb_address |= ((unsigned short) base_address | > + RSI_SD_REQUEST_MASTER); > +#endif > + if (common_ops->load_firmware(adapter, > + lsb_address, > + (unsigned char *)(fw + indx), > + len % block_size)) { > + rsi_dbg(ERR_ZONE, > + "%s: Unable to load %s blk\n", __func__, > + metadata[0].name); > + return -1; > + } > + } > + rsi_dbg(INIT_ZONE, > + "%s: Succesfully loaded %s instructions\n", __func__, > + metadata[0].name); > + > +#ifdef USE_SDIO_INTF > + > + if (rsi_sdio_master_access_msword(adapter, 0x2200)) { > + rsi_dbg(ERR_ZONE, > + "%s: Unable to set ms word to common reg\n", > + __func__); > + return -1; > + } > + > + for (ii = 0; ii < ARRAY_SIZE(data); ii++) { > + /* Bringing TA out of reset */ > + if (common_ops->write_reg_multiple(adapter, > + (address[ii] | > + RSI_SD_REQUEST_MASTER), > + (unsigned char *)&data[ii], > + 4)) { > + rsi_dbg(ERR_ZONE, > + "%s: Unable to hold TA threads\n", __func__); > + return -1; > + } > + } > +#endif > + rsi_dbg(INIT_ZONE, "%s: loaded firmware\n", __func__); > + return 0; > +} > + > +/** > + * This function reads the firmware version from the firmware file. > + * > + * @param fw Pointer to the firmware data. > + * @param fw_ver Pointer to firmware version_info structure. > + * @return None > + */ > +static void rsi_fill_fw_ver(const unsigned char *fw, > + struct version_info *fw_ver) > +{ > + fw_ver->major = (fw[LMAC_VER_OFFSET] & 0xFF); > + fw_ver->minor = (fw[LMAC_VER_OFFSET + 1] & 0xFF); > + fw_ver->release_num = (fw[LMAC_VER_OFFSET + 2] & 0xFF); > + fw_ver->patch_num = (fw[LMAC_VER_OFFSET + 3] & 0xFF); > + fw_ver->info.fw_ver[0] = (fw[LMAC_VER_OFFSET + 4] & 0xFF); > + return; > +} > + > +/** > + * This function includes the actual funtionality of loading the TA firmware. > + * This function also includes opening the TA file,reading the TA file and > + * writing their values in blocks of data. > + * > + * @param common Pointer to the driver private structure. > + * @param fw_status Firmware status. > + * @return status: 0 on success, -1 on failure. > + */ > +static int rsi_load_ta_instructions(struct rsi_common *common, > + unsigned short fw_status) > +{ > + struct rsi_hw *adapter = common->priv; > + struct version_info *fw_ver = &common->fw_ver; > + unsigned int len; > + unsigned int num_blocks; > + const unsigned char *fw; > + const struct firmware *fw_entry = NULL; > + unsigned int block_size = adapter->tx_blk_size; > + int status = 0; > + > +#ifdef USE_SDIO_INTF > + unsigned int base_address; > + unsigned short msb_address; > + > + if (rsi_sdio_master_access_msword(adapter, 0x2200)) { > + rsi_dbg(ERR_ZONE, > + "%s: Unable to set ms word to common reg\n", > + __func__); > + return -1; > + } > + base_address = metadata[0].address; > + msb_address = (base_address >> 16); > + > + if (rsi_sdio_master_access_msword(adapter, msb_address)) { > + rsi_dbg(ERR_ZONE, > + "%s: Unable to set ms word reg\n", __func__); > + return -1; > + } > +#endif > + > + status = request_firmware(&fw_entry, metadata[0].name, adapter->device); > + if (status < 0) { > + rsi_dbg(ERR_ZONE, "%s Firmware file %s not found\n", > + __func__, metadata[0].name); > + return status; > + } > + > + fw = kmemdup(fw_entry->data, fw_entry->size, GFP_KERNEL); > + len = fw_entry->size; > + > +#ifdef USE_USB_INTF > + if (fw_status) { > +#endif > + rsi_fill_fw_ver(fw, fw_ver); > +#ifdef USE_USB_INTF > + return 0; > + } > +#endif > + > + if (len % 4) > + len += (4 - (len % 4)); > + > + num_blocks = (len / block_size); > + > + rsi_dbg(INIT_ZONE, "%s: Instruction size:%d\n", __func__, len); > + rsi_dbg(INIT_ZONE, "%s: num blocks: %d\n", __func__, num_blocks); > + > + status = rsi_copy_to_card(common, fw, len, num_blocks); > + release_firmware(fw_entry); > + return status; > +} > + > +/** > + * This function is a kernel thread to send the packets to the device. > + * > + * @param common Pointer to the driver private structure. > + * @return None. > + */ > +void rsi_tx_scheduler_thread(struct rsi_common *common) > +{ > + struct rsi_common_ops *common_ops = common->common_ops; > + > + do { > + if (common->rx_info.buffer_full) { > + common_ops->wait_queue_event(&common->tx_event, 2); > + rsi_dbg(INFO_ZONE, > + "%s: Event wait for 2ms\n", __func__); > + } else { > + common_ops->wait_queue_event(&common->tx_event, > + EVENT_WAIT_FOREVER); > + } > + common_ops->reset_event(&common->tx_event); > + > + if (common->init_done) > + common_ops->qos_processor(common); > + } while (atomic_read(&common->tx_thread_done) == 0); > + complete_and_exit(&common->tx_thread.completion, 0); > +} > +EXPORT_SYMBOL(rsi_tx_scheduler_thread); > + > +#ifdef USE_USB_INTF > +/** > + * This is a kernel thread to receive the packets from the USB device. > + * > + * @param common Pointer to the driver private structure. > + * @return None. > + */ > +void rsi_usb_rx_thread(struct rsi_common *common) > +{ > + struct rsi_common_ops *common_ops = common->common_ops; > + struct rsi_hw *adapter = common->priv; > + > + while (1) { > + common_ops->wait_queue_event(&common->rx_event, > + EVENT_WAIT_FOREVER); > + > + if (atomic_read(&common->rx_thread_done)) > + goto out; > + > + mutex_lock(&common->tx_rxlock); > + if (rsi_read_pkt(common)) { > + rsi_dbg(ERR_ZONE, "%s: Failed to read pkt\n", __func__); > + mutex_unlock(&common->tx_rxlock); > + goto out; > + } > + mutex_unlock(&common->tx_rxlock); > + common_ops->reset_event(&common->rx_event); > + if (common_ops->rx_urb_submit(adapter)) { > + rsi_dbg(ERR_ZONE, > + "%s: Failed in urb submission\n", __func__); > + goto out; > + } > + } > + > +out: > + rsi_dbg(INFO_ZONE, "%s: Terminated thread\n", __func__); > + atomic_inc(&common->rx_thread_done); > + complete_and_exit(&common->rx_thread.completion, 0); > + return; > +} > +EXPORT_SYMBOL(rsi_usb_rx_thread); > +#endif > + > +/** > + * This Function Initializes The HAL. > + * > + * @param common Pointer to the driver private structure. > + * @param fw_status Firmware status. > + * @return 0 on success, -1 on failure. > + */ > +int rsi_device_init(struct rsi_common *common, unsigned short fw_status) > +{ > + rsi_set_default_parameters(common); > + > + if (rsi_load_ta_instructions(common, fw_status)) > + return -1; > + > +#ifdef USE_SDIO_INTF > + if (rsi_sdio_master_access_msword(common->priv, 0x4105)) { > + rsi_dbg(ERR_ZONE, "%s: Unable to set ms word reg\n", > + __func__); > + return -1; > + } > + rsi_dbg(INIT_ZONE, > + "%s: Setting ms word to 0x41050000\n", __func__); > +#endif > + > + return 0; > +} > +EXPORT_SYMBOL(rsi_device_init); > + > +/** > + * This Function de-initializes The HAL. > + * > + * @param adapter Pointer to the adapter structure. > + * @return 0 on success. > + */ > +int rsi_device_deinit(struct rsi_hw *adapter) > +{ > + rsi_mac80211_detach(adapter); > + return 0; > +} > +EXPORT_SYMBOL(rsi_device_deinit); > diff -uprN a/drivers/net/wireless/rsi/91x/rsi_91x_main.c b/drivers/net/wireless/rsi/91x/rsi_91x_main.c > --- a/drivers/net/wireless/rsi/91x/rsi_91x_main.c 1970-01-01 05:30:00.000000000 +0530 > +++ b/drivers/net/wireless/rsi/91x/rsi_91x_main.c 2014-01-30 16:25:13.984547126 +0530 > @@ -0,0 +1,94 @@ > +/** > + * @file rsi_91x_main.c > + * @author > + * @version 1.0 > + * > + * @section LICENSE > + * Copyright (c) 2013 Redpine Signals Inc. > + * > + * Permission to use, copy, modify, and/or distribute this software for any > + * purpose with or without fee is hereby granted, provided that the above > + * copyright notice and this permission notice appear in all copies. > + * > + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES > + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF > + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR > + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES > + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN > + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF > + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. > + * > + * @section DESCRIPTION > + * > + * This file contians the code specific to file operations like creation, open, > + * reading/ writing to the files > + */ > + > +#include <linux/module.h> > +#include <linux/kernel.h> > +#include "../include/rsi_main.h" > +#include "../include/rsi_device_ops.h" > + > +unsigned int rsi_zone_enabled = /*INFO_ZONE | > + INIT_ZONE | > + MGMT_TX_ZONE | > + MGMT_RX_ZONE | > + DATA_TX_ZONE | > + DATA_RX_ZONE | > + FSM_ZONE | > + ISR_ZONE | */ > + ERR_ZONE | > + 0; > +EXPORT_SYMBOL(rsi_zone_enabled); > + > +/** > + * This function reads parameters of module connected. > + * > + * @param common Pointer to the driver private structure. > + * @return 0 on success, -1 on failure. > + */ > +int rsi_set_default_parameters(struct rsi_common *common) > +{ > + common->rftype = RSI_RF_8111; > + common->band = IEEE80211_BAND_2GHZ; > + common->channel_width = BW_20MHZ; > + common->rts_threshold = MAX_RTS_THRESHOLD; > + common->channel = 1; > + common->min_rate = 0xffff; > + common->fsm_state = FSM_CARD_NOT_READY; > + return 0; > +} > + > +/** > + * This function is invoked when the module is loaded into the kernel. > + * It registers the client driver. > + * > + * @param Void. > + * @return 0 on success, -1 on failure. > + */ > +static int rsi_91x_hal_module_init(void) > +{ > + rsi_dbg(INIT_ZONE, "%s: Module init called\n", __func__); > + return 0; > +} > + > +/** > + * This function is called at the time of removing/unloading the module. > + * It unregisters the client driver. > + * > + * @param Void. > + * @return None. > + */ > +static void rsi_91x_hal_module_exit(void) > +{ > + rsi_dbg(INIT_ZONE, "%s: Module exit called\n", __func__); > + return; > +} > + > +module_init(rsi_91x_hal_module_init); > +module_exit(rsi_91x_hal_module_exit); > +MODULE_AUTHOR("Redpine Signals Inc"); > +MODULE_DESCRIPTION("Station driver for RSI 91x driver"); > +MODULE_SUPPORTED_DEVICE("RSI-91x"); > +MODULE_VERSION("0.1"); > +MODULE_LICENSE("GPL"); > > > -- > To unsubscribe from this list: send the line "unsubscribe linux-wireless" in > the body of a message to majordomo@xxxxxxxxxxxxxxx > More majordomo info at http://vger.kernel.org/majordomo-info.html -- To unsubscribe from this list: send the line "unsubscribe linux-wireless" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html