drivers/scsi/cxgbi/libcxgbi.h

   1 /*
   2  * libcxgbi.h: Chelsio common library for T3/T4 iSCSI driver.
   3  *
   4  * Copyright (c) 2010 Chelsio Communications, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation.
   9  *
  10  * Written by: Karen Xie (kxie@chelsio.com)
  11  * Written by: Rakesh Ranjan (rranjan@chelsio.com)
  12  */
  13
  14 #ifndef __LIBCXGBI_H__
  15 #define __LIBCXGBI_H__
  16
  17 #include <linux/kernel.h>
  18 #include <linux/errno.h>
  19 #include <linux/types.h>
  20 #include <linux/debugfs.h>
  21 #include <linux/list.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/if_vlan.h>
  24 #include <linux/scatterlist.h>
  25 #include <linux/skbuff.h>
  26 #include <linux/vmalloc.h>
  27 #include <scsi/scsi_device.h>
  28 #include <scsi/libiscsi_tcp.h>
  29
  30 enum cxgbi_dbg_flag {
  31         CXGBI_DBG_ISCSI,
  32         CXGBI_DBG_DDP,
  33         CXGBI_DBG_TOE,
  34         CXGBI_DBG_SOCK,
  35
  36         CXGBI_DBG_PDU_TX,
  37         CXGBI_DBG_PDU_RX,
  38         CXGBI_DBG_DEV,
  39 };
  40
  41 #define log_debug(level, fmt, ...)      \
  42         do {    \
  43                 if (dbg_level & (level)) \
  44                         pr_info(fmt, ##__VA_ARGS__); \
  45         } while (0)
  46
  47 /* max. connections per adapter */
  48 #define CXGBI_MAX_CONN          16384
  49
  50 /* always allocate rooms for AHS */
  51 #define SKB_TX_ISCSI_PDU_HEADER_MAX     \
  52         (sizeof(struct iscsi_hdr) + ISCSI_MAX_AHS_SIZE)
  53
  54 #define ISCSI_PDU_NONPAYLOAD_LEN        312 /* bhs(48) + ahs(256) + digest(8)*/
  55
  56 /*
  57  * align pdu size to multiple of 512 for better performance
  58  */
  59 #define cxgbi_align_pdu_size(n) do { n = (n) & (~511); } while (0)
  60
  61 #define ULP2_MODE_ISCSI         2
  62
  63 #define ULP2_MAX_PKT_SIZE       16224
  64 #define ULP2_MAX_PDU_PAYLOAD    \
  65         (ULP2_MAX_PKT_SIZE - ISCSI_PDU_NONPAYLOAD_LEN)
  66
  67 /*
  68  * For iscsi connections HW may inserts digest bytes into the pdu. Those digest
  69  * bytes are not sent by the host but are part of the TCP payload and therefore
  70  * consume TCP sequence space.
  71  */
  72 static const unsigned int ulp2_extra_len[] = { 0, 4, 4, 8 };
  73 static inline unsigned int cxgbi_ulp_extra_len(int submode)
  74 {
  75         return ulp2_extra_len[submode & 3];
  76 }
  77
  78 /*
  79  * struct pagepod_hdr, pagepod - pagepod format
  80  */
  81
  82 #define CPL_RX_DDP_STATUS_DDP_SHIFT     16 /* ddp'able */
  83 #define CPL_RX_DDP_STATUS_PAD_SHIFT     19 /* pad error */
  84 #define CPL_RX_DDP_STATUS_HCRC_SHIFT    20 /* hcrc error */
  85 #define CPL_RX_DDP_STATUS_DCRC_SHIFT    21 /* dcrc error */
  86
  87 struct cxgbi_pagepod_hdr {
  88         u32 vld_tid;
  89         u32 pgsz_tag_clr;
  90         u32 max_offset;
  91         u32 page_offset;
  92         u64 rsvd;
  93 };
  94
  95 #define PPOD_PAGES_MAX                  4
  96 struct cxgbi_pagepod {
  97         struct cxgbi_pagepod_hdr hdr;
  98         u64 addr[PPOD_PAGES_MAX + 1];
  99 };
 100
 101 struct cxgbi_tag_format {
 102         unsigned char sw_bits;
 103         unsigned char rsvd_bits;
 104         unsigned char rsvd_shift;
 105         unsigned char filler[1];
 106         u32 rsvd_mask;
 107 };
 108
 109 struct cxgbi_gather_list {
 110         unsigned int tag;
 111         unsigned int length;
 112         unsigned int offset;
 113         unsigned int nelem;
 114         struct page **pages;
 115         dma_addr_t phys_addr[0];
 116 };
 117
 118 struct cxgbi_ddp_info {
 119         struct kref refcnt;
 120         struct cxgbi_device *cdev;
 121         struct pci_dev *pdev;
 122         unsigned int max_txsz;
 123         unsigned int max_rxsz;
 124         unsigned int llimit;
 125         unsigned int ulimit;
 126         unsigned int nppods;
 127         unsigned int idx_last;
 128         unsigned char idx_bits;
 129         unsigned char filler[3];
 130         unsigned int idx_mask;
 131         unsigned int rsvd_tag_mask;
 132         spinlock_t map_lock;
 133         struct cxgbi_gather_list **gl_map;
 134 };
 135
 136 #define DDP_PGIDX_MAX           4
 137 #define DDP_THRESHOLD           2048
 138
 139 #define PPOD_PAGES_SHIFT        2       /*  4 pages per pod */
 140
 141 #define PPOD_SIZE               sizeof(struct cxgbi_pagepod)  /*  64 */
 142 #define PPOD_SIZE_SHIFT         6
 143
 144 #define ULPMEM_DSGL_MAX_NPPODS  16      /*  1024/PPOD_SIZE */
 145 #define ULPMEM_IDATA_MAX_NPPODS 4       /*  256/PPOD_SIZE */
 146 #define PCIE_MEMWIN_MAX_NPPODS  16      /*  1024/PPOD_SIZE */
 147
 148 #define PPOD_COLOR_SHIFT        0
 149 #define PPOD_COLOR(x)           ((x) << PPOD_COLOR_SHIFT)
 150
 151 #define PPOD_IDX_SHIFT          6
 152 #define PPOD_IDX_MAX_SIZE       24
 153
 154 #define PPOD_TID_SHIFT          0
 155 #define PPOD_TID(x)             ((x) << PPOD_TID_SHIFT)
 156
 157 #define PPOD_TAG_SHIFT          6
 158 #define PPOD_TAG(x)             ((x) << PPOD_TAG_SHIFT)
 159
 160 #define PPOD_VALID_SHIFT        24
 161 #define PPOD_VALID(x)           ((x) << PPOD_VALID_SHIFT)
 162 #define PPOD_VALID_FLAG         PPOD_VALID(1U)
 163
 164 /*
 165  * sge_opaque_hdr -
 166  * Opaque version of structure the SGE stores at skb->head of TX_DATA packets
 167  * and for which we must reserve space.
 168  */
 169 struct sge_opaque_hdr {
 170         void *dev;
 171         dma_addr_t addr[MAX_SKB_FRAGS + 1];
 172 };
 173
 174 struct cxgbi_sock {
 175         struct cxgbi_device *cdev;
 176
 177         int tid;
 178         int atid;
 179         unsigned long flags;
 180         unsigned int mtu;
 181         unsigned short rss_qid;
 182         unsigned short txq_idx;
 183         unsigned short advmss;
 184         unsigned int tx_chan;
 185         unsigned int rx_chan;
 186         unsigned int mss_idx;
 187         unsigned int smac_idx;
 188         unsigned char port_id;
 189         int wr_max_cred;
 190         int wr_cred;
 191         int wr_una_cred;
 192         unsigned char hcrc_len;
 193         unsigned char dcrc_len;
 194
 195         void *l2t;
 196         struct sk_buff *wr_pending_head;
 197         struct sk_buff *wr_pending_tail;
 198         struct sk_buff *cpl_close;
 199         struct sk_buff *cpl_abort_req;
 200         struct sk_buff *cpl_abort_rpl;
 201         struct sk_buff *skb_ulp_lhdr;
 202         spinlock_t lock;
 203         struct kref refcnt;
 204         unsigned int state;
 205         struct sockaddr_in saddr;
 206         struct sockaddr_in daddr;
 207         struct dst_entry *dst;
 208         struct sk_buff_head receive_queue;
 209         struct sk_buff_head write_queue;
 210         struct timer_list retry_timer;
 211         int err;
 212         rwlock_t callback_lock;
 213         void *user_data;
 214
 215         u32 rcv_nxt;
 216         u32 copied_seq;
 217         u32 rcv_wup;
 218         u32 snd_nxt;
 219         u32 snd_una;
 220         u32 write_seq;
 221 };
 222
 223 /*
 224  * connection states
 225  */
 226 enum cxgbi_sock_states{
 227         CTP_CLOSED,
 228         CTP_CONNECTING,
 229         CTP_ACTIVE_OPEN,
 230         CTP_ESTABLISHED,
 231         CTP_ACTIVE_CLOSE,
 232         CTP_PASSIVE_CLOSE,
 233         CTP_CLOSE_WAIT_1,
 234         CTP_CLOSE_WAIT_2,
 235         CTP_ABORTING,
 236 };
 237
 238 /*
 239  * Connection flags -- many to track some close related events.
 240  */
 241 enum cxgbi_sock_flags {
 242         CTPF_ABORT_RPL_RCVD,    /*received one ABORT_RPL_RSS message */
 243         CTPF_ABORT_REQ_RCVD,    /*received one ABORT_REQ_RSS message */
 244         CTPF_ABORT_RPL_PENDING, /* expecting an abort reply */
 245         CTPF_TX_DATA_SENT,      /* already sent a TX_DATA WR */
 246         CTPF_ACTIVE_CLOSE_NEEDED,/* need to be closed */
 247         CTPF_HAS_ATID,          /* reserved atid */
 248         CTPF_HAS_TID,           /* reserved hw tid */
 249         CTPF_OFFLOAD_DOWN,      /* offload function off */
 250 };
 251
 252 struct cxgbi_skb_rx_cb {
 253         __u32 ddigest;
 254         __u32 pdulen;
 255 };
 256
 257 struct cxgbi_skb_tx_cb {
 258         void *l2t;
 259         struct sk_buff *wr_next;
 260 };
 261
 262 enum cxgbi_skcb_flags {
 263         SKCBF_TX_NEED_HDR,      /* packet needs a header */
 264         SKCBF_RX_COALESCED,     /* received whole pdu */
 265         SKCBF_RX_HDR,           /* received pdu header */
 266         SKCBF_RX_DATA,          /* received pdu payload */
 267         SKCBF_RX_STATUS,        /* received ddp status */
 268         SKCBF_RX_DATA_DDPD,     /* pdu payload ddp'd */
 269         SKCBF_RX_HCRC_ERR,      /* header digest error */
 270         SKCBF_RX_DCRC_ERR,      /* data digest error */
 271         SKCBF_RX_PAD_ERR,       /* padding byte error */
 272 };
 273
 274 struct cxgbi_skb_cb {
 275         unsigned char ulp_mode;
 276         unsigned long flags;
 277         unsigned int seq;
 278         union {
 279                 struct cxgbi_skb_rx_cb rx;
 280                 struct cxgbi_skb_tx_cb tx;
 281         };
 282 };
 283
 284 #define CXGBI_SKB_CB(skb)       ((struct cxgbi_skb_cb *)&((skb)->cb[0]))
 285 #define cxgbi_skcb_flags(skb)           (CXGBI_SKB_CB(skb)->flags)
 286 #define cxgbi_skcb_ulp_mode(skb)        (CXGBI_SKB_CB(skb)->ulp_mode)
 287 #define cxgbi_skcb_tcp_seq(skb)         (CXGBI_SKB_CB(skb)->seq)
 288 #define cxgbi_skcb_rx_ddigest(skb)      (CXGBI_SKB_CB(skb)->rx.ddigest)
 289 #define cxgbi_skcb_rx_pdulen(skb)       (CXGBI_SKB_CB(skb)->rx.pdulen)
 290 #define cxgbi_skcb_tx_wr_next(skb)      (CXGBI_SKB_CB(skb)->tx.wr_next)
 291
 292 static inline void cxgbi_skcb_set_flag(struct sk_buff *skb,
 293                                         enum cxgbi_skcb_flags flag)
 294 {
 295         __set_bit(flag, &(cxgbi_skcb_flags(skb)));
 296 }
 297
 298 static inline void cxgbi_skcb_clear_flag(struct sk_buff *skb,
 299                                         enum cxgbi_skcb_flags flag)
 300 {
 301         __clear_bit(flag, &(cxgbi_skcb_flags(skb)));
 302 }
 303
 304 static inline int cxgbi_skcb_test_flag(struct sk_buff *skb,
 305                                         enum cxgbi_skcb_flags flag)
 306 {
 307         return test_bit(flag, &(cxgbi_skcb_flags(skb)));
 308 }
 309
 310 static inline void cxgbi_sock_set_flag(struct cxgbi_sock *csk,
 311                                         enum cxgbi_sock_flags flag)
 312 {
 313         __set_bit(flag, &csk->flags);
 314         log_debug(1 << CXGBI_DBG_SOCK,
 315                 "csk 0x%p,%u,0x%lx, bit %d.\n",
 316                 csk, csk->state, csk->flags, flag);
 317 }
 318
 319 static inline void cxgbi_sock_clear_flag(struct cxgbi_sock *csk,
 320                                         enum cxgbi_sock_flags flag)
 321 {
 322         __clear_bit(flag, &csk->flags);
 323         log_debug(1 << CXGBI_DBG_SOCK,
 324                 "csk 0x%p,%u,0x%lx, bit %d.\n",
 325                 csk, csk->state, csk->flags, flag);
 326 }
 327
 328 static inline int cxgbi_sock_flag(struct cxgbi_sock *csk,
 329                                 enum cxgbi_sock_flags flag)
 330 {
 331         if (csk == NULL)
 332                 return 0;
 333         return test_bit(flag, &csk->flags);
 334 }
 335
 336 static inline void cxgbi_sock_set_state(struct cxgbi_sock *csk, int state)
 337 {
 338         log_debug(1 << CXGBI_DBG_SOCK,
 339                 "csk 0x%p,%u,0x%lx, state -> %u.\n",
 340                 csk, csk->state, csk->flags, state);
 341         csk->state = state;
 342 }
 343
 344 static inline void cxgbi_sock_free(struct kref *kref)
 345 {
 346         struct cxgbi_sock *csk = container_of(kref,
 347                                                 struct cxgbi_sock,
 348                                                 refcnt);
 349         if (csk) {
 350                 log_debug(1 << CXGBI_DBG_SOCK,
 351                         "free csk 0x%p, state %u, flags 0x%lx\n",
 352                         csk, csk->state, csk->flags);
 353                 kfree(csk);
 354         }
 355 }
 356
 357 static inline void __cxgbi_sock_put(const char *fn, struct cxgbi_sock *csk)
 358 {
 359         log_debug(1 << CXGBI_DBG_SOCK,
 360                 "%s, put csk 0x%p, ref %u-1.\n",
 361                 fn, csk, atomic_read(&csk->refcnt.refcount));
 362         kref_put(&csk->refcnt, cxgbi_sock_free);
 363 }
 364 #define cxgbi_sock_put(csk)     __cxgbi_sock_put(__func__, csk)
 365
 366 static inline void __cxgbi_sock_get(const char *fn, struct cxgbi_sock *csk)
 367 {
 368         log_debug(1 << CXGBI_DBG_SOCK,
 369                 "%s, get csk 0x%p, ref %u+1.\n",
 370                 fn, csk, atomic_read(&csk->refcnt.refcount));
 371         kref_get(&csk->refcnt);
 372 }
 373 #define cxgbi_sock_get(csk)     __cxgbi_sock_get(__func__, csk)
 374
 375 static inline int cxgbi_sock_is_closing(struct cxgbi_sock *csk)
 376 {
 377         return csk->state >= CTP_ACTIVE_CLOSE;
 378 }
 379
 380 static inline int cxgbi_sock_is_established(struct cxgbi_sock *csk)
 381 {
 382         return csk->state == CTP_ESTABLISHED;
 383 }
 384
 385 static inline void cxgbi_sock_purge_write_queue(struct cxgbi_sock *csk)
 386 {
 387         struct sk_buff *skb;
 388
 389         while ((skb = __skb_dequeue(&csk->write_queue)))
 390                 __kfree_skb(skb);
 391 }
 392
 393 static inline unsigned int cxgbi_sock_compute_wscale(unsigned int win)
 394 {
 395         unsigned int wscale = 0;
 396
 397         while (wscale < 14 && (65535 << wscale) < win)
 398                 wscale++;
 399         return wscale;
 400 }
 401
 402 static inline struct sk_buff *alloc_wr(int wrlen, int dlen, gfp_t gfp)
 403 {
 404         struct sk_buff *skb = alloc_skb(wrlen + dlen, gfp);
 405
 406         if (skb) {
 407                 __skb_put(skb, wrlen);
 408                 memset(skb->head, 0, wrlen + dlen);
 409         } else
 410                 pr_info("alloc cpl wr skb %u+%u, OOM.\n", wrlen, dlen);
 411         return skb;
 412 }
 413
 414
 415 /*
 416  * The number of WRs needed for an skb depends on the number of fragments
 417  * in the skb and whether it has any payload in its main body.  This maps the
 418  * length of the gather list represented by an skb into the # of necessary WRs.
 419  * The extra two fragments are for iscsi bhs and payload padding.
 420  */
 421 #define SKB_WR_LIST_SIZE         (MAX_SKB_FRAGS + 2)
 422
 423 static inline void cxgbi_sock_reset_wr_list(struct cxgbi_sock *csk)
 424 {
 425         csk->wr_pending_head = csk->wr_pending_tail = NULL;
 426 }
 427
 428 static inline void cxgbi_sock_enqueue_wr(struct cxgbi_sock *csk,
 429                                           struct sk_buff *skb)
 430 {
 431         cxgbi_skcb_tx_wr_next(skb) = NULL;
 432         /*
 433          * We want to take an extra reference since both us and the driver
 434          * need to free the packet before it's really freed. We know there's
 435          * just one user currently so we use atomic_set rather than skb_get
 436          * to avoid the atomic op.
 437          */
 438         atomic_set(&skb->users, 2);
 439
 440         if (!csk->wr_pending_head)
 441                 csk->wr_pending_head = skb;
 442         else
 443                 cxgbi_skcb_tx_wr_next(csk->wr_pending_tail) = skb;
 444         csk->wr_pending_tail = skb;
 445 }
 446
 447 static inline int cxgbi_sock_count_pending_wrs(const struct cxgbi_sock *csk)
 448 {
 449         int n = 0;
 450         const struct sk_buff *skb = csk->wr_pending_head;
 451
 452         while (skb) {
 453                 n += skb->csum;
 454                 skb = cxgbi_skcb_tx_wr_next(skb);
 455         }
 456         return n;
 457 }
 458
 459 static inline struct sk_buff *cxgbi_sock_peek_wr(const struct cxgbi_sock *csk)
 460 {
 461         return csk->wr_pending_head;
 462 }
 463
 464 static inline struct sk_buff *cxgbi_sock_dequeue_wr(struct cxgbi_sock *csk)
 465 {
 466         struct sk_buff *skb = csk->wr_pending_head;
 467
 468         if (likely(skb)) {
 469                 csk->wr_pending_head = cxgbi_skcb_tx_wr_next(skb);
 470                 cxgbi_skcb_tx_wr_next(skb) = NULL;
 471         }
 472         return skb;
 473 }
 474
 475 void cxgbi_sock_check_wr_invariants(const struct cxgbi_sock *);
 476 void cxgbi_sock_purge_wr_queue(struct cxgbi_sock *);
 477 void cxgbi_sock_skb_entail(struct cxgbi_sock *, struct sk_buff *);
 478 void cxgbi_sock_fail_act_open(struct cxgbi_sock *, int);
 479 void cxgbi_sock_act_open_req_arp_failure(void *, struct sk_buff *);
 480 void cxgbi_sock_closed(struct cxgbi_sock *);
 481 void cxgbi_sock_established(struct cxgbi_sock *, unsigned int, unsigned int);
 482 void cxgbi_sock_rcv_abort_rpl(struct cxgbi_sock *);
 483 void cxgbi_sock_rcv_peer_close(struct cxgbi_sock *);
 484 void cxgbi_sock_rcv_close_conn_rpl(struct cxgbi_sock *, u32);
 485 void cxgbi_sock_rcv_wr_ack(struct cxgbi_sock *, unsigned int, unsigned int,
 486                                 int);
 487 unsigned int cxgbi_sock_select_mss(struct cxgbi_sock *, unsigned int);
 488 void cxgbi_sock_free_cpl_skbs(struct cxgbi_sock *);
 489
 490 struct cxgbi_hba {
 491         struct net_device *ndev;
 492         struct net_device *vdev;        /* vlan dev */
 493         struct Scsi_Host *shost;
 494         struct cxgbi_device *cdev;
 495         __be32 ipv4addr;
 496         unsigned char port_id;
 497 };
 498
 499 struct cxgbi_ports_map {
 500         unsigned int max_connect;
 501         unsigned int used;
 502         unsigned short sport_base;
 503         spinlock_t lock;
 504         unsigned int next;
 505         struct cxgbi_sock **port_csk;
 506 };
 507
 508 #define CXGBI_FLAG_DEV_T3               0x1
 509 #define CXGBI_FLAG_DEV_T4               0x2
 510 #define CXGBI_FLAG_ADAPTER_RESET        0x4
 511 #define CXGBI_FLAG_IPV4_SET             0x10
 512 struct cxgbi_device {
 513         struct list_head list_head;
 514         unsigned int flags;
 515         struct net_device **ports;
 516         void *lldev;
 517         struct cxgbi_hba **hbas;
 518         const unsigned short *mtus;
 519         unsigned char nmtus;
 520         unsigned char nports;
 521         struct pci_dev *pdev;
 522         struct dentry *debugfs_root;
 523         struct iscsi_transport *itp;
 524
 525         unsigned int pfvf;
 526         unsigned int snd_win;
 527         unsigned int rcv_win;
 528         unsigned int rx_credit_thres;
 529         unsigned int skb_tx_rsvd;
 530         unsigned int skb_rx_extra;      /* for msg coalesced mode */
 531         unsigned int tx_max_size;
 532         unsigned int rx_max_size;
 533         struct cxgbi_ports_map pmap;
 534         struct cxgbi_tag_format tag_format;
 535         struct cxgbi_ddp_info *ddp;
 536
 537         void (*dev_ddp_cleanup)(struct cxgbi_device *);
 538         int (*csk_ddp_set)(struct cxgbi_sock *, struct cxgbi_pagepod_hdr *,
 539                                 unsigned int, unsigned int,
 540                                 struct cxgbi_gather_list *);
 541         void (*csk_ddp_clear)(struct cxgbi_hba *,
 542                                 unsigned int, unsigned int, unsigned int);
 543         int (*csk_ddp_setup_digest)(struct cxgbi_sock *,
 544                                 unsigned int, int, int, int);
 545         int (*csk_ddp_setup_pgidx)(struct cxgbi_sock *,
 546                                 unsigned int, int, bool);
 547
 548         void (*csk_release_offload_resources)(struct cxgbi_sock *);
 549         int (*csk_rx_pdu_ready)(struct cxgbi_sock *, struct sk_buff *);
 550         u32 (*csk_send_rx_credits)(struct cxgbi_sock *, u32);
 551         int (*csk_push_tx_frames)(struct cxgbi_sock *, int);
 552         void (*csk_send_abort_req)(struct cxgbi_sock *);
 553         void (*csk_send_close_req)(struct cxgbi_sock *);
 554         int (*csk_alloc_cpls)(struct cxgbi_sock *);
 555         int (*csk_init_act_open)(struct cxgbi_sock *);
 556
 557         void *dd_data;
 558 };
 559 #define cxgbi_cdev_priv(cdev)   ((cdev)->dd_data)
 560
 561 struct cxgbi_conn {
 562         struct cxgbi_endpoint *cep;
 563         struct iscsi_conn *iconn;
 564         struct cxgbi_hba *chba;
 565         u32 task_idx_bits;
 566 };
 567
 568 struct cxgbi_endpoint {
 569         struct cxgbi_conn *cconn;
 570         struct cxgbi_hba *chba;
 571         struct cxgbi_sock *csk;
 572 };
 573
 574 #define MAX_PDU_FRAGS   ((ULP2_MAX_PDU_PAYLOAD + 512 - 1) / 512)
 575 struct cxgbi_task_data {
 576         unsigned short nr_frags;
 577         struct page_frag frags[MAX_PDU_FRAGS];
 578         struct sk_buff *skb;
 579         unsigned int offset;
 580         unsigned int count;
 581         unsigned int sgoffset;
 582 };
 583 #define iscsi_task_cxgbi_data(task) \
 584         ((task)->dd_data + sizeof(struct iscsi_tcp_task))
 585
 586 static inline int cxgbi_is_ddp_tag(struct cxgbi_tag_format *tformat, u32 tag)
 587 {
 588         return !(tag & (1 << (tformat->rsvd_bits + tformat->rsvd_shift - 1)));
 589 }
 590
 591 static inline int cxgbi_sw_tag_usable(struct cxgbi_tag_format *tformat,
 592                                         u32 sw_tag)
 593 {
 594         sw_tag >>= (32 - tformat->rsvd_bits);
 595         return !sw_tag;
 596 }
 597
 598 static inline u32 cxgbi_set_non_ddp_tag(struct cxgbi_tag_format *tformat,
 599                                         u32 sw_tag)
 600 {
 601         unsigned char shift = tformat->rsvd_bits + tformat->rsvd_shift - 1;
 602         u32 mask = (1 << shift) - 1;
 603
 604         if (sw_tag && (sw_tag & ~mask)) {
 605                 u32 v1 = sw_tag & ((1 << shift) - 1);
 606                 u32 v2 = (sw_tag >> (shift - 1)) << shift;
 607
 608                 return v2 | v1 | 1 << shift;
 609         }
 610
 611         return sw_tag | 1 << shift;
 612 }
 613
 614 static inline u32 cxgbi_ddp_tag_base(struct cxgbi_tag_format *tformat,
 615                                         u32 sw_tag)
 616 {
 617         u32 mask = (1 << tformat->rsvd_shift) - 1;
 618
 619         if (sw_tag && (sw_tag & ~mask)) {
 620                 u32 v1 = sw_tag & mask;
 621                 u32 v2 = sw_tag >> tformat->rsvd_shift;
 622
 623                 v2 <<= tformat->rsvd_bits + tformat->rsvd_shift;
 624
 625                 return v2 | v1;
 626         }
 627
 628         return sw_tag;
 629 }
 630
 631 static inline u32 cxgbi_tag_rsvd_bits(struct cxgbi_tag_format *tformat,
 632                                         u32 tag)
 633 {
 634         if (cxgbi_is_ddp_tag(tformat, tag))
 635                 return (tag >> tformat->rsvd_shift) & tformat->rsvd_mask;
 636
 637         return 0;
 638 }
 639
 640 static inline u32 cxgbi_tag_nonrsvd_bits(struct cxgbi_tag_format *tformat,
 641                                         u32 tag)
 642 {
 643         unsigned char shift = tformat->rsvd_bits + tformat->rsvd_shift - 1;
 644         u32 v1, v2;
 645
 646         if (cxgbi_is_ddp_tag(tformat, tag)) {
 647                 v1 = tag & ((1 << tformat->rsvd_shift) - 1);
 648                 v2 = (tag >> (shift + 1)) << tformat->rsvd_shift;
 649         } else {
 650                 u32 mask = (1 << shift) - 1;
 651                 tag &= ~(1 << shift);
 652                 v1 = tag & mask;
 653                 v2 = (tag >> 1) & ~mask;
 654         }
 655         return v1 | v2;
 656 }
 657
 658 static inline void *cxgbi_alloc_big_mem(unsigned int size,
 659                                         gfp_t gfp)
 660 {
 661         void *p = kmalloc(size, gfp);
 662         if (!p)
 663                 p = vmalloc(size);
 664         if (p)
 665                 memset(p, 0, size);
 666         return p;
 667 }
 668
 669 static inline void cxgbi_free_big_mem(void *addr)
 670 {
 671         if (is_vmalloc_addr(addr))
 672                 vfree(addr);
 673         else
 674                 kfree(addr);
 675 }
 676
 677 static inline void cxgbi_set_iscsi_ipv4(struct cxgbi_hba *chba, __be32 ipaddr)
 678 {
 679         if (chba->cdev->flags & CXGBI_FLAG_IPV4_SET)
 680                 chba->ipv4addr = ipaddr;
 681         else
 682                 pr_info("set iscsi ipv4 NOT supported, using %s ipv4.\n",
 683                         chba->ndev->name);
 684 }
 685
 686 static inline __be32 cxgbi_get_iscsi_ipv4(struct cxgbi_hba *chba)
 687 {
 688         return chba->ipv4addr;
 689 }
 690
 691 struct cxgbi_device *cxgbi_device_register(unsigned int, unsigned int);
 692 void cxgbi_device_unregister(struct cxgbi_device *);
 693 void cxgbi_device_unregister_all(unsigned int flag);
 694 struct cxgbi_device *cxgbi_device_find_by_lldev(void *);
 695 int cxgbi_hbas_add(struct cxgbi_device *, unsigned int, unsigned int,
 696                         struct scsi_host_template *,
 697                         struct scsi_transport_template *);
 698 void cxgbi_hbas_remove(struct cxgbi_device *);
 699
 700 int cxgbi_device_portmap_create(struct cxgbi_device *cdev, unsigned int base,
 701                         unsigned int max_conn);
 702 void cxgbi_device_portmap_cleanup(struct cxgbi_device *cdev);
 703
 704 void cxgbi_conn_tx_open(struct cxgbi_sock *);
 705 void cxgbi_conn_pdu_ready(struct cxgbi_sock *);
 706 int cxgbi_conn_alloc_pdu(struct iscsi_task *, u8);
 707 int cxgbi_conn_init_pdu(struct iscsi_task *, unsigned int , unsigned int);
 708 int cxgbi_conn_xmit_pdu(struct iscsi_task *);
 709
 710 void cxgbi_cleanup_task(struct iscsi_task *task);
 711
 712 mode_t cxgbi_attr_is_visible(int param_type, int param);
 713 void cxgbi_get_conn_stats(struct iscsi_cls_conn *, struct iscsi_stats *);
 714 int cxgbi_set_conn_param(struct iscsi_cls_conn *,
 715                         enum iscsi_param, char *, int);
 716 int cxgbi_get_ep_param(struct iscsi_endpoint *ep, enum iscsi_param, char *);
 717 struct iscsi_cls_conn *cxgbi_create_conn(struct iscsi_cls_session *, u32);
 718 int cxgbi_bind_conn(struct iscsi_cls_session *,
 719                         struct iscsi_cls_conn *, u64, int);
 720 void cxgbi_destroy_session(struct iscsi_cls_session *);
 721 struct iscsi_cls_session *cxgbi_create_session(struct iscsi_endpoint *,
 722                         u16, u16, u32);
 723 int cxgbi_set_host_param(struct Scsi_Host *,
 724                         enum iscsi_host_param, char *, int);
 725 int cxgbi_get_host_param(struct Scsi_Host *, enum iscsi_host_param, char *);
 726 struct iscsi_endpoint *cxgbi_ep_connect(struct Scsi_Host *,
 727                         struct sockaddr *, int);
 728 int cxgbi_ep_poll(struct iscsi_endpoint *, int);
 729 void cxgbi_ep_disconnect(struct iscsi_endpoint *);
 730
 731 int cxgbi_iscsi_init(struct iscsi_transport *,
 732                         struct scsi_transport_template **);
 733 void cxgbi_iscsi_cleanup(struct iscsi_transport *,
 734                         struct scsi_transport_template **);
 735 void cxgbi_parse_pdu_itt(struct iscsi_conn *, itt_t, int *, int *);
 736 int cxgbi_ddp_init(struct cxgbi_device *, unsigned int, unsigned int,
 737                         unsigned int, unsigned int);
 738 int cxgbi_ddp_cleanup(struct cxgbi_device *);
 739 void cxgbi_ddp_page_size_factor(int *);
 740 void cxgbi_ddp_ppod_clear(struct cxgbi_pagepod *);
 741 void cxgbi_ddp_ppod_set(struct cxgbi_pagepod *, struct cxgbi_pagepod_hdr *,
 742                         struct cxgbi_gather_list *, unsigned int);
 743 #endif  /*__LIBCXGBI_H__*/