/* * This file is part of the Chelsio FCoE driver for Linux. * * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved. * * This software is available to you under a choice of one of two * licenses. You may choose to be licensed under the terms of the GNU * General Public License (GPL) Version 2, available from the file * COPYING in the main directory of this source tree, or the * OpenIB.org BSD license below: * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above * copyright notice, this list of conditions and the following * disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with the distribution. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include <linux/delay.h> #include <linux/jiffies.h> #include <linux/string.h> #include <scsi/scsi_device.h> #include <scsi/scsi_transport_fc.h> #include "csio_hw.h" #include "csio_lnode.h" #include "csio_rnode.h" #include "csio_mb.h" #include "csio_wr.h" #define csio_mb_is_host_owner(__owner) … /* MB Command/Response Helpers */ /* * csio_mb_fw_retval - FW return value from a mailbox response. * @mbp: Mailbox structure * */ enum fw_retval csio_mb_fw_retval(struct csio_mb *mbp) { … } /* * csio_mb_hello - FW HELLO command helper * @hw: The HW structure * @mbp: Mailbox structure * @m_mbox: Master mailbox number, if any. * @a_mbox: Mailbox number for asycn notifications. * @master: Device mastership. * @cbfn: Callback, if any. * */ void csio_mb_hello(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo, uint32_t m_mbox, uint32_t a_mbox, enum csio_dev_master master, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* * csio_mb_process_hello_rsp - FW HELLO response processing helper * @hw: The HW structure * @mbp: Mailbox structure * @retval: Mailbox return value from Firmware * @state: State that the function is in. * @mpfn: Master pfn * */ void csio_mb_process_hello_rsp(struct csio_hw *hw, struct csio_mb *mbp, enum fw_retval *retval, enum csio_dev_state *state, uint8_t *mpfn) { … } /* * csio_mb_bye - FW BYE command helper * @hw: The HW structure * @mbp: Mailbox structure * @cbfn: Callback, if any. * */ void csio_mb_bye(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* * csio_mb_reset - FW RESET command helper * @hw: The HW structure * @mbp: Mailbox structure * @reset: Type of reset. * @cbfn: Callback, if any. * */ void csio_mb_reset(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo, int reset, int halt, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* * csio_mb_params - FW PARAMS command helper * @hw: The HW structure * @mbp: Mailbox structure * @tmo: Command timeout. * @pf: PF number. * @vf: VF number. * @nparams: Number of parameters * @params: Parameter mnemonic array. * @val: Parameter value array. * @wr: Write/Read PARAMS. * @cbfn: Callback, if any. * */ void csio_mb_params(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo, unsigned int pf, unsigned int vf, unsigned int nparams, const u32 *params, u32 *val, bool wr, void (*cbfn)(struct csio_hw *, struct csio_mb *)) { … } /* * csio_mb_process_read_params_rsp - FW PARAMS response processing helper * @hw: The HW structure * @mbp: Mailbox structure * @retval: Mailbox return value from Firmware * @nparams: Number of parameters * @val: Parameter value array. * */ void csio_mb_process_read_params_rsp(struct csio_hw *hw, struct csio_mb *mbp, enum fw_retval *retval, unsigned int nparams, u32 *val) { … } /* * csio_mb_ldst - FW LDST command * @hw: The HW structure * @mbp: Mailbox structure * @tmo: timeout * @reg: register * */ void csio_mb_ldst(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo, int reg) { … } /* * * csio_mb_caps_config - FW Read/Write Capabilities command helper * @hw: The HW structure * @mbp: Mailbox structure * @wr: Write if 1, Read if 0 * @init: Turn on initiator mode. * @tgt: Turn on target mode. * @cofld: If 1, Control Offload for FCoE * @cbfn: Callback, if any. * * This helper assumes that cmdp has MB payload from a previous CAPS * read command. */ void csio_mb_caps_config(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo, bool wr, bool init, bool tgt, bool cofld, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* * csio_mb_port- FW PORT command helper * @hw: The HW structure * @mbp: Mailbox structure * @tmo: COmmand timeout * @portid: Port ID to get/set info * @wr: Write/Read PORT information. * @fc: Flow control * @caps: Port capabilites to set. * @cbfn: Callback, if any. * */ void csio_mb_port(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo, u8 portid, bool wr, uint32_t fc, uint16_t fw_caps, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* * csio_mb_process_read_port_rsp - FW PORT command response processing helper * @hw: The HW structure * @mbp: Mailbox structure * @retval: Mailbox return value from Firmware * @caps: port capabilities * */ void csio_mb_process_read_port_rsp(struct csio_hw *hw, struct csio_mb *mbp, enum fw_retval *retval, uint16_t fw_caps, u32 *pcaps, u32 *acaps) { … } /* * csio_mb_initialize - FW INITIALIZE command helper * @hw: The HW structure * @mbp: Mailbox structure * @tmo: COmmand timeout * @cbfn: Callback, if any. * */ void csio_mb_initialize(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* * csio_mb_iq_alloc - Initializes the mailbox to allocate an * Ingress DMA queue in the firmware. * * @hw: The hw structure * @mbp: Mailbox structure to initialize * @priv: Private object * @mb_tmo: Mailbox time-out period (in ms). * @iq_params: Ingress queue params needed for allocation. * @cbfn: The call-back function * * */ static void csio_mb_iq_alloc(struct csio_hw *hw, struct csio_mb *mbp, void *priv, uint32_t mb_tmo, struct csio_iq_params *iq_params, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_mb_iq_alloc */ /* * csio_mb_iq_write - Initializes the mailbox for writing into an * Ingress DMA Queue. * * @hw: The HW structure * @mbp: Mailbox structure to initialize * @priv: Private object * @mb_tmo: Mailbox time-out period (in ms). * @cascaded_req: TRUE - if this request is cascased with iq-alloc request. * @iq_params: Ingress queue params needed for writing. * @cbfn: The call-back function * * NOTE: We OR relevant bits with cmdp->XXX, instead of just equating, * because this IQ write request can be cascaded with a previous * IQ alloc request, and we dont want to over-write the bits set by * that request. This logic will work even in a non-cascaded case, since the * cmdp structure is zeroed out by CSIO_INIT_MBP. */ static void csio_mb_iq_write(struct csio_hw *hw, struct csio_mb *mbp, void *priv, uint32_t mb_tmo, bool cascaded_req, struct csio_iq_params *iq_params, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_mb_iq_write */ /* * csio_mb_iq_alloc_write - Initializes the mailbox for allocating an * Ingress DMA Queue. * * @hw: The HW structure * @mbp: Mailbox structure to initialize * @priv: Private data. * @mb_tmo: Mailbox time-out period (in ms). * @iq_params: Ingress queue params needed for allocation & writing. * @cbfn: The call-back function * * */ void csio_mb_iq_alloc_write(struct csio_hw *hw, struct csio_mb *mbp, void *priv, uint32_t mb_tmo, struct csio_iq_params *iq_params, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_mb_iq_alloc_write */ /* * csio_mb_iq_alloc_write_rsp - Process the allocation & writing * of ingress DMA queue mailbox's response. * * @hw: The HW structure. * @mbp: Mailbox structure to initialize. * @retval: Firmware return value. * @iq_params: Ingress queue parameters, after allocation and write. * */ void csio_mb_iq_alloc_write_rsp(struct csio_hw *hw, struct csio_mb *mbp, enum fw_retval *ret_val, struct csio_iq_params *iq_params) { … } /* csio_mb_iq_alloc_write_rsp */ /* * csio_mb_iq_free - Initializes the mailbox for freeing a * specified Ingress DMA Queue. * * @hw: The HW structure * @mbp: Mailbox structure to initialize * @priv: Private data * @mb_tmo: Mailbox time-out period (in ms). * @iq_params: Parameters of ingress queue, that is to be freed. * @cbfn: The call-back function * * */ void csio_mb_iq_free(struct csio_hw *hw, struct csio_mb *mbp, void *priv, uint32_t mb_tmo, struct csio_iq_params *iq_params, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_mb_iq_free */ /* * csio_mb_eq_ofld_alloc - Initializes the mailbox for allocating * an offload-egress queue. * * @hw: The HW structure * @mbp: Mailbox structure to initialize * @priv: Private data * @mb_tmo: Mailbox time-out period (in ms). * @eq_ofld_params: (Offload) Egress queue parameters. * @cbfn: The call-back function * * */ static void csio_mb_eq_ofld_alloc(struct csio_hw *hw, struct csio_mb *mbp, void *priv, uint32_t mb_tmo, struct csio_eq_params *eq_ofld_params, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_mb_eq_ofld_alloc */ /* * csio_mb_eq_ofld_write - Initializes the mailbox for writing * an alloacted offload-egress queue. * * @hw: The HW structure * @mbp: Mailbox structure to initialize * @priv: Private data * @mb_tmo: Mailbox time-out period (in ms). * @cascaded_req: TRUE - if this request is cascased with Eq-alloc request. * @eq_ofld_params: (Offload) Egress queue parameters. * @cbfn: The call-back function * * * NOTE: We OR relevant bits with cmdp->XXX, instead of just equating, * because this EQ write request can be cascaded with a previous * EQ alloc request, and we dont want to over-write the bits set by * that request. This logic will work even in a non-cascaded case, since the * cmdp structure is zeroed out by CSIO_INIT_MBP. */ static void csio_mb_eq_ofld_write(struct csio_hw *hw, struct csio_mb *mbp, void *priv, uint32_t mb_tmo, bool cascaded_req, struct csio_eq_params *eq_ofld_params, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_mb_eq_ofld_write */ /* * csio_mb_eq_ofld_alloc_write - Initializes the mailbox for allocation * writing into an Engress DMA Queue. * * @hw: The HW structure * @mbp: Mailbox structure to initialize * @priv: Private data. * @mb_tmo: Mailbox time-out period (in ms). * @eq_ofld_params: (Offload) Egress queue parameters. * @cbfn: The call-back function * * */ void csio_mb_eq_ofld_alloc_write(struct csio_hw *hw, struct csio_mb *mbp, void *priv, uint32_t mb_tmo, struct csio_eq_params *eq_ofld_params, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_mb_eq_ofld_alloc_write */ /* * csio_mb_eq_ofld_alloc_write_rsp - Process the allocation * & write egress DMA queue mailbox's response. * * @hw: The HW structure. * @mbp: Mailbox structure to initialize. * @retval: Firmware return value. * @eq_ofld_params: (Offload) Egress queue parameters. * */ void csio_mb_eq_ofld_alloc_write_rsp(struct csio_hw *hw, struct csio_mb *mbp, enum fw_retval *ret_val, struct csio_eq_params *eq_ofld_params) { … } /* csio_mb_eq_ofld_alloc_write_rsp */ /* * csio_mb_eq_ofld_free - Initializes the mailbox for freeing a * specified Engress DMA Queue. * * @hw: The HW structure * @mbp: Mailbox structure to initialize * @priv: Private data area. * @mb_tmo: Mailbox time-out period (in ms). * @eq_ofld_params: (Offload) Egress queue parameters, that is to be freed. * @cbfn: The call-back function * * */ void csio_mb_eq_ofld_free(struct csio_hw *hw, struct csio_mb *mbp, void *priv, uint32_t mb_tmo, struct csio_eq_params *eq_ofld_params, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_mb_eq_ofld_free */ /* * csio_write_fcoe_link_cond_init_mb - Initialize Mailbox to write FCoE link * condition. * * @ln: The Lnode structure * @mbp: Mailbox structure to initialize * @mb_tmo: Mailbox time-out period (in ms). * @cbfn: The call back function. * * */ void csio_write_fcoe_link_cond_init_mb(struct csio_lnode *ln, struct csio_mb *mbp, uint32_t mb_tmo, uint8_t port_id, uint32_t sub_opcode, uint8_t cos, bool link_status, uint32_t fcfi, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_write_fcoe_link_cond_init_mb */ /* * csio_fcoe_read_res_info_init_mb - Initializes the mailbox for reading FCoE * resource information(FW_GET_RES_INFO_CMD). * * @hw: The HW structure * @mbp: Mailbox structure to initialize * @mb_tmo: Mailbox time-out period (in ms). * @cbfn: The call-back function * * */ void csio_fcoe_read_res_info_init_mb(struct csio_hw *hw, struct csio_mb *mbp, uint32_t mb_tmo, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_fcoe_read_res_info_init_mb */ /* * csio_fcoe_vnp_alloc_init_mb - Initializes the mailbox for allocating VNP * in the firmware (FW_FCOE_VNP_CMD). * * @ln: The Lnode structure. * @mbp: Mailbox structure to initialize. * @mb_tmo: Mailbox time-out period (in ms). * @fcfi: FCF Index. * @vnpi: vnpi * @iqid: iqid * @vnport_wwnn: vnport WWNN * @vnport_wwpn: vnport WWPN * @cbfn: The call-back function. * * */ void csio_fcoe_vnp_alloc_init_mb(struct csio_lnode *ln, struct csio_mb *mbp, uint32_t mb_tmo, uint32_t fcfi, uint32_t vnpi, uint16_t iqid, uint8_t vnport_wwnn[8], uint8_t vnport_wwpn[8], void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_fcoe_vnp_alloc_init_mb */ /* * csio_fcoe_vnp_read_init_mb - Prepares VNP read cmd. * @ln: The Lnode structure. * @mbp: Mailbox structure to initialize. * @mb_tmo: Mailbox time-out period (in ms). * @fcfi: FCF Index. * @vnpi: vnpi * @cbfn: The call-back handler. */ void csio_fcoe_vnp_read_init_mb(struct csio_lnode *ln, struct csio_mb *mbp, uint32_t mb_tmo, uint32_t fcfi, uint32_t vnpi, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* * csio_fcoe_vnp_free_init_mb - Initializes the mailbox for freeing an * alloacted VNP in the firmware (FW_FCOE_VNP_CMD). * * @ln: The Lnode structure. * @mbp: Mailbox structure to initialize. * @mb_tmo: Mailbox time-out period (in ms). * @fcfi: FCF flow id * @vnpi: VNP flow id * @cbfn: The call-back function. * Return: None */ void csio_fcoe_vnp_free_init_mb(struct csio_lnode *ln, struct csio_mb *mbp, uint32_t mb_tmo, uint32_t fcfi, uint32_t vnpi, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* * csio_fcoe_read_fcf_init_mb - Initializes the mailbox to read the * FCF records. * * @ln: The Lnode structure * @mbp: Mailbox structure to initialize * @mb_tmo: Mailbox time-out period (in ms). * @fcf_params: FC-Forwarder parameters. * @cbfn: The call-back function * * */ void csio_fcoe_read_fcf_init_mb(struct csio_lnode *ln, struct csio_mb *mbp, uint32_t mb_tmo, uint32_t portid, uint32_t fcfi, void (*cbfn) (struct csio_hw *, struct csio_mb *)) { … } /* csio_fcoe_read_fcf_init_mb */ void csio_fcoe_read_portparams_init_mb(struct csio_hw *hw, struct csio_mb *mbp, uint32_t mb_tmo, struct fw_fcoe_port_cmd_params *portparams, void (*cbfn)(struct csio_hw *, struct csio_mb *)) { … } /* csio_fcoe_read_portparams_init_mb */ void csio_mb_process_portparams_rsp(struct csio_hw *hw, struct csio_mb *mbp, enum fw_retval *retval, struct fw_fcoe_port_cmd_params *portparams, struct fw_fcoe_port_stats *portstats) { … } /* Entry points/APIs for MB module */ /* * csio_mb_intr_enable - Enable Interrupts from mailboxes. * @hw: The HW structure * * Enables CIM interrupt bit in appropriate INT_ENABLE registers. */ void csio_mb_intr_enable(struct csio_hw *hw) { … } /* * csio_mb_intr_disable - Disable Interrupts from mailboxes. * @hw: The HW structure * * Disable bit in HostInterruptEnable CIM register. */ void csio_mb_intr_disable(struct csio_hw *hw) { … } static void csio_mb_dump_fw_dbg(struct csio_hw *hw, __be64 *cmd) { … } static void csio_mb_debug_cmd_handler(struct csio_hw *hw) { … } /* * csio_mb_issue - generic routine for issuing Mailbox commands. * @hw: The HW structure * @mbp: Mailbox command to issue * * Caller should hold hw lock across this call. */ int csio_mb_issue(struct csio_hw *hw, struct csio_mb *mbp) { … } /* * csio_mb_completions - Completion handler for Mailbox commands * @hw: The HW structure * @cbfn_q: Completion queue. * */ void csio_mb_completions(struct csio_hw *hw, struct list_head *cbfn_q) { … } static void csio_mb_portmod_changed(struct csio_hw *hw, uint8_t port_id) { … } int csio_mb_fwevt_handler(struct csio_hw *hw, __be64 *cmd) { … } /* * csio_mb_isr_handler - Handle mailboxes related interrupts. * @hw: The HW structure * * Called from the ISR to handle Mailbox related interrupts. * HW Lock should be held across this call. */ int csio_mb_isr_handler(struct csio_hw *hw) { … } /* * csio_mb_tmo_handler - Timeout handler * @hw: The HW structure * */ struct csio_mb * csio_mb_tmo_handler(struct csio_hw *hw) { … } /* * csio_mb_cancel_all - Cancel all waiting commands. * @hw: The HW structure * @cbfn_q: The callback queue. * * Caller should hold hw lock across this call. */ void csio_mb_cancel_all(struct csio_hw *hw, struct list_head *cbfn_q) { … } /* * csio_mbm_init - Initialize Mailbox module * @mbm: Mailbox module * @hw: The HW structure * @timer: Timing function for interrupting mailboxes * * Initialize timer and the request/response queues. */ int csio_mbm_init(struct csio_mbm *mbm, struct csio_hw *hw, void (*timer_fn)(struct timer_list *)) { … } /* * csio_mbm_exit - Uninitialize mailbox module * @mbm: Mailbox module * * Stop timer. */ void csio_mbm_exit(struct csio_mbm *mbm) { … }
Codebase Browser
linux