]>
Commit | Line | Data |
---|---|---|
61d8658b DC |
1 | /* |
2 | * QLogic FCoE Offload Driver | |
3 | * Copyright (c) 2016 Cavium Inc. | |
4 | * | |
5 | * This software is available under the terms of the GNU General Public License | |
6 | * (GPL) Version 2, available from the file COPYING in the main directory of | |
7 | * this source tree. | |
8 | */ | |
9 | #include <linux/if_ether.h> | |
10 | #include <linux/if_vlan.h> | |
11 | #include "qedf.h" | |
12 | ||
13 | extern const struct qed_fcoe_ops *qed_ops; | |
14 | /* | |
15 | * FIP VLAN functions that will eventually move to libfcoe. | |
16 | */ | |
17 | ||
18 | void qedf_fcoe_send_vlan_req(struct qedf_ctx *qedf) | |
19 | { | |
20 | struct sk_buff *skb; | |
21 | char *eth_fr; | |
22 | int fr_len; | |
23 | struct fip_vlan *vlan; | |
24 | #define MY_FIP_ALL_FCF_MACS ((__u8[6]) { 1, 0x10, 0x18, 1, 0, 2 }) | |
25 | static u8 my_fcoe_all_fcfs[ETH_ALEN] = MY_FIP_ALL_FCF_MACS; | |
26 | ||
27 | skb = dev_alloc_skb(sizeof(struct fip_vlan)); | |
28 | if (!skb) | |
29 | return; | |
30 | ||
31 | fr_len = sizeof(*vlan); | |
32 | eth_fr = (char *)skb->data; | |
33 | vlan = (struct fip_vlan *)eth_fr; | |
34 | ||
35 | memset(vlan, 0, sizeof(*vlan)); | |
36 | ether_addr_copy(vlan->eth.h_source, qedf->mac); | |
37 | ether_addr_copy(vlan->eth.h_dest, my_fcoe_all_fcfs); | |
38 | vlan->eth.h_proto = htons(ETH_P_FIP); | |
39 | ||
40 | vlan->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER); | |
41 | vlan->fip.fip_op = htons(FIP_OP_VLAN); | |
42 | vlan->fip.fip_subcode = FIP_SC_VL_REQ; | |
43 | vlan->fip.fip_dl_len = htons(sizeof(vlan->desc) / FIP_BPW); | |
44 | ||
45 | vlan->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC; | |
46 | vlan->desc.mac.fd_desc.fip_dlen = sizeof(vlan->desc.mac) / FIP_BPW; | |
47 | ether_addr_copy(vlan->desc.mac.fd_mac, qedf->mac); | |
48 | ||
49 | vlan->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME; | |
50 | vlan->desc.wwnn.fd_desc.fip_dlen = sizeof(vlan->desc.wwnn) / FIP_BPW; | |
51 | put_unaligned_be64(qedf->lport->wwnn, &vlan->desc.wwnn.fd_wwn); | |
52 | ||
53 | skb_put(skb, sizeof(*vlan)); | |
54 | skb->protocol = htons(ETH_P_FIP); | |
55 | skb_reset_mac_header(skb); | |
56 | skb_reset_network_header(skb); | |
57 | ||
58 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Sending FIP VLAN " | |
59 | "request."); | |
60 | ||
61 | if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) { | |
62 | QEDF_WARN(&(qedf->dbg_ctx), "Cannot send vlan request " | |
63 | "because link is not up.\n"); | |
64 | ||
65 | kfree_skb(skb); | |
66 | return; | |
67 | } | |
68 | qed_ops->ll2->start_xmit(qedf->cdev, skb); | |
69 | } | |
70 | ||
71 | static void qedf_fcoe_process_vlan_resp(struct qedf_ctx *qedf, | |
72 | struct sk_buff *skb) | |
73 | { | |
74 | struct fip_header *fiph; | |
75 | struct fip_desc *desc; | |
76 | u16 vid = 0; | |
77 | ssize_t rlen; | |
78 | size_t dlen; | |
79 | ||
80 | fiph = (struct fip_header *)(((void *)skb->data) + 2 * ETH_ALEN + 2); | |
81 | ||
82 | rlen = ntohs(fiph->fip_dl_len) * 4; | |
83 | desc = (struct fip_desc *)(fiph + 1); | |
84 | while (rlen > 0) { | |
85 | dlen = desc->fip_dlen * FIP_BPW; | |
86 | switch (desc->fip_dtype) { | |
87 | case FIP_DT_VLAN: | |
88 | vid = ntohs(((struct fip_vlan_desc *)desc)->fd_vlan); | |
89 | break; | |
90 | } | |
91 | desc = (struct fip_desc *)((char *)desc + dlen); | |
92 | rlen -= dlen; | |
93 | } | |
94 | ||
95 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "VLAN response, " | |
96 | "vid=0x%x.\n", vid); | |
97 | ||
98 | if (vid > 0 && qedf->vlan_id != vid) { | |
99 | qedf_set_vlan_id(qedf, vid); | |
100 | ||
101 | /* Inform waiter that it's ok to call fcoe_ctlr_link up() */ | |
102 | complete(&qedf->fipvlan_compl); | |
103 | } | |
104 | } | |
105 | ||
106 | void qedf_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb) | |
107 | { | |
108 | struct qedf_ctx *qedf = container_of(fip, struct qedf_ctx, ctlr); | |
109 | struct ethhdr *eth_hdr; | |
110 | struct vlan_ethhdr *vlan_hdr; | |
111 | struct fip_header *fiph; | |
112 | u16 op, vlan_tci = 0; | |
113 | u8 sub; | |
114 | ||
115 | if (!test_bit(QEDF_LL2_STARTED, &qedf->flags)) { | |
116 | QEDF_WARN(&(qedf->dbg_ctx), "LL2 not started\n"); | |
117 | kfree_skb(skb); | |
118 | return; | |
119 | } | |
120 | ||
121 | fiph = (struct fip_header *) ((void *)skb->data + 2 * ETH_ALEN + 2); | |
122 | eth_hdr = (struct ethhdr *)skb_mac_header(skb); | |
123 | op = ntohs(fiph->fip_op); | |
124 | sub = fiph->fip_subcode; | |
125 | ||
126 | if (!qedf->vlan_hw_insert) { | |
127 | vlan_hdr = (struct vlan_ethhdr *)skb_push(skb, sizeof(*vlan_hdr) | |
128 | - sizeof(*eth_hdr)); | |
129 | memcpy(vlan_hdr, eth_hdr, 2 * ETH_ALEN); | |
130 | vlan_hdr->h_vlan_proto = htons(ETH_P_8021Q); | |
131 | vlan_hdr->h_vlan_encapsulated_proto = eth_hdr->h_proto; | |
132 | vlan_hdr->h_vlan_TCI = vlan_tci = htons(qedf->vlan_id); | |
133 | } | |
134 | ||
135 | /* Update eth_hdr since we added a VLAN tag */ | |
136 | eth_hdr = (struct ethhdr *)skb_mac_header(skb); | |
137 | ||
138 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FIP frame send: " | |
139 | "dest=%pM op=%x sub=%x vlan=%04x.", eth_hdr->h_dest, op, sub, | |
140 | ntohs(vlan_tci)); | |
141 | if (qedf_dump_frames) | |
142 | print_hex_dump(KERN_WARNING, "fip ", DUMP_PREFIX_OFFSET, 16, 1, | |
143 | skb->data, skb->len, false); | |
144 | ||
145 | qed_ops->ll2->start_xmit(qedf->cdev, skb); | |
146 | } | |
147 | ||
148 | /* Process incoming FIP frames. */ | |
149 | void qedf_fip_recv(struct qedf_ctx *qedf, struct sk_buff *skb) | |
150 | { | |
151 | struct ethhdr *eth_hdr; | |
152 | struct fip_header *fiph; | |
153 | struct fip_desc *desc; | |
154 | struct fip_mac_desc *mp; | |
155 | struct fip_wwn_desc *wp; | |
156 | struct fip_vn_desc *vp; | |
157 | size_t rlen, dlen; | |
158 | uint32_t cvl_port_id; | |
159 | __u8 cvl_mac[ETH_ALEN]; | |
160 | u16 op; | |
161 | u8 sub; | |
162 | ||
163 | eth_hdr = (struct ethhdr *)skb_mac_header(skb); | |
164 | fiph = (struct fip_header *) ((void *)skb->data + 2 * ETH_ALEN + 2); | |
165 | op = ntohs(fiph->fip_op); | |
166 | sub = fiph->fip_subcode; | |
167 | ||
168 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FIP frame received: " | |
169 | "skb=%p fiph=%p source=%pM op=%x sub=%x", skb, fiph, | |
170 | eth_hdr->h_source, op, sub); | |
171 | if (qedf_dump_frames) | |
172 | print_hex_dump(KERN_WARNING, "fip ", DUMP_PREFIX_OFFSET, 16, 1, | |
173 | skb->data, skb->len, false); | |
174 | ||
175 | /* Handle FIP VLAN resp in the driver */ | |
176 | if (op == FIP_OP_VLAN && sub == FIP_SC_VL_NOTE) { | |
177 | qedf_fcoe_process_vlan_resp(qedf, skb); | |
178 | qedf->vlan_hw_insert = 0; | |
179 | kfree_skb(skb); | |
180 | } else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK) { | |
181 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Clear virtual " | |
182 | "link received.\n"); | |
183 | ||
184 | /* Check that an FCF has been selected by fcoe */ | |
185 | if (qedf->ctlr.sel_fcf == NULL) { | |
186 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, | |
187 | "Dropping CVL since FCF has not been selected " | |
188 | "yet."); | |
189 | return; | |
190 | } | |
191 | ||
192 | cvl_port_id = 0; | |
193 | memset(cvl_mac, 0, ETH_ALEN); | |
194 | /* | |
195 | * We need to loop through the CVL descriptors to determine | |
196 | * if we want to reset the fcoe link | |
197 | */ | |
198 | rlen = ntohs(fiph->fip_dl_len) * FIP_BPW; | |
199 | desc = (struct fip_desc *)(fiph + 1); | |
200 | while (rlen >= sizeof(*desc)) { | |
201 | dlen = desc->fip_dlen * FIP_BPW; | |
202 | switch (desc->fip_dtype) { | |
203 | case FIP_DT_MAC: | |
204 | mp = (struct fip_mac_desc *)desc; | |
205 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, | |
db6b2060 | 206 | "fd_mac=%pM\n", mp->fd_mac); |
61d8658b DC |
207 | ether_addr_copy(cvl_mac, mp->fd_mac); |
208 | break; | |
209 | case FIP_DT_NAME: | |
210 | wp = (struct fip_wwn_desc *)desc; | |
211 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, | |
212 | "fc_wwpn=%016llx.\n", | |
213 | get_unaligned_be64(&wp->fd_wwn)); | |
214 | break; | |
215 | case FIP_DT_VN_ID: | |
216 | vp = (struct fip_vn_desc *)desc; | |
217 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, | |
218 | "fd_fc_id=%x.\n", ntoh24(vp->fd_fc_id)); | |
219 | cvl_port_id = ntoh24(vp->fd_fc_id); | |
220 | break; | |
221 | default: | |
222 | /* Ignore anything else */ | |
223 | break; | |
224 | } | |
225 | desc = (struct fip_desc *)((char *)desc + dlen); | |
226 | rlen -= dlen; | |
227 | } | |
228 | ||
229 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, | |
230 | "cvl_port_id=%06x cvl_mac=%pM.\n", cvl_port_id, | |
231 | cvl_mac); | |
232 | if (cvl_port_id == qedf->lport->port_id && | |
233 | ether_addr_equal(cvl_mac, | |
234 | qedf->ctlr.sel_fcf->fcf_mac)) { | |
235 | fcoe_ctlr_link_down(&qedf->ctlr); | |
236 | qedf_wait_for_upload(qedf); | |
237 | fcoe_ctlr_link_up(&qedf->ctlr); | |
238 | } | |
239 | kfree_skb(skb); | |
240 | } else { | |
241 | /* Everything else is handled by libfcoe */ | |
242 | __skb_pull(skb, ETH_HLEN); | |
243 | fcoe_ctlr_recv(&qedf->ctlr, skb); | |
244 | } | |
245 | } | |
246 | ||
247 | void qedf_update_src_mac(struct fc_lport *lport, u8 *addr) | |
248 | { | |
249 | struct qedf_ctx *qedf = lport_priv(lport); | |
250 | ||
251 | QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, | |
252 | "Setting data_src_addr=%pM.\n", addr); | |
253 | ether_addr_copy(qedf->data_src_addr, addr); | |
254 | } | |
255 | ||
256 | u8 *qedf_get_src_mac(struct fc_lport *lport) | |
257 | { | |
258 | u8 mac[ETH_ALEN]; | |
259 | u8 port_id[3]; | |
260 | struct qedf_ctx *qedf = lport_priv(lport); | |
261 | ||
262 | /* We need to use the lport port_id to create the data_src_addr */ | |
263 | if (is_zero_ether_addr(qedf->data_src_addr)) { | |
264 | hton24(port_id, lport->port_id); | |
265 | fc_fcoe_set_mac(mac, port_id); | |
266 | qedf->ctlr.update_mac(lport, mac); | |
267 | } | |
268 | return qedf->data_src_addr; | |
269 | } |