/* * cxgb3i_offload.c: Chelsio S3xx iscsi offloaded tcp connection management * * Copyright (C) 2003-2015 Chelsio Communications. All rights reserved. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the LICENSE file included in this * release for licensing terms and conditions. * * Written by: Dimitris Michailidis ([email protected]) * Karen Xie ([email protected]) */ #define pr_fmt(fmt) … #include <linux/module.h> #include <linux/moduleparam.h> #include <scsi/scsi_host.h> #include "common.h" #include "t3_cpl.h" #include "t3cdev.h" #include "cxgb3_defs.h" #include "cxgb3_ctl_defs.h" #include "cxgb3_offload.h" #include "firmware_exports.h" #include "cxgb3i.h" static unsigned int dbg_level; #include "../libcxgbi.h" #define DRV_MODULE_NAME … #define DRV_MODULE_DESC … #define DRV_MODULE_VERSION … #define DRV_MODULE_RELDATE … static char version[] = …; MODULE_AUTHOR(…) …; MODULE_DESCRIPTION(…); MODULE_VERSION(…); MODULE_LICENSE(…) …; module_param(dbg_level, uint, 0644); MODULE_PARM_DESC(…) …; static int cxgb3i_rcv_win = …; module_param(cxgb3i_rcv_win, int, 0644); MODULE_PARM_DESC(…) …; static int cxgb3i_snd_win = …; module_param(cxgb3i_snd_win, int, 0644); MODULE_PARM_DESC(…) …; static int cxgb3i_rx_credit_thres = …; module_param(cxgb3i_rx_credit_thres, int, 0644); MODULE_PARM_DESC(…) …; static unsigned int cxgb3i_max_connect = …; module_param(cxgb3i_max_connect, uint, 0644); MODULE_PARM_DESC(…) …; static unsigned int cxgb3i_sport_base = …; module_param(cxgb3i_sport_base, uint, 0644); MODULE_PARM_DESC(…) …; static void cxgb3i_dev_open(struct t3cdev *); static void cxgb3i_dev_close(struct t3cdev *); static void cxgb3i_dev_event_handler(struct t3cdev *, u32, u32); static struct cxgb3_client t3_client = …; static const struct scsi_host_template cxgb3i_host_template = …; static struct iscsi_transport cxgb3i_iscsi_transport = …; static struct scsi_transport_template *cxgb3i_stt; /* * CPL (Chelsio Protocol Language) defines a message passing interface between * the host driver and Chelsio asic. * The section below implments CPLs that related to iscsi tcp connection * open/close/abort and data send/receive. */ static int push_tx_frames(struct cxgbi_sock *csk, int req_completion); static void send_act_open_req(struct cxgbi_sock *csk, struct sk_buff *skb, const struct l2t_entry *e) { … } static inline void act_open_arp_failure(struct t3cdev *dev, struct sk_buff *skb) { … } /* * CPL connection close request: host -> * * Close a connection by sending a CPL_CLOSE_CON_REQ message and queue it to * the write queue (i.e., after any unsent txt data). */ static void send_close_req(struct cxgbi_sock *csk) { … } /* * CPL connection abort request: host -> * * Send an ABORT_REQ message. Makes sure we do not send multiple ABORT_REQs * for the same connection and also that we do not try to send a message * after the connection has closed. */ static void abort_arp_failure(struct t3cdev *tdev, struct sk_buff *skb) { … } static void send_abort_req(struct cxgbi_sock *csk) { … } /* * CPL connection abort reply: host -> * * Send an ABORT_RPL message in response of the ABORT_REQ received. */ static void send_abort_rpl(struct cxgbi_sock *csk, int rst_status) { … } /* * CPL connection rx data ack: host -> * Send RX credits through an RX_DATA_ACK CPL message. Returns the number of * credits sent. */ static u32 send_rx_credits(struct cxgbi_sock *csk, u32 credits) { … } /* * CPL connection tx data: host -> * * Send iscsi PDU via TX_DATA CPL message. Returns the number of * credits sent. * Each TX_DATA consumes work request credit (wrs), so we need to keep track of * how many we've used so far and how many are pending (i.e., yet ack'ed by T3). */ static unsigned int wrlen __read_mostly; static unsigned int skb_wrs[SKB_WR_LIST_SIZE] __read_mostly; static void init_wr_tab(unsigned int wr_len) { … } static inline void make_tx_data_wr(struct cxgbi_sock *csk, struct sk_buff *skb, int len, int req_completion) { … } /* * push_tx_frames -- start transmit * * Prepends TX_DATA_WR or CPL_CLOSE_CON_REQ headers to buffers waiting in a * connection's send queue and sends them on to T3. Must be called with the * connection's lock held. Returns the amount of send buffer space that was * freed as a result of sending queued data to T3. */ static void arp_failure_skb_discard(struct t3cdev *dev, struct sk_buff *skb) { … } static int push_tx_frames(struct cxgbi_sock *csk, int req_completion) { … } /* * Process a CPL_ACT_ESTABLISH message: -> host * Updates connection state from an active establish CPL message. Runs with * the connection lock held. */ static inline void free_atid(struct cxgbi_sock *csk) { … } static int do_act_establish(struct t3cdev *tdev, struct sk_buff *skb, void *ctx) { … } /* * Process a CPL_ACT_OPEN_RPL message: -> host * Handle active open failures. */ static int act_open_rpl_status_to_errno(int status) { … } static void act_open_retry_timer(struct timer_list *t) { … } static int do_act_open_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx) { … } /* * Process PEER_CLOSE CPL messages: -> host * Handle peer FIN. */ static int do_peer_close(struct t3cdev *cdev, struct sk_buff *skb, void *ctx) { … } /* * Process CLOSE_CONN_RPL CPL message: -> host * Process a peer ACK to our FIN. */ static int do_close_con_rpl(struct t3cdev *cdev, struct sk_buff *skb, void *ctx) { … } /* * Process ABORT_REQ_RSS CPL message: -> host * Process abort requests. If we are waiting for an ABORT_RPL we ignore this * request except that we need to reply to it. */ static int abort_status_to_errno(struct cxgbi_sock *csk, int abort_reason, int *need_rst) { … } static int do_abort_req(struct t3cdev *cdev, struct sk_buff *skb, void *ctx) { … } /* * Process ABORT_RPL_RSS CPL message: -> host * Process abort replies. We only process these messages if we anticipate * them as the coordination between SW and HW in this area is somewhat lacking * and sometimes we get ABORT_RPLs after we are done with the connection that * originated the ABORT_REQ. */ static int do_abort_rpl(struct t3cdev *cdev, struct sk_buff *skb, void *ctx) { … } /* * Process RX_ISCSI_HDR CPL message: -> host * Handle received PDUs, the payload could be DDP'ed. If not, the payload * follow after the bhs. */ static int do_iscsi_hdr(struct t3cdev *t3dev, struct sk_buff *skb, void *ctx) { … } /* * Process TX_DATA_ACK CPL messages: -> host * Process an acknowledgment of WR completion. Advance snd_una and send the * next batch of work requests from the write queue. */ static int do_wr_ack(struct t3cdev *cdev, struct sk_buff *skb, void *ctx) { … } /* * for each connection, pre-allocate skbs needed for close/abort requests. So * that we can service the request right away. */ static int alloc_cpls(struct cxgbi_sock *csk) { … } static void l2t_put(struct cxgbi_sock *csk) { … } /* * release_offload_resources - release offload resource * Release resources held by an offload connection (TID, L2T entry, etc.) */ static void release_offload_resources(struct cxgbi_sock *csk) { … } static void update_address(struct cxgbi_hba *chba) { … } static int init_act_open(struct cxgbi_sock *csk) { … } cxgb3_cpl_handler_func cxgb3i_cpl_handlers[NUM_CPL_CMDS] = …; /** * cxgb3i_ofld_init - allocate and initialize resources for each adapter found * @cdev: cxgbi adapter */ static int cxgb3i_ofld_init(struct cxgbi_device *cdev) { … } /* * functions to program the pagepod in h/w */ static inline void ulp_mem_io_set_hdr(struct sk_buff *skb, unsigned int addr) { … } static struct cxgbi_ppm *cdev2ppm(struct cxgbi_device *cdev) { … } static int ddp_set_map(struct cxgbi_ppm *ppm, struct cxgbi_sock *csk, struct cxgbi_task_tag_info *ttinfo) { … } static void ddp_clear_map(struct cxgbi_device *cdev, struct cxgbi_ppm *ppm, struct cxgbi_task_tag_info *ttinfo) { … } static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid, int pg_idx) { … } /** * ddp_setup_conn_digest - setup conn. digest setting * @csk: cxgb tcp socket * @tid: connection id * @hcrc: header digest enabled * @dcrc: data digest enabled * set up the iscsi digest settings for a connection identified by tid */ static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid, int hcrc, int dcrc) { … } /** * cxgb3i_ddp_init - initialize the cxgb3 adapter's ddp resource * @cdev: cxgb3i adapter * initialize the ddp pagepod manager for a given adapter */ static int cxgb3i_ddp_init(struct cxgbi_device *cdev) { … } static void cxgb3i_dev_close(struct t3cdev *t3dev) { … } /** * cxgb3i_dev_open - init a t3 adapter structure and any h/w settings * @t3dev: t3cdev adapter */ static void cxgb3i_dev_open(struct t3cdev *t3dev) { … } static void cxgb3i_dev_event_handler(struct t3cdev *t3dev, u32 event, u32 port) { … } /** * cxgb3i_init_module - module init entry point * * initialize any driver wide global data structures and register itself * with the cxgb3 module */ static int __init cxgb3i_init_module(void) { … } /** * cxgb3i_exit_module - module cleanup/exit entry point * * go through the driver hba list and for each hba, release any resource held. * and unregisters iscsi transport and the cxgb3 module */ static void __exit cxgb3i_exit_module(void) { … } module_init(…) …; module_exit(cxgb3i_exit_module);
Codebase Browser
linux