1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Copyright 2008 Cisco Systems, Inc. All rights reserved.
4	* Copyright 2007 Nuova Systems, Inc. All rights reserved.
5	*/
6	#include <linux/errno.h>
7	#include <linux/pci.h>
8	#include <linux/slab.h>
9	#include <linux/skbuff.h>
10	#include <linux/interrupt.h>
11	#include <linux/spinlock.h>
12	#include <linux/if_ether.h>
13	#include <linux/if_vlan.h>
14	#include <linux/workqueue.h>
15	#include <scsi/fc/fc_fip.h>
16	#include <scsi/fc/fc_els.h>
17	#include <scsi/fc/fc_fcoe.h>
18	#include <scsi/fc_frame.h>
19	#include <scsi/libfc.h>
20	#include "fnic_io.h"
21	#include "fnic.h"
22	#include "fnic_fip.h"
23	#include "cq_enet_desc.h"
24	#include "cq_exch_desc.h"
25
26	static u8 fcoe_all_fcfs[ETH_ALEN] = FIP_ALL_FCF_MACS;
27	struct workqueue_struct *fnic_fip_queue;
28	struct workqueue_struct *fnic_event_queue;
29
30	static void fnic_set_eth_mode(struct fnic *);
31	static void fnic_fcoe_send_vlan_req(struct fnic *fnic);
32	static void fnic_fcoe_start_fcf_disc(struct fnic *fnic);
33	static void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct sk_buff *);
34	static int fnic_fcoe_vlan_check(struct fnic *fnic, u16 flag);
35	static int fnic_fcoe_handle_fip_frame(struct fnic *fnic, struct sk_buff *skb);
36
37	void fnic_handle_link(struct work_struct *work)
38	{
39	struct fnic *fnic = container_of(work, struct fnic, link_work);
40	unsigned long flags;
41	int old_link_status;
42	u32 old_link_down_cnt;
43	u64 old_port_speed, new_port_speed;
44
45	spin_lock_irqsave(&fnic->fnic_lock, flags);
46
47	fnic->link_events = 1; /* less work to just set everytime*/
48
49	if (fnic->stop_rx_link_events) {
50	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
51	return;
52	}
53
54	old_link_down_cnt = fnic->link_down_cnt;
55	old_link_status = fnic->link_status;
56	old_port_speed = atomic64_read(
57	v: &fnic->fnic_stats.misc_stats.current_port_speed);
58
59	fnic->link_status = vnic_dev_link_status(vdev: fnic->vdev);
60	fnic->link_down_cnt = vnic_dev_link_down_cnt(vdev: fnic->vdev);
61
62	new_port_speed = vnic_dev_port_speed(vdev: fnic->vdev);
63	atomic64_set(v: &fnic->fnic_stats.misc_stats.current_port_speed,
64	i: new_port_speed);
65	if (old_port_speed != new_port_speed)
66	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
67	"Current vnic speed set to: %llu\n",
68	new_port_speed);
69
70	switch (vnic_dev_port_speed(vdev: fnic->vdev)) {
71	case DCEM_PORTSPEED_10G:
72	fc_host_speed(fnic->lport->host) = FC_PORTSPEED_10GBIT;
73	fnic->lport->link_supported_speeds = FC_PORTSPEED_10GBIT;
74	break;
75	case DCEM_PORTSPEED_20G:
76	fc_host_speed(fnic->lport->host) = FC_PORTSPEED_20GBIT;
77	fnic->lport->link_supported_speeds = FC_PORTSPEED_20GBIT;
78	break;
79	case DCEM_PORTSPEED_25G:
80	fc_host_speed(fnic->lport->host) = FC_PORTSPEED_25GBIT;
81	fnic->lport->link_supported_speeds = FC_PORTSPEED_25GBIT;
82	break;
83	case DCEM_PORTSPEED_40G:
84	case DCEM_PORTSPEED_4x10G:
85	fc_host_speed(fnic->lport->host) = FC_PORTSPEED_40GBIT;
86	fnic->lport->link_supported_speeds = FC_PORTSPEED_40GBIT;
87	break;
88	case DCEM_PORTSPEED_100G:
89	fc_host_speed(fnic->lport->host) = FC_PORTSPEED_100GBIT;
90	fnic->lport->link_supported_speeds = FC_PORTSPEED_100GBIT;
91	break;
92	default:
93	fc_host_speed(fnic->lport->host) = FC_PORTSPEED_UNKNOWN;
94	fnic->lport->link_supported_speeds = FC_PORTSPEED_UNKNOWN;
95	break;
96	}
97
98	if (old_link_status == fnic->link_status) {
99	if (!fnic->link_status) {
100	/* DOWN -> DOWN */
101	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
102	fnic_fc_trace_set_data(host_no: fnic->lport->host->host_no,
103	FNIC_FC_LE, frame: "Link Status: DOWN->DOWN",
104	strlen("Link Status: DOWN->DOWN"));
105	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
106	"down->down\n");
107	} else {
108	if (old_link_down_cnt != fnic->link_down_cnt) {
109	/* UP -> DOWN -> UP */
110	fnic->lport->host_stats.link_failure_count++;
111	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
112	fnic_fc_trace_set_data(
113	host_no: fnic->lport->host->host_no,
114	FNIC_FC_LE,
115	frame: "Link Status:UP_DOWN_UP",
116	strlen("Link_Status:UP_DOWN_UP")
117	);
118	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
119	"link down\n");
120	fcoe_ctlr_link_down(&fnic->ctlr);
121	if (fnic->config.flags & VFCF_FIP_CAPABLE) {
122	/* start FCoE VLAN discovery */
123	fnic_fc_trace_set_data(
124	host_no: fnic->lport->host->host_no,
125	FNIC_FC_LE,
126	frame: "Link Status: UP_DOWN_UP_VLAN",
127	strlen(
128	"Link Status: UP_DOWN_UP_VLAN")
129	);
130	fnic_fcoe_send_vlan_req(fnic);
131	return;
132	}
133	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
134	"up->down->up: Link up\n");
135	fcoe_ctlr_link_up(&fnic->ctlr);
136	} else {
137	/* UP -> UP */
138	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
139	fnic_fc_trace_set_data(
140	host_no: fnic->lport->host->host_no, FNIC_FC_LE,
141	frame: "Link Status: UP_UP",
142	strlen("Link Status: UP_UP"));
143	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
144	"up->up\n");
145	}
146	}
147	} else if (fnic->link_status) {
148	/* DOWN -> UP */
149	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
150	if (fnic->config.flags & VFCF_FIP_CAPABLE) {
151	/* start FCoE VLAN discovery */
152	fnic_fc_trace_set_data(host_no: fnic->lport->host->host_no,
153	FNIC_FC_LE, frame: "Link Status: DOWN_UP_VLAN",
154	strlen("Link Status: DOWN_UP_VLAN"));
155	fnic_fcoe_send_vlan_req(fnic);
156
157	return;
158	}
159
160	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
161	"down->up: Link up\n");
162	fnic_fc_trace_set_data(host_no: fnic->lport->host->host_no, FNIC_FC_LE,
163	frame: "Link Status: DOWN_UP", strlen("Link Status: DOWN_UP"));
164	fcoe_ctlr_link_up(&fnic->ctlr);
165	} else {
166	/* UP -> DOWN */
167	fnic->lport->host_stats.link_failure_count++;
168	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
169	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
170	"up->down: Link down\n");
171	fnic_fc_trace_set_data(
172	host_no: fnic->lport->host->host_no, FNIC_FC_LE,
173	frame: "Link Status: UP_DOWN",
174	strlen("Link Status: UP_DOWN"));
175	if (fnic->config.flags & VFCF_FIP_CAPABLE) {
176	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
177	"deleting fip-timer during link-down\n");
178	del_timer_sync(timer: &fnic->fip_timer);
179	}
180	fcoe_ctlr_link_down(&fnic->ctlr);
181	}
182
183	}
184
185	/*
186	* This function passes incoming fabric frames to libFC
187	*/
188	void fnic_handle_frame(struct work_struct *work)
189	{
190	struct fnic *fnic = container_of(work, struct fnic, frame_work);
191	struct fc_lport *lp = fnic->lport;
192	unsigned long flags;
193	struct sk_buff *skb;
194	struct fc_frame *fp;
195
196	while ((skb = skb_dequeue(list: &fnic->frame_queue))) {
197
198	spin_lock_irqsave(&fnic->fnic_lock, flags);
199	if (fnic->stop_rx_link_events) {
200	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
201	dev_kfree_skb(skb);
202	return;
203	}
204	fp = (struct fc_frame *)skb;
205
206	/*
207	* If we're in a transitional state, just re-queue and return.
208	* The queue will be serviced when we get to a stable state.
209	*/
210	if (fnic->state != FNIC_IN_FC_MODE &&
211	fnic->state != FNIC_IN_ETH_MODE) {
212	skb_queue_head(list: &fnic->frame_queue, newsk: skb);
213	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
214	return;
215	}
216	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
217
218	fc_exch_recv(lp, fp);
219	}
220	}
221
222	void fnic_fcoe_evlist_free(struct fnic *fnic)
223	{
224	struct fnic_event *fevt = NULL;
225	struct fnic_event *next = NULL;
226	unsigned long flags;
227
228	spin_lock_irqsave(&fnic->fnic_lock, flags);
229	if (list_empty(head: &fnic->evlist)) {
230	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
231	return;
232	}
233
234	list_for_each_entry_safe(fevt, next, &fnic->evlist, list) {
235	list_del(entry: &fevt->list);
236	kfree(objp: fevt);
237	}
238	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
239	}
240
241	void fnic_handle_event(struct work_struct *work)
242	{
243	struct fnic *fnic = container_of(work, struct fnic, event_work);
244	struct fnic_event *fevt = NULL;
245	struct fnic_event *next = NULL;
246	unsigned long flags;
247
248	spin_lock_irqsave(&fnic->fnic_lock, flags);
249	if (list_empty(head: &fnic->evlist)) {
250	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
251	return;
252	}
253
254	list_for_each_entry_safe(fevt, next, &fnic->evlist, list) {
255	if (fnic->stop_rx_link_events) {
256	list_del(entry: &fevt->list);
257	kfree(objp: fevt);
258	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
259	return;
260	}
261	/*
262	* If we're in a transitional state, just re-queue and return.
263	* The queue will be serviced when we get to a stable state.
264	*/
265	if (fnic->state != FNIC_IN_FC_MODE &&
266	fnic->state != FNIC_IN_ETH_MODE) {
267	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
268	return;
269	}
270
271	list_del(entry: &fevt->list);
272	switch (fevt->event) {
273	case FNIC_EVT_START_VLAN_DISC:
274	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
275	fnic_fcoe_send_vlan_req(fnic);
276	spin_lock_irqsave(&fnic->fnic_lock, flags);
277	break;
278	case FNIC_EVT_START_FCF_DISC:
279	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
280	"Start FCF Discovery\n");
281	fnic_fcoe_start_fcf_disc(fnic);
282	break;
283	default:
284	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
285	"Unknown event 0x%x\n", fevt->event);
286	break;
287	}
288	kfree(objp: fevt);
289	}
290	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
291	}
292
293	/**
294	* is_fnic_fip_flogi_reject() - Check if the Received FIP FLOGI frame is rejected
295	* @fip: The FCoE controller that received the frame
296	* @skb: The received FIP frame
297	*
298	* Returns non-zero if the frame is rejected with unsupported cmd with
299	* insufficient resource els explanation.
300	*/
301	static inline int is_fnic_fip_flogi_reject(struct fcoe_ctlr *fip,
302	struct sk_buff *skb)
303	{
304	struct fc_lport *lport = fip->lp;
305	struct fip_header *fiph;
306	struct fc_frame_header *fh = NULL;
307	struct fip_desc *desc;
308	struct fip_encaps *els;
309	u16 op;
310	u8 els_op;
311	u8 sub;
312
313	size_t rlen;
314	size_t dlen = 0;
315
316	if (skb_linearize(skb))
317	return 0;
318
319	if (skb->len < sizeof(*fiph))
320	return 0;
321
322	fiph = (struct fip_header *)skb->data;
323	op = ntohs(fiph->fip_op);
324	sub = fiph->fip_subcode;
325
326	if (op != FIP_OP_LS)
327	return 0;
328
329	if (sub != FIP_SC_REP)
330	return 0;
331
332	rlen = ntohs(fiph->fip_dl_len) * 4;
333	if (rlen + sizeof(*fiph) > skb->len)
334	return 0;
335
336	desc = (struct fip_desc *)(fiph + 1);
337	dlen = desc->fip_dlen * FIP_BPW;
338
339	if (desc->fip_dtype == FIP_DT_FLOGI) {
340
341	if (dlen < sizeof(*els) + sizeof(*fh) + 1)
342	return 0;
343
344	els = (struct fip_encaps *)desc;
345	fh = (struct fc_frame_header *)(els + 1);
346
347	if (!fh)
348	return 0;
349
350	/*
351	* ELS command code, reason and explanation should be = Reject,
352	* unsupported command and insufficient resource
353	*/
354	els_op = *(u8 *)(fh + 1);
355	if (els_op == ELS_LS_RJT) {
356	shost_printk(KERN_INFO, lport->host,
357	"Flogi Request Rejected by Switch\n");
358	return 1;
359	}
360	shost_printk(KERN_INFO, lport->host,
361	"Flogi Request Accepted by Switch\n");
362	}
363	return 0;
364	}
365
366	static void fnic_fcoe_send_vlan_req(struct fnic *fnic)
367	{
368	struct fcoe_ctlr *fip = &fnic->ctlr;
369	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
370	struct sk_buff *skb;
371	char *eth_fr;
372	struct fip_vlan *vlan;
373	u64 vlan_tov;
374
375	fnic_fcoe_reset_vlans(fnic);
376	fnic->set_vlan(fnic, 0);
377
378	if (printk_ratelimit())
379	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
380	"Sending VLAN request...\n");
381
382	skb = dev_alloc_skb(length: sizeof(struct fip_vlan));
383	if (!skb)
384	return;
385
386	eth_fr = (char *)skb->data;
387	vlan = (struct fip_vlan *)eth_fr;
388
389	memset(vlan, 0, sizeof(*vlan));
390	memcpy(vlan->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
391	memcpy(vlan->eth.h_dest, fcoe_all_fcfs, ETH_ALEN);
392	vlan->eth.h_proto = htons(ETH_P_FIP);
393
394	vlan->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
395	vlan->fip.fip_op = htons(FIP_OP_VLAN);
396	vlan->fip.fip_subcode = FIP_SC_VL_REQ;
397	vlan->fip.fip_dl_len = htons(sizeof(vlan->desc) / FIP_BPW);
398
399	vlan->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC;
400	vlan->desc.mac.fd_desc.fip_dlen = sizeof(vlan->desc.mac) / FIP_BPW;
401	memcpy(&vlan->desc.mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
402
403	vlan->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
404	vlan->desc.wwnn.fd_desc.fip_dlen = sizeof(vlan->desc.wwnn) / FIP_BPW;
405	put_unaligned_be64(val: fip->lp->wwnn, p: &vlan->desc.wwnn.fd_wwn);
406	atomic64_inc(v: &fnic_stats->vlan_stats.vlan_disc_reqs);
407
408	skb_put(skb, len: sizeof(*vlan));
409	skb->protocol = htons(ETH_P_FIP);
410	skb_reset_mac_header(skb);
411	skb_reset_network_header(skb);
412	fip->send(fip, skb);
413
414	/* set a timer so that we can retry if there no response */
415	vlan_tov = jiffies + msecs_to_jiffies(FCOE_CTLR_FIPVLAN_TOV);
416	mod_timer(timer: &fnic->fip_timer, expires: round_jiffies(j: vlan_tov));
417	}
418
419	static void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct sk_buff *skb)
420	{
421	struct fcoe_ctlr *fip = &fnic->ctlr;
422	struct fip_header *fiph;
423	struct fip_desc *desc;
424	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
425	u16 vid;
426	size_t rlen;
427	size_t dlen;
428	struct fcoe_vlan *vlan;
429	u64 sol_time;
430	unsigned long flags;
431
432	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
433	"Received VLAN response...\n");
434
435	fiph = (struct fip_header *) skb->data;
436
437	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
438	"Received VLAN response... OP 0x%x SUB_OP 0x%x\n",
439	ntohs(fiph->fip_op), fiph->fip_subcode);
440
441	rlen = ntohs(fiph->fip_dl_len) * 4;
442	fnic_fcoe_reset_vlans(fnic);
443	spin_lock_irqsave(&fnic->vlans_lock, flags);
444	desc = (struct fip_desc *)(fiph + 1);
445	while (rlen > 0) {
446	dlen = desc->fip_dlen * FIP_BPW;
447	switch (desc->fip_dtype) {
448	case FIP_DT_VLAN:
449	vid = ntohs(((struct fip_vlan_desc *)desc)->fd_vlan);
450	shost_printk(KERN_INFO, fnic->lport->host,
451	"process_vlan_resp: FIP VLAN %d\n", vid);
452	vlan = kzalloc(size: sizeof(*vlan), GFP_ATOMIC);
453	if (!vlan) {
454	/* retry from timer */
455	spin_unlock_irqrestore(lock: &fnic->vlans_lock,
456	flags);
457	goto out;
458	}
459	vlan->vid = vid & 0x0fff;
460	vlan->state = FIP_VLAN_AVAIL;
461	list_add_tail(new: &vlan->list, head: &fnic->vlans);
462	break;
463	}
464	desc = (struct fip_desc *)((char *)desc + dlen);
465	rlen -= dlen;
466	}
467
468	/* any VLAN descriptors present ? */
469	if (list_empty(head: &fnic->vlans)) {
470	/* retry from timer */
471	atomic64_inc(v: &fnic_stats->vlan_stats.resp_withno_vlanID);
472	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
473	"No VLAN descriptors in FIP VLAN response\n");
474	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
475	goto out;
476	}
477
478	vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list);
479	fnic->set_vlan(fnic, vlan->vid);
480	vlan->state = FIP_VLAN_SENT; /* sent now */
481	vlan->sol_count++;
482	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
483
484	/* start the solicitation */
485	fcoe_ctlr_link_up(fip);
486
487	sol_time = jiffies + msecs_to_jiffies(FCOE_CTLR_START_DELAY);
488	mod_timer(timer: &fnic->fip_timer, expires: round_jiffies(j: sol_time));
489	out:
490	return;
491	}
492
493	static void fnic_fcoe_start_fcf_disc(struct fnic *fnic)
494	{
495	unsigned long flags;
496	struct fcoe_vlan *vlan;
497	u64 sol_time;
498
499	spin_lock_irqsave(&fnic->vlans_lock, flags);
500	vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list);
501	fnic->set_vlan(fnic, vlan->vid);
502	vlan->state = FIP_VLAN_SENT; /* sent now */
503	vlan->sol_count = 1;
504	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
505
506	/* start the solicitation */
507	fcoe_ctlr_link_up(&fnic->ctlr);
508
509	sol_time = jiffies + msecs_to_jiffies(FCOE_CTLR_START_DELAY);
510	mod_timer(timer: &fnic->fip_timer, expires: round_jiffies(j: sol_time));
511	}
512
513	static int fnic_fcoe_vlan_check(struct fnic *fnic, u16 flag)
514	{
515	unsigned long flags;
516	struct fcoe_vlan *fvlan;
517
518	spin_lock_irqsave(&fnic->vlans_lock, flags);
519	if (list_empty(head: &fnic->vlans)) {
520	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
521	return -EINVAL;
522	}
523
524	fvlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list);
525	if (fvlan->state == FIP_VLAN_USED) {
526	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
527	return 0;
528	}
529
530	if (fvlan->state == FIP_VLAN_SENT) {
531	fvlan->state = FIP_VLAN_USED;
532	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
533	return 0;
534	}
535	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
536	return -EINVAL;
537	}
538
539	static void fnic_event_enq(struct fnic *fnic, enum fnic_evt ev)
540	{
541	struct fnic_event *fevt;
542	unsigned long flags;
543
544	fevt = kmalloc(size: sizeof(*fevt), GFP_ATOMIC);
545	if (!fevt)
546	return;
547
548	fevt->fnic = fnic;
549	fevt->event = ev;
550
551	spin_lock_irqsave(&fnic->fnic_lock, flags);
552	list_add_tail(new: &fevt->list, head: &fnic->evlist);
553	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
554
555	schedule_work(work: &fnic->event_work);
556	}
557
558	static int fnic_fcoe_handle_fip_frame(struct fnic *fnic, struct sk_buff *skb)
559	{
560	struct fip_header *fiph;
561	int ret = 1;
562	u16 op;
563	u8 sub;
564
565	if (!skb || !(skb->data))
566	return -1;
567
568	if (skb_linearize(skb))
569	goto drop;
570
571	fiph = (struct fip_header *)skb->data;
572	op = ntohs(fiph->fip_op);
573	sub = fiph->fip_subcode;
574
575	if (FIP_VER_DECAPS(fiph->fip_ver) != FIP_VER)
576	goto drop;
577
578	if (ntohs(fiph->fip_dl_len) * FIP_BPW + sizeof(*fiph) > skb->len)
579	goto drop;
580
581	if (op == FIP_OP_DISC && sub == FIP_SC_ADV) {
582	if (fnic_fcoe_vlan_check(fnic, ntohs(fiph->fip_flags)))
583	goto drop;
584	/* pass it on to fcoe */
585	ret = 1;
586	} else if (op == FIP_OP_VLAN && sub == FIP_SC_VL_NOTE) {
587	/* set the vlan as used */
588	fnic_fcoe_process_vlan_resp(fnic, skb);
589	ret = 0;
590	} else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK) {
591	/* received CVL request, restart vlan disc */
592	fnic_event_enq(fnic, ev: FNIC_EVT_START_VLAN_DISC);
593	/* pass it on to fcoe */
594	ret = 1;
595	}
596	drop:
597	return ret;
598	}
599
600	void fnic_handle_fip_frame(struct work_struct *work)
601	{
602	struct fnic *fnic = container_of(work, struct fnic, fip_frame_work);
603	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
604	unsigned long flags;
605	struct sk_buff *skb;
606	struct ethhdr *eh;
607
608	while ((skb = skb_dequeue(list: &fnic->fip_frame_queue))) {
609	spin_lock_irqsave(&fnic->fnic_lock, flags);
610	if (fnic->stop_rx_link_events) {
611	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
612	dev_kfree_skb(skb);
613	return;
614	}
615	/*
616	* If we're in a transitional state, just re-queue and return.
617	* The queue will be serviced when we get to a stable state.
618	*/
619	if (fnic->state != FNIC_IN_FC_MODE &&
620	fnic->state != FNIC_IN_ETH_MODE) {
621	skb_queue_head(list: &fnic->fip_frame_queue, newsk: skb);
622	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
623	return;
624	}
625	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
626	eh = (struct ethhdr *)skb->data;
627	if (eh->h_proto == htons(ETH_P_FIP)) {
628	skb_pull(skb, len: sizeof(*eh));
629	if (fnic_fcoe_handle_fip_frame(fnic, skb) <= 0) {
630	dev_kfree_skb(skb);
631	continue;
632	}
633	/*
634	* If there's FLOGI rejects - clear all
635	* fcf's & restart from scratch
636	*/
637	if (is_fnic_fip_flogi_reject(fip: &fnic->ctlr, skb)) {
638	atomic64_inc(
639	v: &fnic_stats->vlan_stats.flogi_rejects);
640	shost_printk(KERN_INFO, fnic->lport->host,
641	"Trigger a Link down - VLAN Disc\n");
642	fcoe_ctlr_link_down(&fnic->ctlr);
643	/* start FCoE VLAN discovery */
644	fnic_fcoe_send_vlan_req(fnic);
645	dev_kfree_skb(skb);
646	continue;
647	}
648	fcoe_ctlr_recv(&fnic->ctlr, skb);
649	continue;
650	}
651	}
652	}
653
654	/**
655	* fnic_import_rq_eth_pkt() - handle received FCoE or FIP frame.
656	* @fnic: fnic instance.
657	* @skb: Ethernet Frame.
658	*/
659	static inline int fnic_import_rq_eth_pkt(struct fnic *fnic, struct sk_buff *skb)
660	{
661	struct fc_frame *fp;
662	struct ethhdr *eh;
663	struct fcoe_hdr *fcoe_hdr;
664	struct fcoe_crc_eof *ft;
665
666	/*
667	* Undo VLAN encapsulation if present.
668	*/
669	eh = (struct ethhdr *)skb->data;
670	if (eh->h_proto == htons(ETH_P_8021Q)) {
671	memmove((u8 *)eh + VLAN_HLEN, eh, ETH_ALEN * 2);
672	eh = skb_pull(skb, VLAN_HLEN);
673	skb_reset_mac_header(skb);
674	}
675	if (eh->h_proto == htons(ETH_P_FIP)) {
676	if (!(fnic->config.flags & VFCF_FIP_CAPABLE)) {
677	printk(KERN_ERR "Dropped FIP frame, as firmware "
678	"uses non-FIP mode, Enable FIP "
679	"using UCSM\n");
680	goto drop;
681	}
682	if ((fnic_fc_trace_set_data(host_no: fnic->lport->host->host_no,
683	FNIC_FC_RECV|0x80, frame: (char *)skb->data, fc_frame_len: skb->len)) != 0) {
684	printk(KERN_ERR "fnic ctlr frame trace error!!!");
685	}
686	skb_queue_tail(list: &fnic->fip_frame_queue, newsk: skb);
687	queue_work(wq: fnic_fip_queue, work: &fnic->fip_frame_work);
688	return 1; /* let caller know packet was used */
689	}
690	if (eh->h_proto != htons(ETH_P_FCOE))
691	goto drop;
692	skb_set_network_header(skb, offset: sizeof(*eh));
693	skb_pull(skb, len: sizeof(*eh));
694
695	fcoe_hdr = (struct fcoe_hdr *)skb->data;
696	if (FC_FCOE_DECAPS_VER(fcoe_hdr) != FC_FCOE_VER)
697	goto drop;
698
699	fp = (struct fc_frame *)skb;
700	fc_frame_init(fp);
701	fr_sof(fp) = fcoe_hdr->fcoe_sof;
702	skb_pull(skb, len: sizeof(struct fcoe_hdr));
703	skb_reset_transport_header(skb);
704
705	ft = (struct fcoe_crc_eof *)(skb->data + skb->len - sizeof(*ft));
706	fr_eof(fp) = ft->fcoe_eof;
707	skb_trim(skb, len: skb->len - sizeof(*ft));
708	return 0;
709	drop:
710	dev_kfree_skb_irq(skb);
711	return -1;
712	}
713
714	/**
715	* fnic_update_mac_locked() - set data MAC address and filters.
716	* @fnic: fnic instance.
717	* @new: newly-assigned FCoE MAC address.
718	*
719	* Called with the fnic lock held.
720	*/
721	void fnic_update_mac_locked(struct fnic *fnic, u8 *new)
722	{
723	u8 *ctl = fnic->ctlr.ctl_src_addr;
724	u8 *data = fnic->data_src_addr;
725
726	if (is_zero_ether_addr(addr: new))
727	new = ctl;
728	if (ether_addr_equal(addr1: data, addr2: new))
729	return;
730	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
731	"update_mac %pM\n", new);
732	if (!is_zero_ether_addr(addr: data) && !ether_addr_equal(addr1: data, addr2: ctl))
733	vnic_dev_del_addr(vdev: fnic->vdev, addr: data);
734	memcpy(data, new, ETH_ALEN);
735	if (!ether_addr_equal(addr1: new, addr2: ctl))
736	vnic_dev_add_addr(vdev: fnic->vdev, addr: new);
737	}
738
739	/**
740	* fnic_update_mac() - set data MAC address and filters.
741	* @lport: local port.
742	* @new: newly-assigned FCoE MAC address.
743	*/
744	void fnic_update_mac(struct fc_lport *lport, u8 *new)
745	{
746	struct fnic *fnic = lport_priv(lport);
747
748	spin_lock_irq(lock: &fnic->fnic_lock);
749	fnic_update_mac_locked(fnic, new);
750	spin_unlock_irq(lock: &fnic->fnic_lock);
751	}
752
753	/**
754	* fnic_set_port_id() - set the port_ID after successful FLOGI.
755	* @lport: local port.
756	* @port_id: assigned FC_ID.
757	* @fp: received frame containing the FLOGI accept or NULL.
758	*
759	* This is called from libfc when a new FC_ID has been assigned.
760	* This causes us to reset the firmware to FC_MODE and setup the new MAC
761	* address and FC_ID.
762	*
763	* It is also called with FC_ID 0 when we're logged off.
764	*
765	* If the FC_ID is due to point-to-point, fp may be NULL.
766	*/
767	void fnic_set_port_id(struct fc_lport *lport, u32 port_id, struct fc_frame *fp)
768	{
769	struct fnic *fnic = lport_priv(lport);
770	u8 *mac;
771	int ret;
772
773	FNIC_FCS_DBG(KERN_DEBUG, lport->host, fnic->fnic_num,
774	"set port_id 0x%x fp 0x%p\n",
775	port_id, fp);
776
777	/*
778	* If we're clearing the FC_ID, change to use the ctl_src_addr.
779	* Set ethernet mode to send FLOGI.
780	*/
781	if (!port_id) {
782	fnic_update_mac(lport, new: fnic->ctlr.ctl_src_addr);
783	fnic_set_eth_mode(fnic);
784	return;
785	}
786
787	if (fp) {
788	mac = fr_cb(fp)->granted_mac;
789	if (is_zero_ether_addr(addr: mac)) {
790	/* non-FIP - FLOGI already accepted - ignore return */
791	fcoe_ctlr_recv_flogi(&fnic->ctlr, lport, fp);
792	}
793	fnic_update_mac(lport, new: mac);
794	}
795
796	/* Change state to reflect transition to FC mode */
797	spin_lock_irq(lock: &fnic->fnic_lock);
798	if (fnic->state == FNIC_IN_ETH_MODE || fnic->state == FNIC_IN_FC_MODE)
799	fnic->state = FNIC_IN_ETH_TRANS_FC_MODE;
800	else {
801	FNIC_FCS_DBG(KERN_ERR, fnic->lport->host, fnic->fnic_num,
802	"Unexpected fnic state: %s processing FLOGI response",
803	fnic_state_to_str(fnic->state));
804	spin_unlock_irq(lock: &fnic->fnic_lock);
805	return;
806	}
807	spin_unlock_irq(lock: &fnic->fnic_lock);
808
809	/*
810	* Send FLOGI registration to firmware to set up FC mode.
811	* The new address will be set up when registration completes.
812	*/
813	ret = fnic_flogi_reg_handler(fnic, port_id);
814
815	if (ret < 0) {
816	spin_lock_irq(lock: &fnic->fnic_lock);
817	if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE)
818	fnic->state = FNIC_IN_ETH_MODE;
819	spin_unlock_irq(lock: &fnic->fnic_lock);
820	}
821	}
822
823	static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
824	*cq_desc, struct vnic_rq_buf *buf,
825	int skipped __attribute__((unused)),
826	void *opaque)
827	{
828	struct fnic *fnic = vnic_dev_priv(vdev: rq->vdev);
829	struct sk_buff *skb;
830	struct fc_frame *fp;
831	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
832	u8 type, color, eop, sop, ingress_port, vlan_stripped;
833	u8 fcoe = 0, fcoe_sof, fcoe_eof;
834	u8 fcoe_fc_crc_ok = 1, fcoe_enc_error = 0;
835	u8 tcp_udp_csum_ok, udp, tcp, ipv4_csum_ok;
836	u8 ipv6, ipv4, ipv4_fragment, rss_type, csum_not_calc;
837	u8 fcs_ok = 1, packet_error = 0;
838	u16 q_number, completed_index, bytes_written = 0, vlan, checksum;
839	u32 rss_hash;
840	u16 exchange_id, tmpl;
841	u8 sof = 0;
842	u8 eof = 0;
843	u32 fcp_bytes_written = 0;
844	unsigned long flags;
845
846	dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len,
847	DMA_FROM_DEVICE);
848	skb = buf->os_buf;
849	fp = (struct fc_frame *)skb;
850	buf->os_buf = NULL;
851
852	cq_desc_dec(desc_arg: cq_desc, type: &type, color: &color, q_number: &q_number, completed_index: &completed_index);
853	if (type == CQ_DESC_TYPE_RQ_FCP) {
854	cq_fcp_rq_desc_dec(desc_ptr: (struct cq_fcp_rq_desc *)cq_desc,
855	type: &type, color: &color, q_number: &q_number, completed_index: &completed_index,
856	eop: &eop, sop: &sop, fck: &fcoe_fc_crc_ok, exchange_id: &exchange_id,
857	tmpl: &tmpl, bytes_written: &fcp_bytes_written, sof: &sof, eof: &eof,
858	ingress_port: &ingress_port, packet_err: &packet_error,
859	fcoe_err: &fcoe_enc_error, fcs_ok: &fcs_ok, vlan_stripped: &vlan_stripped,
860	vlan: &vlan);
861	skb_trim(skb, len: fcp_bytes_written);
862	fr_sof(fp) = sof;
863	fr_eof(fp) = eof;
864
865	} else if (type == CQ_DESC_TYPE_RQ_ENET) {
866	cq_enet_rq_desc_dec(desc: (struct cq_enet_rq_desc *)cq_desc,
867	type: &type, color: &color, q_number: &q_number, completed_index: &completed_index,
868	ingress_port: &ingress_port, fcoe: &fcoe, eop: &eop, sop: &sop,
869	rss_type: &rss_type, csum_not_calc: &csum_not_calc, rss_hash: &rss_hash,
870	bytes_written: &bytes_written, packet_error: &packet_error,
871	vlan_stripped: &vlan_stripped, vlan: &vlan, checksum: &checksum,
872	fcoe_sof: &fcoe_sof, fcoe_fc_crc_ok: &fcoe_fc_crc_ok,
873	fcoe_enc_error: &fcoe_enc_error, fcoe_eof: &fcoe_eof,
874	tcp_udp_csum_ok: &tcp_udp_csum_ok, udp: &udp, tcp: &tcp,
875	ipv4_csum_ok: &ipv4_csum_ok, ipv6: &ipv6, ipv4: &ipv4,
876	ipv4_fragment: &ipv4_fragment, fcs_ok: &fcs_ok);
877	skb_trim(skb, len: bytes_written);
878	if (!fcs_ok) {
879	atomic64_inc(v: &fnic_stats->misc_stats.frame_errors);
880	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
881	"fcs error. dropping packet.\n");
882	goto drop;
883	}
884	if (fnic_import_rq_eth_pkt(fnic, skb))
885	return;
886
887	} else {
888	/* wrong CQ type*/
889	shost_printk(KERN_ERR, fnic->lport->host,
890	"fnic rq_cmpl wrong cq type x%x\n", type);
891	goto drop;
892	}
893
894	if (!fcs_ok || packet_error || !fcoe_fc_crc_ok || fcoe_enc_error) {
895	atomic64_inc(v: &fnic_stats->misc_stats.frame_errors);
896	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
897	"fnic rq_cmpl fcoe x%x fcsok x%x"
898	" pkterr x%x fcoe_fc_crc_ok x%x, fcoe_enc_err"
899	" x%x\n",
900	fcoe, fcs_ok, packet_error,
901	fcoe_fc_crc_ok, fcoe_enc_error);
902	goto drop;
903	}
904
905	spin_lock_irqsave(&fnic->fnic_lock, flags);
906	if (fnic->stop_rx_link_events) {
907	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
908	goto drop;
909	}
910	fr_dev(fp) = fnic->lport;
911	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
912	if ((fnic_fc_trace_set_data(host_no: fnic->lport->host->host_no, FNIC_FC_RECV,
913	frame: (char *)skb->data, fc_frame_len: skb->len)) != 0) {
914	printk(KERN_ERR "fnic ctlr frame trace error!!!");
915	}
916
917	skb_queue_tail(list: &fnic->frame_queue, newsk: skb);
918	queue_work(wq: fnic_event_queue, work: &fnic->frame_work);
919
920	return;
921	drop:
922	dev_kfree_skb_irq(skb);
923	}
924
925	static int fnic_rq_cmpl_handler_cont(struct vnic_dev *vdev,
926	struct cq_desc *cq_desc, u8 type,
927	u16 q_number, u16 completed_index,
928	void *opaque)
929	{
930	struct fnic *fnic = vnic_dev_priv(vdev);
931
932	vnic_rq_service(rq: &fnic->rq[q_number], cq_desc, completed_index,
933	desc_return: VNIC_RQ_RETURN_DESC, buf_service: fnic_rq_cmpl_frame_recv,
934	NULL);
935	return 0;
936	}
937
938	int fnic_rq_cmpl_handler(struct fnic *fnic, int rq_work_to_do)
939	{
940	unsigned int tot_rq_work_done = 0, cur_work_done;
941	unsigned int i;
942	int err;
943
944	for (i = 0; i < fnic->rq_count; i++) {
945	cur_work_done = vnic_cq_service(cq: &fnic->cq[i], work_to_do: rq_work_to_do,
946	q_service: fnic_rq_cmpl_handler_cont,
947	NULL);
948	if (cur_work_done) {
949	err = vnic_rq_fill(rq: &fnic->rq[i], buf_fill: fnic_alloc_rq_frame);
950	if (err)
951	shost_printk(KERN_ERR, fnic->lport->host,
952	"fnic_alloc_rq_frame can't alloc"
953	" frame\n");
954	}
955	tot_rq_work_done += cur_work_done;
956	}
957
958	return tot_rq_work_done;
959	}
960
961	/*
962	* This function is called once at init time to allocate and fill RQ
963	* buffers. Subsequently, it is called in the interrupt context after RQ
964	* buffer processing to replenish the buffers in the RQ
965	*/
966	int fnic_alloc_rq_frame(struct vnic_rq *rq)
967	{
968	struct fnic *fnic = vnic_dev_priv(vdev: rq->vdev);
969	struct sk_buff *skb;
970	u16 len;
971	dma_addr_t pa;
972	int r;
973
974	len = FC_FRAME_HEADROOM + FC_MAX_FRAME + FC_FRAME_TAILROOM;
975	skb = dev_alloc_skb(length: len);
976	if (!skb) {
977	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
978	"Unable to allocate RQ sk_buff\n");
979	return -ENOMEM;
980	}
981	skb_reset_mac_header(skb);
982	skb_reset_transport_header(skb);
983	skb_reset_network_header(skb);
984	skb_put(skb, len);
985	pa = dma_map_single(&fnic->pdev->dev, skb->data, len, DMA_FROM_DEVICE);
986	if (dma_mapping_error(dev: &fnic->pdev->dev, dma_addr: pa)) {
987	r = -ENOMEM;
988	printk(KERN_ERR "PCI mapping failed with error %d\n", r);
989	goto free_skb;
990	}
991
992	fnic_queue_rq_desc(rq, os_buf: skb, dma_addr: pa, len);
993	return 0;
994
995	free_skb:
996	kfree_skb(skb);
997	return r;
998	}
999
1000	void fnic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf)
1001	{
1002	struct fc_frame *fp = buf->os_buf;
1003	struct fnic *fnic = vnic_dev_priv(vdev: rq->vdev);
1004
1005	dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len,
1006	DMA_FROM_DEVICE);
1007
1008	dev_kfree_skb(fp_skb(fp));
1009	buf->os_buf = NULL;
1010	}
1011
1012	/**
1013	* fnic_eth_send() - Send Ethernet frame.
1014	* @fip: fcoe_ctlr instance.
1015	* @skb: Ethernet Frame, FIP, without VLAN encapsulation.
1016	*/
1017	void fnic_eth_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
1018	{
1019	struct fnic *fnic = fnic_from_ctlr(fip);
1020	struct vnic_wq *wq = &fnic->wq[0];
1021	dma_addr_t pa;
1022	struct ethhdr *eth_hdr;
1023	struct vlan_ethhdr *vlan_hdr;
1024	unsigned long flags;
1025
1026	if (!fnic->vlan_hw_insert) {
1027	eth_hdr = (struct ethhdr *)skb_mac_header(skb);
1028	vlan_hdr = skb_push(skb, len: sizeof(*vlan_hdr) - sizeof(*eth_hdr));
1029	memcpy(vlan_hdr, eth_hdr, 2 * ETH_ALEN);
1030	vlan_hdr->h_vlan_proto = htons(ETH_P_8021Q);
1031	vlan_hdr->h_vlan_encapsulated_proto = eth_hdr->h_proto;
1032	vlan_hdr->h_vlan_TCI = htons(fnic->vlan_id);
1033	if ((fnic_fc_trace_set_data(host_no: fnic->lport->host->host_no,
1034	FNIC_FC_SEND|0x80, frame: (char *)eth_hdr, fc_frame_len: skb->len)) != 0) {
1035	printk(KERN_ERR "fnic ctlr frame trace error!!!");
1036	}
1037	} else {
1038	if ((fnic_fc_trace_set_data(host_no: fnic->lport->host->host_no,
1039	FNIC_FC_SEND|0x80, frame: (char *)skb->data, fc_frame_len: skb->len)) != 0) {
1040	printk(KERN_ERR "fnic ctlr frame trace error!!!");
1041	}
1042	}
1043
1044	pa = dma_map_single(&fnic->pdev->dev, skb->data, skb->len,
1045	DMA_TO_DEVICE);
1046	if (dma_mapping_error(dev: &fnic->pdev->dev, dma_addr: pa)) {
1047	printk(KERN_ERR "DMA mapping failed\n");
1048	goto free_skb;
1049	}
1050
1051	spin_lock_irqsave(&fnic->wq_lock[0], flags);
1052	if (!vnic_wq_desc_avail(wq))
1053	goto irq_restore;
1054
1055	fnic_queue_wq_eth_desc(wq, os_buf: skb, dma_addr: pa, len: skb->len,
1056	vlan_tag_insert: 0 /* hw inserts cos value */,
1057	vlan_tag: fnic->vlan_id, cq_entry: 1);
1058	spin_unlock_irqrestore(lock: &fnic->wq_lock[0], flags);
1059	return;
1060
1061	irq_restore:
1062	spin_unlock_irqrestore(lock: &fnic->wq_lock[0], flags);
1063	dma_unmap_single(&fnic->pdev->dev, pa, skb->len, DMA_TO_DEVICE);
1064	free_skb:
1065	kfree_skb(skb);
1066	}
1067
1068	/*
1069	* Send FC frame.
1070	*/
1071	static int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
1072	{
1073	struct vnic_wq *wq = &fnic->wq[0];
1074	struct sk_buff *skb;
1075	dma_addr_t pa;
1076	struct ethhdr *eth_hdr;
1077	struct vlan_ethhdr *vlan_hdr;
1078	struct fcoe_hdr *fcoe_hdr;
1079	struct fc_frame_header *fh;
1080	u32 tot_len, eth_hdr_len;
1081	int ret = 0;
1082	unsigned long flags;
1083
1084	fh = fc_frame_header_get(fp);
1085	skb = fp_skb(fp);
1086
1087	if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ) &&
1088	fcoe_ctlr_els_send(&fnic->ctlr, fnic->lport, skb))
1089	return 0;
1090
1091	if (!fnic->vlan_hw_insert) {
1092	eth_hdr_len = sizeof(*vlan_hdr) + sizeof(*fcoe_hdr);
1093	vlan_hdr = skb_push(skb, len: eth_hdr_len);
1094	eth_hdr = (struct ethhdr *)vlan_hdr;
1095	vlan_hdr->h_vlan_proto = htons(ETH_P_8021Q);
1096	vlan_hdr->h_vlan_encapsulated_proto = htons(ETH_P_FCOE);
1097	vlan_hdr->h_vlan_TCI = htons(fnic->vlan_id);
1098	fcoe_hdr = (struct fcoe_hdr *)(vlan_hdr + 1);
1099	} else {
1100	eth_hdr_len = sizeof(*eth_hdr) + sizeof(*fcoe_hdr);
1101	eth_hdr = skb_push(skb, len: eth_hdr_len);
1102	eth_hdr->h_proto = htons(ETH_P_FCOE);
1103	fcoe_hdr = (struct fcoe_hdr *)(eth_hdr + 1);
1104	}
1105
1106	if (fnic->ctlr.map_dest)
1107	fc_fcoe_set_mac(mac: eth_hdr->h_dest, did: fh->fh_d_id);
1108	else
1109	memcpy(eth_hdr->h_dest, fnic->ctlr.dest_addr, ETH_ALEN);
1110	memcpy(eth_hdr->h_source, fnic->data_src_addr, ETH_ALEN);
1111
1112	tot_len = skb->len;
1113	BUG_ON(tot_len % 4);
1114
1115	memset(fcoe_hdr, 0, sizeof(*fcoe_hdr));
1116	fcoe_hdr->fcoe_sof = fr_sof(fp);
1117	if (FC_FCOE_VER)
1118	FC_FCOE_ENCAPS_VER(fcoe_hdr, FC_FCOE_VER);
1119
1120	pa = dma_map_single(&fnic->pdev->dev, eth_hdr, tot_len, DMA_TO_DEVICE);
1121	if (dma_mapping_error(dev: &fnic->pdev->dev, dma_addr: pa)) {
1122	ret = -ENOMEM;
1123	printk(KERN_ERR "DMA map failed with error %d\n", ret);
1124	goto free_skb_on_err;
1125	}
1126
1127	if ((fnic_fc_trace_set_data(host_no: fnic->lport->host->host_no, FNIC_FC_SEND,
1128	frame: (char *)eth_hdr, fc_frame_len: tot_len)) != 0) {
1129	printk(KERN_ERR "fnic ctlr frame trace error!!!");
1130	}
1131
1132	spin_lock_irqsave(&fnic->wq_lock[0], flags);
1133
1134	if (!vnic_wq_desc_avail(wq)) {
1135	dma_unmap_single(&fnic->pdev->dev, pa, tot_len, DMA_TO_DEVICE);
1136	ret = -1;
1137	goto irq_restore;
1138	}
1139
1140	fnic_queue_wq_desc(wq, os_buf: skb, dma_addr: pa, len: tot_len, fr_eof(fp),
1141	vlan_tag_insert: 0 /* hw inserts cos value */,
1142	vlan_tag: fnic->vlan_id, cq_entry: 1, sop: 1, eop: 1);
1143
1144	irq_restore:
1145	spin_unlock_irqrestore(lock: &fnic->wq_lock[0], flags);
1146
1147	free_skb_on_err:
1148	if (ret)
1149	dev_kfree_skb_any(fp_skb(fp));
1150
1151	return ret;
1152	}
1153
1154	/*
1155	* fnic_send
1156	* Routine to send a raw frame
1157	*/
1158	int fnic_send(struct fc_lport *lp, struct fc_frame *fp)
1159	{
1160	struct fnic *fnic = lport_priv(lport: lp);
1161	unsigned long flags;
1162
1163	if (fnic->in_remove) {
1164	dev_kfree_skb(fp_skb(fp));
1165	return -1;
1166	}
1167
1168	/*
1169	* Queue frame if in a transitional state.
1170	* This occurs while registering the Port_ID / MAC address after FLOGI.
1171	*/
1172	spin_lock_irqsave(&fnic->fnic_lock, flags);
1173	if (fnic->state != FNIC_IN_FC_MODE && fnic->state != FNIC_IN_ETH_MODE) {
1174	skb_queue_tail(list: &fnic->tx_queue, fp_skb(fp));
1175	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
1176	return 0;
1177	}
1178	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
1179
1180	return fnic_send_frame(fnic, fp);
1181	}
1182
1183	/**
1184	* fnic_flush_tx() - send queued frames.
1185	* @work: pointer to work element
1186	*
1187	* Send frames that were waiting to go out in FC or Ethernet mode.
1188	* Whenever changing modes we purge queued frames, so these frames should
1189	* be queued for the stable mode that we're in, either FC or Ethernet.
1190	*
1191	* Called without fnic_lock held.
1192	*/
1193	void fnic_flush_tx(struct work_struct *work)
1194	{
1195	struct fnic *fnic = container_of(work, struct fnic, flush_work);
1196	struct sk_buff *skb;
1197	struct fc_frame *fp;
1198
1199	while ((skb = skb_dequeue(list: &fnic->tx_queue))) {
1200	fp = (struct fc_frame *)skb;
1201	fnic_send_frame(fnic, fp);
1202	}
1203	}
1204
1205	/**
1206	* fnic_set_eth_mode() - put fnic into ethernet mode.
1207	* @fnic: fnic device
1208	*
1209	* Called without fnic lock held.
1210	*/
1211	static void fnic_set_eth_mode(struct fnic *fnic)
1212	{
1213	unsigned long flags;
1214	enum fnic_state old_state;
1215	int ret;
1216
1217	spin_lock_irqsave(&fnic->fnic_lock, flags);
1218	again:
1219	old_state = fnic->state;
1220	switch (old_state) {
1221	case FNIC_IN_FC_MODE:
1222	case FNIC_IN_ETH_TRANS_FC_MODE:
1223	default:
1224	fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
1225	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
1226
1227	ret = fnic_fw_reset_handler(fnic);
1228
1229	spin_lock_irqsave(&fnic->fnic_lock, flags);
1230	if (fnic->state != FNIC_IN_FC_TRANS_ETH_MODE)
1231	goto again;
1232	if (ret)
1233	fnic->state = old_state;
1234	break;
1235
1236	case FNIC_IN_FC_TRANS_ETH_MODE:
1237	case FNIC_IN_ETH_MODE:
1238	break;
1239	}
1240	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
1241	}
1242
1243	static void fnic_wq_complete_frame_send(struct vnic_wq *wq,
1244	struct cq_desc *cq_desc,
1245	struct vnic_wq_buf *buf, void *opaque)
1246	{
1247	struct sk_buff *skb = buf->os_buf;
1248	struct fc_frame *fp = (struct fc_frame *)skb;
1249	struct fnic *fnic = vnic_dev_priv(vdev: wq->vdev);
1250
1251	dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len,
1252	DMA_TO_DEVICE);
1253	dev_kfree_skb_irq(fp_skb(fp));
1254	buf->os_buf = NULL;
1255	}
1256
1257	static int fnic_wq_cmpl_handler_cont(struct vnic_dev *vdev,
1258	struct cq_desc *cq_desc, u8 type,
1259	u16 q_number, u16 completed_index,
1260	void *opaque)
1261	{
1262	struct fnic *fnic = vnic_dev_priv(vdev);
1263	unsigned long flags;
1264
1265	spin_lock_irqsave(&fnic->wq_lock[q_number], flags);
1266	vnic_wq_service(wq: &fnic->wq[q_number], cq_desc, completed_index,
1267	buf_service: fnic_wq_complete_frame_send, NULL);
1268	spin_unlock_irqrestore(lock: &fnic->wq_lock[q_number], flags);
1269
1270	return 0;
1271	}
1272
1273	int fnic_wq_cmpl_handler(struct fnic *fnic, int work_to_do)
1274	{
1275	unsigned int wq_work_done = 0;
1276	unsigned int i;
1277
1278	for (i = 0; i < fnic->raw_wq_count; i++) {
1279	wq_work_done += vnic_cq_service(cq: &fnic->cq[fnic->rq_count+i],
1280	work_to_do,
1281	q_service: fnic_wq_cmpl_handler_cont,
1282	NULL);
1283	}
1284
1285	return wq_work_done;
1286	}
1287
1288
1289	void fnic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf)
1290	{
1291	struct fc_frame *fp = buf->os_buf;
1292	struct fnic *fnic = vnic_dev_priv(vdev: wq->vdev);
1293
1294	dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len,
1295	DMA_TO_DEVICE);
1296
1297	dev_kfree_skb(fp_skb(fp));
1298	buf->os_buf = NULL;
1299	}
1300
1301	void fnic_fcoe_reset_vlans(struct fnic *fnic)
1302	{
1303	unsigned long flags;
1304	struct fcoe_vlan *vlan;
1305	struct fcoe_vlan *next;
1306
1307	/*
1308	* indicate a link down to fcoe so that all fcf's are free'd
1309	* might not be required since we did this before sending vlan
1310	* discovery request
1311	*/
1312	spin_lock_irqsave(&fnic->vlans_lock, flags);
1313	if (!list_empty(head: &fnic->vlans)) {
1314	list_for_each_entry_safe(vlan, next, &fnic->vlans, list) {
1315	list_del(entry: &vlan->list);
1316	kfree(objp: vlan);
1317	}
1318	}
1319	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
1320	}
1321
1322	void fnic_handle_fip_timer(struct fnic *fnic)
1323	{
1324	unsigned long flags;
1325	struct fcoe_vlan *vlan;
1326	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
1327	u64 sol_time;
1328
1329	spin_lock_irqsave(&fnic->fnic_lock, flags);
1330	if (fnic->stop_rx_link_events) {
1331	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
1332	return;
1333	}
1334	spin_unlock_irqrestore(lock: &fnic->fnic_lock, flags);
1335
1336	if (fnic->ctlr.mode == FIP_MODE_NON_FIP)
1337	return;
1338
1339	spin_lock_irqsave(&fnic->vlans_lock, flags);
1340	if (list_empty(head: &fnic->vlans)) {
1341	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
1342	/* no vlans available, try again */
1343	if (unlikely(fnic_log_level & FNIC_FCS_LOGGING))
1344	if (printk_ratelimit())
1345	shost_printk(KERN_DEBUG, fnic->lport->host,
1346	"Start VLAN Discovery\n");
1347	fnic_event_enq(fnic, ev: FNIC_EVT_START_VLAN_DISC);
1348	return;
1349	}
1350
1351	vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list);
1352	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
1353	"fip_timer: vlan %d state %d sol_count %d\n",
1354	vlan->vid, vlan->state, vlan->sol_count);
1355	switch (vlan->state) {
1356	case FIP_VLAN_USED:
1357	FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, fnic->fnic_num,
1358	"FIP VLAN is selected for FC transaction\n");
1359	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
1360	break;
1361	case FIP_VLAN_FAILED:
1362	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
1363	/* if all vlans are in failed state, restart vlan disc */
1364	if (unlikely(fnic_log_level & FNIC_FCS_LOGGING))
1365	if (printk_ratelimit())
1366	shost_printk(KERN_DEBUG, fnic->lport->host,
1367	"Start VLAN Discovery\n");
1368	fnic_event_enq(fnic, ev: FNIC_EVT_START_VLAN_DISC);
1369	break;
1370	case FIP_VLAN_SENT:
1371	if (vlan->sol_count >= FCOE_CTLR_MAX_SOL) {
1372	/*
1373	* no response on this vlan, remove from the list.
1374	* Try the next vlan
1375	*/
1376	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
1377	"Dequeue this VLAN ID %d from list\n",
1378	vlan->vid);
1379	list_del(entry: &vlan->list);
1380	kfree(objp: vlan);
1381	vlan = NULL;
1382	if (list_empty(head: &fnic->vlans)) {
1383	/* we exhausted all vlans, restart vlan disc */
1384	spin_unlock_irqrestore(lock: &fnic->vlans_lock,
1385	flags);
1386	FNIC_FCS_DBG(KERN_INFO, fnic->lport->host, fnic->fnic_num,
1387	"fip_timer: vlan list empty, "
1388	"trigger vlan disc\n");
1389	fnic_event_enq(fnic, ev: FNIC_EVT_START_VLAN_DISC);
1390	return;
1391	}
1392	/* check the next vlan */
1393	vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan,
1394	list);
1395	fnic->set_vlan(fnic, vlan->vid);
1396	vlan->state = FIP_VLAN_SENT; /* sent now */
1397	}
1398	spin_unlock_irqrestore(lock: &fnic->vlans_lock, flags);
1399	atomic64_inc(v: &fnic_stats->vlan_stats.sol_expiry_count);
1400	vlan->sol_count++;
1401	sol_time = jiffies + msecs_to_jiffies
1402	(FCOE_CTLR_START_DELAY);
1403	mod_timer(timer: &fnic->fip_timer, expires: round_jiffies(j: sol_time));
1404	break;
1405	}
1406	}
1407