include/scsi/libfcoe.h

   1 /*
   2  * Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  16  *
  17  * Maintained at www.Open-FCoE.org
  18  */
  19
  20 #ifndef _LIBFCOE_H
  21 #define _LIBFCOE_H
  22
  23 #include <linux/netdevice.h>
  24 #include <linux/skbuff.h>
  25 #include <scsi/fc/fc_fcoe.h>
  26 #include <scsi/libfc.h>
  27
  28 /*
  29  * this percpu struct for fcoe
  30  */
  31 struct fcoe_percpu_s {
  32         int             cpu;
  33         struct task_struct *thread;
  34         struct sk_buff_head fcoe_rx_list;
  35         struct page *crc_eof_page;
  36         int crc_eof_offset;
  37 };
  38
  39 /*
  40  * the fcoe sw transport private data
  41  */
  42 struct fcoe_softc {
  43         struct list_head list;
  44         struct fc_lport *lp;
  45         struct net_device *real_dev;
  46         struct net_device *phys_dev;            /* device with ethtool_ops */
  47         struct packet_type  fcoe_packet_type;
  48         struct sk_buff_head fcoe_pending_queue;
  49
  50         u8 dest_addr[ETH_ALEN];
  51         u8 ctl_src_addr[ETH_ALEN];
  52         u8 data_src_addr[ETH_ALEN];
  53         /*
  54          * fcoe protocol address learning related stuff
  55          */
  56         u16 flogi_oxid;
  57         u8 flogi_progress;
  58         u8 address_mode;
  59 };
  60
  61 static inline struct fcoe_softc *fcoe_softc(
  62         const struct fc_lport *lp)
  63 {
  64         return (struct fcoe_softc *)lport_priv(lp);
  65 }
  66
  67 static inline struct net_device *fcoe_netdev(
  68         const struct fc_lport *lp)
  69 {
  70         return fcoe_softc(lp)->real_dev;
  71 }
  72
  73 static inline struct fcoe_hdr *skb_fcoe_header(const struct sk_buff *skb)
  74 {
  75         return (struct fcoe_hdr *)skb_network_header(skb);
  76 }
  77
  78 static inline int skb_fcoe_offset(const struct sk_buff *skb)
  79 {
  80         return skb_network_offset(skb);
  81 }
  82
  83 static inline struct fc_frame_header *skb_fc_header(const struct sk_buff *skb)
  84 {
  85         return (struct fc_frame_header *)skb_transport_header(skb);
  86 }
  87
  88 static inline int skb_fc_offset(const struct sk_buff *skb)
  89 {
  90         return skb_transport_offset(skb);
  91 }
  92
  93 static inline void skb_reset_fc_header(struct sk_buff *skb)
  94 {
  95         skb_reset_network_header(skb);
  96         skb_set_transport_header(skb, skb_network_offset(skb) +
  97                                  sizeof(struct fcoe_hdr));
  98 }
  99
 100 static inline bool skb_fc_is_data(const struct sk_buff *skb)
 101 {
 102         return skb_fc_header(skb)->fh_r_ctl == FC_RCTL_DD_SOL_DATA;
 103 }
 104
 105 static inline bool skb_fc_is_cmd(const struct sk_buff *skb)
 106 {
 107         return skb_fc_header(skb)->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD;
 108 }
 109
 110 static inline bool skb_fc_has_exthdr(const struct sk_buff *skb)
 111 {
 112         return (skb_fc_header(skb)->fh_r_ctl == FC_RCTL_VFTH) ||
 113             (skb_fc_header(skb)->fh_r_ctl == FC_RCTL_IFRH) ||
 114             (skb_fc_header(skb)->fh_r_ctl == FC_RCTL_ENCH);
 115 }
 116
 117 static inline bool skb_fc_is_roff(const struct sk_buff *skb)
 118 {
 119         return skb_fc_header(skb)->fh_f_ctl[2] & FC_FC_REL_OFF;
 120 }
 121
 122 static inline u16 skb_fc_oxid(const struct sk_buff *skb)
 123 {
 124         return be16_to_cpu(skb_fc_header(skb)->fh_ox_id);
 125 }
 126
 127 static inline u16 skb_fc_rxid(const struct sk_buff *skb)
 128 {
 129         return be16_to_cpu(skb_fc_header(skb)->fh_rx_id);
 130 }
 131
 132 /* FIXME - DMA_BIDIRECTIONAL ? */
 133 #define skb_cb(skb)     ((struct fcoe_rcv_info *)&((skb)->cb[0]))
 134 #define skb_cmd(skb)    (skb_cb(skb)->fr_cmd)
 135 #define skb_dir(skb)    (skb_cmd(skb)->sc_data_direction)
 136 static inline bool skb_fc_is_read(const struct sk_buff *skb)
 137 {
 138         if (skb_fc_is_cmd(skb) && skb_cmd(skb))
 139                 return skb_dir(skb) == DMA_FROM_DEVICE;
 140         return false;
 141 }
 142
 143 static inline bool skb_fc_is_write(const struct sk_buff *skb)
 144 {
 145         if (skb_fc_is_cmd(skb) && skb_cmd(skb))
 146                 return skb_dir(skb) == DMA_TO_DEVICE;
 147         return false;
 148 }
 149
 150 /* libfcoe funcs */
 151 int fcoe_reset(struct Scsi_Host *shost);
 152 u64 fcoe_wwn_from_mac(unsigned char mac[MAX_ADDR_LEN],
 153                       unsigned int scheme, unsigned int port);
 154
 155 u32 fcoe_fc_crc(struct fc_frame *fp);
 156 int fcoe_xmit(struct fc_lport *, struct fc_frame *);
 157 int fcoe_rcv(struct sk_buff *, struct net_device *,
 158              struct packet_type *, struct net_device *);
 159
 160 int fcoe_percpu_receive_thread(void *arg);
 161 void fcoe_clean_pending_queue(struct fc_lport *lp);
 162 void fcoe_percpu_clean(struct fc_lport *lp);
 163 void fcoe_watchdog(ulong vp);
 164 int fcoe_link_ok(struct fc_lport *lp);
 165
 166 struct fc_lport *fcoe_hostlist_lookup(const struct net_device *);
 167 int fcoe_hostlist_add(const struct fc_lport *);
 168 int fcoe_hostlist_remove(const struct fc_lport *);
 169
 170 struct Scsi_Host *fcoe_host_alloc(struct scsi_host_template *, int);
 171 int fcoe_libfc_config(struct fc_lport *, struct libfc_function_template *);
 172
 173 /* fcoe sw hba */
 174 int __init fcoe_sw_init(void);
 175 int __exit fcoe_sw_exit(void);
 176 #endif /* _LIBFCOE_H */