1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved.
4	*
5	* Maintained at www.Open-FCoE.org
6	*/
7
8	#include <linux/module.h>
9	#include <linux/spinlock.h>
10	#include <linux/netdevice.h>
11	#include <linux/etherdevice.h>
12	#include <linux/ethtool.h>
13	#include <linux/if_ether.h>
14	#include <linux/if_vlan.h>
15	#include <linux/crc32.h>
16	#include <linux/slab.h>
17	#include <linux/cpu.h>
18	#include <linux/fs.h>
19	#include <linux/sysfs.h>
20	#include <linux/ctype.h>
21	#include <linux/workqueue.h>
22	#include <net/dcbnl.h>
23	#include <net/dcbevent.h>
24	#include <scsi/scsi_tcq.h>
25	#include <scsi/scsicam.h>
26	#include <scsi/scsi_transport.h>
27	#include <scsi/scsi_transport_fc.h>
28	#include <net/rtnetlink.h>
29
30	#include <scsi/fc/fc_encaps.h>
31	#include <scsi/fc/fc_fip.h>
32	#include <scsi/fc/fc_fcoe.h>
33
34	#include <scsi/libfc.h>
35	#include <scsi/fc_frame.h>
36	#include <scsi/libfcoe.h>
37
38	#include "fcoe.h"
39
40	MODULE_AUTHOR("Open-FCoE.org");
41	MODULE_DESCRIPTION("FCoE");
42	MODULE_LICENSE("GPL v2");
43
44	/* Performance tuning parameters for fcoe */
45	static unsigned int fcoe_ddp_min = 4096;
46	module_param_named(ddp_min, fcoe_ddp_min, uint, S_IRUGO | S_IWUSR);
47	MODULE_PARM_DESC(ddp_min, "Minimum I/O size in bytes for " \
48	"Direct Data Placement (DDP).");
49
50	unsigned int fcoe_debug_logging;
51	module_param_named(debug_logging, fcoe_debug_logging, int, S_IRUGO|S_IWUSR);
52	MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
53
54	static unsigned int fcoe_e_d_tov = 2 * 1000;
55	module_param_named(e_d_tov, fcoe_e_d_tov, int, S_IRUGO|S_IWUSR);
56	MODULE_PARM_DESC(e_d_tov, "E_D_TOV in ms, default 2000");
57
58	static unsigned int fcoe_r_a_tov = 2 * 2 * 1000;
59	module_param_named(r_a_tov, fcoe_r_a_tov, int, S_IRUGO|S_IWUSR);
60	MODULE_PARM_DESC(r_a_tov, "R_A_TOV in ms, default 4000");
61
62	static DEFINE_MUTEX(fcoe_config_mutex);
63
64	static struct workqueue_struct *fcoe_wq;
65
66	/* fcoe host list */
67	/* must only by accessed under the RTNL mutex */
68	static LIST_HEAD(fcoe_hostlist);
69	static DEFINE_PER_CPU(struct fcoe_percpu_s, fcoe_percpu);
70
71	/* Function Prototypes */
72	static int fcoe_reset(struct Scsi_Host *);
73	static int fcoe_xmit(struct fc_lport *, struct fc_frame *);
74	static int fcoe_rcv(struct sk_buff *, struct net_device *,
75	struct packet_type *, struct net_device *);
76	static void fcoe_percpu_clean(struct fc_lport *);
77	static int fcoe_link_ok(struct fc_lport *);
78
79	static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *);
80	static int fcoe_hostlist_add(const struct fc_lport *);
81	static void fcoe_hostlist_del(const struct fc_lport *);
82
83	static int fcoe_device_notification(struct notifier_block *, ulong, void *);
84	static void fcoe_dev_setup(void);
85	static void fcoe_dev_cleanup(void);
86	static struct fcoe_interface
87	*fcoe_hostlist_lookup_port(const struct net_device *);
88
89	static int fcoe_fip_recv(struct sk_buff *, struct net_device *,
90	struct packet_type *, struct net_device *);
91	static int fcoe_fip_vlan_recv(struct sk_buff *, struct net_device *,
92	struct packet_type *, struct net_device *);
93
94	static void fcoe_fip_send(struct fcoe_ctlr *, struct sk_buff *);
95	static void fcoe_update_src_mac(struct fc_lport *, u8 *);
96	static u8 *fcoe_get_src_mac(struct fc_lport *);
97	static void fcoe_destroy_work(struct work_struct *);
98
99	static int fcoe_ddp_setup(struct fc_lport *, u16, struct scatterlist *,
100	unsigned int);
101	static int fcoe_ddp_done(struct fc_lport *, u16);
102	static int fcoe_ddp_target(struct fc_lport *, u16, struct scatterlist *,
103	unsigned int);
104	static int fcoe_dcb_app_notification(struct notifier_block *notifier,
105	ulong event, void *ptr);
106
107	static bool fcoe_match(struct net_device *netdev);
108	static int fcoe_create(struct net_device *netdev, enum fip_mode fip_mode);
109	static int fcoe_destroy(struct net_device *netdev);
110	static int fcoe_enable(struct net_device *netdev);
111	static int fcoe_disable(struct net_device *netdev);
112
113	/* fcoe_syfs control interface handlers */
114	static int fcoe_ctlr_alloc(struct net_device *netdev);
115	static int fcoe_ctlr_enabled(struct fcoe_ctlr_device *cdev);
116	static void fcoe_ctlr_mode(struct fcoe_ctlr_device *ctlr_dev);
117
118	static struct fc_seq *fcoe_elsct_send(struct fc_lport *,
119	u32 did, struct fc_frame *,
120	unsigned int op,
121	void (*resp)(struct fc_seq *,
122	struct fc_frame *,
123	void *),
124	void *, u32 timeout);
125	static void fcoe_recv_frame(struct sk_buff *skb);
126
127	/* notification function for packets from net device */
128	static struct notifier_block fcoe_notifier = {
129	.notifier_call = fcoe_device_notification,
130	};
131
132	/* notification function for DCB events */
133	static struct notifier_block dcb_notifier = {
134	.notifier_call = fcoe_dcb_app_notification,
135	};
136
137	static struct scsi_transport_template *fcoe_nport_scsi_transport;
138	static struct scsi_transport_template *fcoe_vport_scsi_transport;
139
140	static int fcoe_vport_destroy(struct fc_vport *);
141	static int fcoe_vport_create(struct fc_vport *, bool disabled);
142	static int fcoe_vport_disable(struct fc_vport *, bool disable);
143	static void fcoe_set_vport_symbolic_name(struct fc_vport *);
144	static void fcoe_set_port_id(struct fc_lport *, u32, struct fc_frame *);
145	static void fcoe_fcf_get_vlan_id(struct fcoe_fcf_device *);
146	static void fcoe_vport_remove(struct fc_lport *);
147
148	static struct fcoe_sysfs_function_template fcoe_sysfs_templ = {
149	.set_fcoe_ctlr_mode = fcoe_ctlr_mode,
150	.set_fcoe_ctlr_enabled = fcoe_ctlr_enabled,
151	.get_fcoe_ctlr_link_fail = fcoe_ctlr_get_lesb,
152	.get_fcoe_ctlr_vlink_fail = fcoe_ctlr_get_lesb,
153	.get_fcoe_ctlr_miss_fka = fcoe_ctlr_get_lesb,
154	.get_fcoe_ctlr_symb_err = fcoe_ctlr_get_lesb,
155	.get_fcoe_ctlr_err_block = fcoe_ctlr_get_lesb,
156	.get_fcoe_ctlr_fcs_error = fcoe_ctlr_get_lesb,
157
158	.get_fcoe_fcf_selected = fcoe_fcf_get_selected,
159	.get_fcoe_fcf_vlan_id = fcoe_fcf_get_vlan_id,
160	};
161
162	static struct libfc_function_template fcoe_libfc_fcn_templ = {
163	.frame_send = fcoe_xmit,
164	.ddp_setup = fcoe_ddp_setup,
165	.ddp_done = fcoe_ddp_done,
166	.ddp_target = fcoe_ddp_target,
167	.elsct_send = fcoe_elsct_send,
168	.get_lesb = fcoe_get_lesb,
169	.lport_set_port_id = fcoe_set_port_id,
170	};
171
172	static struct fc_function_template fcoe_nport_fc_functions = {
173	.show_host_node_name = 1,
174	.show_host_port_name = 1,
175	.show_host_supported_classes = 1,
176	.show_host_supported_fc4s = 1,
177	.show_host_active_fc4s = 1,
178	.show_host_maxframe_size = 1,
179	.show_host_serial_number = 1,
180	.show_host_manufacturer = 1,
181	.show_host_model = 1,
182	.show_host_model_description = 1,
183	.show_host_hardware_version = 1,
184	.show_host_driver_version = 1,
185	.show_host_firmware_version = 1,
186	.show_host_optionrom_version = 1,
187
188	.show_host_port_id = 1,
189	.show_host_supported_speeds = 1,
190	.get_host_speed = fc_get_host_speed,
191	.show_host_speed = 1,
192	.show_host_port_type = 1,
193	.get_host_port_state = fc_get_host_port_state,
194	.show_host_port_state = 1,
195	.show_host_symbolic_name = 1,
196
197	.dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
198	.show_rport_maxframe_size = 1,
199	.show_rport_supported_classes = 1,
200
201	.show_host_fabric_name = 1,
202	.show_starget_node_name = 1,
203	.show_starget_port_name = 1,
204	.show_starget_port_id = 1,
205	.set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
206	.show_rport_dev_loss_tmo = 1,
207	.get_fc_host_stats = fc_get_host_stats,
208	.issue_fc_host_lip = fcoe_reset,
209
210	.terminate_rport_io = fc_rport_terminate_io,
211
212	.vport_create = fcoe_vport_create,
213	.vport_delete = fcoe_vport_destroy,
214	.vport_disable = fcoe_vport_disable,
215	.set_vport_symbolic_name = fcoe_set_vport_symbolic_name,
216
217	.bsg_request = fc_lport_bsg_request,
218	};
219
220	static struct fc_function_template fcoe_vport_fc_functions = {
221	.show_host_node_name = 1,
222	.show_host_port_name = 1,
223	.show_host_supported_classes = 1,
224	.show_host_supported_fc4s = 1,
225	.show_host_active_fc4s = 1,
226	.show_host_maxframe_size = 1,
227	.show_host_serial_number = 1,
228	.show_host_manufacturer = 1,
229	.show_host_model = 1,
230	.show_host_model_description = 1,
231	.show_host_hardware_version = 1,
232	.show_host_driver_version = 1,
233	.show_host_firmware_version = 1,
234	.show_host_optionrom_version = 1,
235
236	.show_host_port_id = 1,
237	.show_host_supported_speeds = 1,
238	.get_host_speed = fc_get_host_speed,
239	.show_host_speed = 1,
240	.show_host_port_type = 1,
241	.get_host_port_state = fc_get_host_port_state,
242	.show_host_port_state = 1,
243	.show_host_symbolic_name = 1,
244
245	.dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
246	.show_rport_maxframe_size = 1,
247	.show_rport_supported_classes = 1,
248
249	.show_host_fabric_name = 1,
250	.show_starget_node_name = 1,
251	.show_starget_port_name = 1,
252	.show_starget_port_id = 1,
253	.set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
254	.show_rport_dev_loss_tmo = 1,
255	.get_fc_host_stats = fc_get_host_stats,
256	.issue_fc_host_lip = fcoe_reset,
257
258	.terminate_rport_io = fc_rport_terminate_io,
259
260	.bsg_request = fc_lport_bsg_request,
261	};
262
263	static const struct scsi_host_template fcoe_shost_template = {
264	.module = THIS_MODULE,
265	.name = "FCoE Driver",
266	.proc_name = FCOE_NAME,
267	.queuecommand = fc_queuecommand,
268	.eh_timed_out = fc_eh_timed_out,
269	.eh_abort_handler = fc_eh_abort,
270	.eh_device_reset_handler = fc_eh_device_reset,
271	.eh_host_reset_handler = fc_eh_host_reset,
272	.slave_alloc = fc_slave_alloc,
273	.change_queue_depth = scsi_change_queue_depth,
274	.this_id = -1,
275	.cmd_per_lun = 3,
276	.can_queue = FCOE_MAX_OUTSTANDING_COMMANDS,
277	.sg_tablesize = SG_ALL,
278	.max_sectors = 0xffff,
279	.track_queue_depth = 1,
280	.cmd_size = sizeof(struct libfc_cmd_priv),
281	};
282
283	/**
284	* fcoe_interface_setup() - Setup a FCoE interface
285	* @fcoe: The new FCoE interface
286	* @netdev: The net device that the fcoe interface is on
287	*
288	* Returns : 0 for success
289	* Locking: must be called with the RTNL mutex held
290	*/
291	static int fcoe_interface_setup(struct fcoe_interface *fcoe,
292	struct net_device *netdev)
293	{
294	struct fcoe_ctlr *fip = fcoe_to_ctlr(fcoe);
295	struct netdev_hw_addr *ha;
296	struct net_device *real_dev;
297	static const u8 flogi_maddr[ETH_ALEN] = FC_FCOE_FLOGI_MAC;
298	const struct net_device_ops *ops;
299
300	fcoe->netdev = netdev;
301
302	/* Let LLD initialize for FCoE */
303	ops = netdev->netdev_ops;
304	if (ops->ndo_fcoe_enable) {
305	if (ops->ndo_fcoe_enable(netdev))
306	FCOE_NETDEV_DBG(netdev, "Failed to enable FCoE"
307	" specific feature for LLD.\n");
308	}
309
310	/* Do not support for bonding device */
311	if (netif_is_bond_master(dev: netdev)) {
312	FCOE_NETDEV_DBG(netdev, "Bonded interfaces not supported\n");
313	return -EOPNOTSUPP;
314	}
315
316	/* look for SAN MAC address, if multiple SAN MACs exist, only
317	* use the first one for SPMA */
318	real_dev = is_vlan_dev(dev: netdev) ? vlan_dev_real_dev(dev: netdev) : netdev;
319	fcoe->realdev = real_dev;
320	rcu_read_lock();
321	for_each_dev_addr(real_dev, ha) {
322	if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&
323	(is_valid_ether_addr(addr: ha->addr))) {
324	memcpy(fip->ctl_src_addr, ha->addr, ETH_ALEN);
325	fip->spma = 1;
326	break;
327	}
328	}
329	rcu_read_unlock();
330
331	/* setup Source Mac Address */
332	if (!fip->spma)
333	memcpy(fip->ctl_src_addr, netdev->dev_addr, netdev->addr_len);
334
335	/*
336	* Add FCoE MAC address as second unicast MAC address
337	* or enter promiscuous mode if not capable of listening
338	* for multiple unicast MACs.
339	*/
340	dev_uc_add(dev: netdev, addr: flogi_maddr);
341	if (fip->spma)
342	dev_uc_add(dev: netdev, addr: fip->ctl_src_addr);
343	if (fip->mode == FIP_MODE_VN2VN) {
344	dev_mc_add(dev: netdev, FIP_ALL_VN2VN_MACS);
345	dev_mc_add(dev: netdev, FIP_ALL_P2P_MACS);
346	} else
347	dev_mc_add(dev: netdev, FIP_ALL_ENODE_MACS);
348
349	/*
350	* setup the receive function from ethernet driver
351	* on the ethertype for the given device
352	*/
353	fcoe->fcoe_packet_type.func = fcoe_rcv;
354	fcoe->fcoe_packet_type.type = htons(ETH_P_FCOE);
355	fcoe->fcoe_packet_type.dev = netdev;
356	dev_add_pack(pt: &fcoe->fcoe_packet_type);
357
358	fcoe->fip_packet_type.func = fcoe_fip_recv;
359	fcoe->fip_packet_type.type = htons(ETH_P_FIP);
360	fcoe->fip_packet_type.dev = netdev;
361	dev_add_pack(pt: &fcoe->fip_packet_type);
362
363	if (netdev != real_dev) {
364	fcoe->fip_vlan_packet_type.func = fcoe_fip_vlan_recv;
365	fcoe->fip_vlan_packet_type.type = htons(ETH_P_FIP);
366	fcoe->fip_vlan_packet_type.dev = real_dev;
367	dev_add_pack(pt: &fcoe->fip_vlan_packet_type);
368	}
369	return 0;
370	}
371
372	/**
373	* fcoe_interface_create() - Create a FCoE interface on a net device
374	* @netdev: The net device to create the FCoE interface on
375	* @fip_mode: The mode to use for FIP
376	*
377	* Returns: pointer to a struct fcoe_interface or NULL on error
378	*/
379	static struct fcoe_interface *fcoe_interface_create(struct net_device *netdev,
380	enum fip_mode fip_mode)
381	{
382	struct fcoe_ctlr_device *ctlr_dev;
383	struct fcoe_ctlr *ctlr;
384	struct fcoe_interface *fcoe;
385	int size;
386	int err;
387
388	if (!try_module_get(THIS_MODULE)) {
389	FCOE_NETDEV_DBG(netdev,
390	"Could not get a reference to the module\n");
391	fcoe = ERR_PTR(error: -EBUSY);
392	goto out;
393	}
394
395	size = sizeof(struct fcoe_ctlr) + sizeof(struct fcoe_interface);
396	ctlr_dev = fcoe_ctlr_device_add(parent: &netdev->dev, f: &fcoe_sysfs_templ,
397	priv_size: size);
398	if (!ctlr_dev) {
399	FCOE_DBG("Failed to add fcoe_ctlr_device\n");
400	fcoe = ERR_PTR(error: -ENOMEM);
401	goto out_putmod;
402	}
403
404	ctlr = fcoe_ctlr_device_priv(ctlr: ctlr_dev);
405	ctlr->cdev = ctlr_dev;
406	fcoe = fcoe_ctlr_priv(ctlr);
407
408	dev_hold(dev: netdev);
409
410	/*
411	* Initialize FIP.
412	*/
413	fcoe_ctlr_init(ctlr, fip_mode);
414	ctlr->send = fcoe_fip_send;
415	ctlr->update_mac = fcoe_update_src_mac;
416	ctlr->get_src_addr = fcoe_get_src_mac;
417
418	err = fcoe_interface_setup(fcoe, netdev);
419	if (err) {
420	fcoe_ctlr_destroy(ctlr);
421	fcoe_ctlr_device_delete(ctlr_dev);
422	dev_put(dev: netdev);
423	fcoe = ERR_PTR(error: err);
424	goto out_putmod;
425	}
426
427	goto out;
428
429	out_putmod:
430	module_put(THIS_MODULE);
431	out:
432	return fcoe;
433	}
434
435	/**
436	* fcoe_interface_remove() - remove FCoE interface from netdev
437	* @fcoe: The FCoE interface to be cleaned up
438	*
439	* Caller must be holding the RTNL mutex
440	*/
441	static void fcoe_interface_remove(struct fcoe_interface *fcoe)
442	{
443	struct net_device *netdev = fcoe->netdev;
444	struct fcoe_ctlr *fip = fcoe_to_ctlr(fcoe);
445	static const u8 flogi_maddr[ETH_ALEN] = FC_FCOE_FLOGI_MAC;
446	const struct net_device_ops *ops;
447
448	/*
449	* Don't listen for Ethernet packets anymore.
450	* synchronize_net() ensures that the packet handlers are not running
451	* on another CPU. dev_remove_pack() would do that, this calls the
452	* unsyncronized version __dev_remove_pack() to avoid multiple delays.
453	*/
454	__dev_remove_pack(pt: &fcoe->fcoe_packet_type);
455	__dev_remove_pack(pt: &fcoe->fip_packet_type);
456	if (netdev != fcoe->realdev)
457	__dev_remove_pack(pt: &fcoe->fip_vlan_packet_type);
458	synchronize_net();
459
460	/* Delete secondary MAC addresses */
461	dev_uc_del(dev: netdev, addr: flogi_maddr);
462	if (fip->spma)
463	dev_uc_del(dev: netdev, addr: fip->ctl_src_addr);
464	if (fip->mode == FIP_MODE_VN2VN) {
465	dev_mc_del(dev: netdev, FIP_ALL_VN2VN_MACS);
466	dev_mc_del(dev: netdev, FIP_ALL_P2P_MACS);
467	} else
468	dev_mc_del(dev: netdev, FIP_ALL_ENODE_MACS);
469
470	/* Tell the LLD we are done w/ FCoE */
471	ops = netdev->netdev_ops;
472	if (ops->ndo_fcoe_disable) {
473	if (ops->ndo_fcoe_disable(netdev))
474	FCOE_NETDEV_DBG(netdev, "Failed to disable FCoE"
475	" specific feature for LLD.\n");
476	}
477	fcoe->removed = 1;
478	}
479
480
481	/**
482	* fcoe_interface_cleanup() - Clean up a FCoE interface
483	* @fcoe: The FCoE interface to be cleaned up
484	*/
485	static void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
486	{
487	struct net_device *netdev = fcoe->netdev;
488	struct fcoe_ctlr *fip = fcoe_to_ctlr(fcoe);
489
490	/* Release the self-reference taken during fcoe_interface_create() */
491	/* tear-down the FCoE controller */
492	fcoe_ctlr_destroy(fip);
493	scsi_host_put(t: fip->lp->host);
494	dev_put(dev: netdev);
495	module_put(THIS_MODULE);
496	}
497
498	/**
499	* fcoe_fip_recv() - Handler for received FIP frames
500	* @skb: The receive skb
501	* @netdev: The associated net device
502	* @ptype: The packet_type structure which was used to register this handler
503	* @orig_dev: The original net_device the skb was received on.
504	* (in case dev is a bond)
505	*
506	* Returns: 0 for success
507	*/
508	static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *netdev,
509	struct packet_type *ptype,
510	struct net_device *orig_dev)
511	{
512	struct fcoe_interface *fcoe;
513	struct fcoe_ctlr *ctlr;
514
515	fcoe = container_of(ptype, struct fcoe_interface, fip_packet_type);
516	ctlr = fcoe_to_ctlr(fcoe);
517	fcoe_ctlr_recv(ctlr, skb);
518	return 0;
519	}
520
521	/**
522	* fcoe_fip_vlan_recv() - Handler for received FIP VLAN discovery frames
523	* @skb: The receive skb
524	* @netdev: The associated net device
525	* @ptype: The packet_type structure which was used to register this handler
526	* @orig_dev: The original net_device the skb was received on.
527	* (in case dev is a bond)
528	*
529	* Returns: 0 for success
530	*/
531	static int fcoe_fip_vlan_recv(struct sk_buff *skb, struct net_device *netdev,
532	struct packet_type *ptype,
533	struct net_device *orig_dev)
534	{
535	struct fcoe_interface *fcoe;
536	struct fcoe_ctlr *ctlr;
537
538	fcoe = container_of(ptype, struct fcoe_interface, fip_vlan_packet_type);
539	ctlr = fcoe_to_ctlr(fcoe);
540	fcoe_ctlr_recv(ctlr, skb);
541	return 0;
542	}
543
544	/**
545	* fcoe_port_send() - Send an Ethernet-encapsulated FIP/FCoE frame
546	* @port: The FCoE port
547	* @skb: The FIP/FCoE packet to be sent
548	*/
549	static void fcoe_port_send(struct fcoe_port *port, struct sk_buff *skb)
550	{
551	if (port->fcoe_pending_queue.qlen)
552	fcoe_check_wait_queue(lport: port->lport, skb);
553	else if (fcoe_start_io(skb))
554	fcoe_check_wait_queue(lport: port->lport, skb);
555	}
556
557	/**
558	* fcoe_fip_send() - Send an Ethernet-encapsulated FIP frame
559	* @fip: The FCoE controller
560	* @skb: The FIP packet to be sent
561	*/
562	static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
563	{
564	struct fcoe_interface *fcoe = fcoe_from_ctlr(fip);
565	struct fip_frame {
566	struct ethhdr eth;
567	struct fip_header fip;
568	} __packed *frame;
569
570	/*
571	* Use default VLAN for FIP VLAN discovery protocol
572	*/
573	frame = (struct fip_frame *)skb->data;
574	if (ntohs(frame->eth.h_proto) == ETH_P_FIP &&
575	ntohs(frame->fip.fip_op) == FIP_OP_VLAN &&
576	fcoe->realdev != fcoe->netdev)
577	skb->dev = fcoe->realdev;
578	else
579	skb->dev = fcoe->netdev;
580	fcoe_port_send(port: lport_priv(lport: fip->lp), skb);
581	}
582
583	/**
584	* fcoe_update_src_mac() - Update the Ethernet MAC filters
585	* @lport: The local port to update the source MAC on
586	* @addr: Unicast MAC address to add
587	*
588	* Remove any previously-set unicast MAC filter.
589	* Add secondary FCoE MAC address filter for our OUI.
590	*/
591	static void fcoe_update_src_mac(struct fc_lport *lport, u8 *addr)
592	{
593	struct fcoe_port *port = lport_priv(lport);
594	struct fcoe_interface *fcoe = port->priv;
595
596	if (!is_zero_ether_addr(addr: port->data_src_addr))
597	dev_uc_del(dev: fcoe->netdev, addr: port->data_src_addr);
598	if (!is_zero_ether_addr(addr))
599	dev_uc_add(dev: fcoe->netdev, addr);
600	memcpy(port->data_src_addr, addr, ETH_ALEN);
601	}
602
603	/**
604	* fcoe_get_src_mac() - return the Ethernet source address for an lport
605	* @lport: libfc lport
606	*/
607	static u8 *fcoe_get_src_mac(struct fc_lport *lport)
608	{
609	struct fcoe_port *port = lport_priv(lport);
610
611	return port->data_src_addr;
612	}
613
614	/**
615	* fcoe_lport_config() - Set up a local port
616	* @lport: The local port to be setup
617	*
618	* Returns: 0 for success
619	*/
620	static int fcoe_lport_config(struct fc_lport *lport)
621	{
622	lport->link_up = 0;
623	lport->qfull = 0;
624	lport->max_retry_count = 3;
625	lport->max_rport_retry_count = 3;
626	lport->e_d_tov = fcoe_e_d_tov;
627	lport->r_a_tov = fcoe_r_a_tov;
628	lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
629	FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
630	lport->does_npiv = 1;
631
632	fc_lport_init_stats(lport);
633
634	/* lport fc_lport related configuration */
635	fc_lport_config(lport);
636
637	/* offload related configuration */
638	lport->crc_offload = 0;
639	lport->seq_offload = 0;
640	lport->lro_enabled = 0;
641	lport->lro_xid = 0;
642	lport->lso_max = 0;
643
644	return 0;
645	}
646
647	/*
648	* fcoe_netdev_features_change - Updates the lport's offload flags based
649	* on the LLD netdev's FCoE feature flags
650	*/
651	static void fcoe_netdev_features_change(struct fc_lport *lport,
652	struct net_device *netdev)
653	{
654	mutex_lock(&lport->lp_mutex);
655
656	if (netdev->features & NETIF_F_SG)
657	lport->sg_supp = 1;
658	else
659	lport->sg_supp = 0;
660
661	if (netdev->features & NETIF_F_FCOE_CRC) {
662	lport->crc_offload = 1;
663	FCOE_NETDEV_DBG(netdev, "Supports FCCRC offload\n");
664	} else {
665	lport->crc_offload = 0;
666	}
667
668	if (netdev->features & NETIF_F_FSO) {
669	lport->seq_offload = 1;
670	lport->lso_max = min(netdev->gso_max_size, GSO_LEGACY_MAX_SIZE);
671	FCOE_NETDEV_DBG(netdev, "Supports LSO for max len 0x%x\n",
672	lport->lso_max);
673	} else {
674	lport->seq_offload = 0;
675	lport->lso_max = 0;
676	}
677
678	if (netdev->fcoe_ddp_xid) {
679	lport->lro_enabled = 1;
680	lport->lro_xid = netdev->fcoe_ddp_xid;
681	FCOE_NETDEV_DBG(netdev, "Supports LRO for max xid 0x%x\n",
682	lport->lro_xid);
683	} else {
684	lport->lro_enabled = 0;
685	lport->lro_xid = 0;
686	}
687
688	mutex_unlock(lock: &lport->lp_mutex);
689	}
690
691	/**
692	* fcoe_netdev_config() - Set up net devive for SW FCoE
693	* @lport: The local port that is associated with the net device
694	* @netdev: The associated net device
695	*
696	* Must be called after fcoe_lport_config() as it will use local port mutex
697	*
698	* Returns: 0 for success
699	*/
700	static int fcoe_netdev_config(struct fc_lport *lport, struct net_device *netdev)
701	{
702	u32 mfs;
703	u64 wwnn, wwpn;
704	struct fcoe_interface *fcoe;
705	struct fcoe_ctlr *ctlr;
706	struct fcoe_port *port;
707
708	/* Setup lport private data to point to fcoe softc */
709	port = lport_priv(lport);
710	fcoe = port->priv;
711	ctlr = fcoe_to_ctlr(fcoe);
712
713	/* Figure out the VLAN ID, if any */
714	if (is_vlan_dev(dev: netdev))
715	lport->vlan = vlan_dev_vlan_id(dev: netdev);
716	else
717	lport->vlan = 0;
718
719	/*
720	* Determine max frame size based on underlying device and optional
721	* user-configured limit. If the MFS is too low, fcoe_link_ok()
722	* will return 0, so do this first.
723	*/
724	mfs = netdev->mtu;
725	if (netdev->features & NETIF_F_FCOE_MTU) {
726	mfs = FCOE_MTU;
727	FCOE_NETDEV_DBG(netdev, "Supports FCOE_MTU of %d bytes\n", mfs);
728	}
729	mfs -= (sizeof(struct fcoe_hdr) + sizeof(struct fcoe_crc_eof));
730	if (fc_set_mfs(lport, mfs))
731	return -EINVAL;
732
733	/* offload features support */
734	fcoe_netdev_features_change(lport, netdev);
735
736	skb_queue_head_init(list: &port->fcoe_pending_queue);
737	port->fcoe_pending_queue_active = 0;
738	timer_setup(&port->timer, fcoe_queue_timer, 0);
739
740	fcoe_link_speed_update(lport);
741
742	if (!lport->vport) {
743	if (fcoe_get_wwn(netdev, wwn: &wwnn, NETDEV_FCOE_WWNN))
744	wwnn = fcoe_wwn_from_mac(mac: ctlr->ctl_src_addr, scheme: 1, port: 0);
745	fc_set_wwnn(lport, wwnn);
746	if (fcoe_get_wwn(netdev, wwn: &wwpn, NETDEV_FCOE_WWPN))
747	wwpn = fcoe_wwn_from_mac(mac: ctlr->ctl_src_addr,
748	scheme: 2, port: 0);
749	fc_set_wwpn(lport, wwpn);
750	}
751
752	return 0;
753	}
754
755	/**
756	* fcoe_shost_config() - Set up the SCSI host associated with a local port
757	* @lport: The local port
758	* @dev: The device associated with the SCSI host
759	*
760	* Must be called after fcoe_lport_config() and fcoe_netdev_config()
761	*
762	* Returns: 0 for success
763	*/
764	static int fcoe_shost_config(struct fc_lport *lport, struct device *dev)
765	{
766	int rc = 0;
767
768	/* lport scsi host config */
769	lport->host->max_lun = FCOE_MAX_LUN;
770	lport->host->max_id = FCOE_MAX_FCP_TARGET;
771	lport->host->max_channel = 0;
772	lport->host->max_cmd_len = FCOE_MAX_CMD_LEN;
773
774	if (lport->vport)
775	lport->host->transportt = fcoe_vport_scsi_transport;
776	else
777	lport->host->transportt = fcoe_nport_scsi_transport;
778
779	/* add the new host to the SCSI-ml */
780	rc = scsi_add_host(host: lport->host, dev);
781	if (rc) {
782	FCOE_NETDEV_DBG(fcoe_netdev(lport), "fcoe_shost_config: "
783	"error on scsi_add_host\n");
784	return rc;
785	}
786
787	if (!lport->vport)
788	fc_host_max_npiv_vports(lport->host) = USHRT_MAX;
789
790	snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
791	fmt: "%s v%s over %s", FCOE_NAME, FCOE_VERSION,
792	fcoe_netdev(lport)->name);
793
794	return 0;
795	}
796
797
798	/**
799	* fcoe_fdmi_info() - Get FDMI related info from net devive for SW FCoE
800	* @lport: The local port that is associated with the net device
801	* @netdev: The associated net device
802	*
803	* Must be called after fcoe_shost_config() as it will use local port mutex
804	*
805	*/
806	static void fcoe_fdmi_info(struct fc_lport *lport, struct net_device *netdev)
807	{
808	struct fcoe_interface *fcoe;
809	struct fcoe_port *port;
810	struct net_device *realdev;
811	int rc;
812
813	port = lport_priv(lport);
814	fcoe = port->priv;
815	realdev = fcoe->realdev;
816
817	/* No FDMI state m/c for NPIV ports */
818	if (lport->vport)
819	return;
820
821	if (realdev->netdev_ops->ndo_fcoe_get_hbainfo) {
822	struct netdev_fcoe_hbainfo *fdmi;
823	fdmi = kzalloc(size: sizeof(*fdmi), GFP_KERNEL);
824	if (!fdmi)
825	return;
826
827	rc = realdev->netdev_ops->ndo_fcoe_get_hbainfo(realdev,
828	fdmi);
829	if (rc) {
830	printk(KERN_INFO "fcoe: Failed to retrieve FDMI "
831	"information from netdev.\n");
832	return;
833	}
834
835	snprintf(fc_host_serial_number(lport->host),
836	FC_SERIAL_NUMBER_SIZE,
837	fmt: "%s",
838	fdmi->serial_number);
839	snprintf(fc_host_manufacturer(lport->host),
840	FC_SERIAL_NUMBER_SIZE,
841	fmt: "%s",
842	fdmi->manufacturer);
843	snprintf(fc_host_model(lport->host),
844	FC_SYMBOLIC_NAME_SIZE,
845	fmt: "%s",
846	fdmi->model);
847	snprintf(fc_host_model_description(lport->host),
848	FC_SYMBOLIC_NAME_SIZE,
849	fmt: "%s",
850	fdmi->model_description);
851	snprintf(fc_host_hardware_version(lport->host),
852	FC_VERSION_STRING_SIZE,
853	fmt: "%s",
854	fdmi->hardware_version);
855	snprintf(fc_host_driver_version(lport->host),
856	FC_VERSION_STRING_SIZE,
857	fmt: "%s",
858	fdmi->driver_version);
859	snprintf(fc_host_optionrom_version(lport->host),
860	FC_VERSION_STRING_SIZE,
861	fmt: "%s",
862	fdmi->optionrom_version);
863	snprintf(fc_host_firmware_version(lport->host),
864	FC_VERSION_STRING_SIZE,
865	fmt: "%s",
866	fdmi->firmware_version);
867
868	/* Enable FDMI lport states */
869	lport->fdmi_enabled = 1;
870	kfree(objp: fdmi);
871	} else {
872	lport->fdmi_enabled = 0;
873	printk(KERN_INFO "fcoe: No FDMI support.\n");
874	}
875	}
876
877	/**
878	* fcoe_oem_match() - The match routine for the offloaded exchange manager
879	* @fp: The I/O frame
880	*
881	* This routine will be associated with an exchange manager (EM). When
882	* the libfc exchange handling code is looking for an EM to use it will
883	* call this routine and pass it the frame that it wishes to send. This
884	* routine will return True if the associated EM is to be used and False
885	* if the echange code should continue looking for an EM.
886	*
887	* The offload EM that this routine is associated with will handle any
888	* packets that are for SCSI read requests.
889	*
890	* This has been enhanced to work when FCoE stack is operating in target
891	* mode.
892	*
893	* Returns: True for read types I/O, otherwise returns false.
894	*/
895	static bool fcoe_oem_match(struct fc_frame *fp)
896	{
897	struct fc_frame_header *fh = fc_frame_header_get(fp);
898	struct fcp_cmnd *fcp;
899
900	if (fc_fcp_is_read(fr_fsp(fp)) &&
901	(fr_fsp(fp)->data_len > fcoe_ddp_min))
902	return true;
903	else if ((fr_fsp(fp) == NULL) &&
904	(fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD) &&
905	(ntohs(fh->fh_rx_id) == FC_XID_UNKNOWN)) {
906	fcp = fc_frame_payload_get(fp, len: sizeof(*fcp));
907	if ((fcp->fc_flags & FCP_CFL_WRDATA) &&
908	(ntohl(fcp->fc_dl) > fcoe_ddp_min))
909	return true;
910	}
911	return false;
912	}
913
914	/**
915	* fcoe_em_config() - Allocate and configure an exchange manager
916	* @lport: The local port that the new EM will be associated with
917	*
918	* Returns: 0 on success
919	*/
920	static inline int fcoe_em_config(struct fc_lport *lport)
921	{
922	struct fcoe_port *port = lport_priv(lport);
923	struct fcoe_interface *fcoe = port->priv;
924	struct fcoe_interface *oldfcoe = NULL;
925	struct net_device *old_real_dev, *cur_real_dev;
926	u16 min_xid = FCOE_MIN_XID;
927	u16 max_xid = FCOE_MAX_XID;
928
929	/*
930	* Check if need to allocate an em instance for
931	* offload exchange ids to be shared across all VN_PORTs/lport.
932	*/
933	if (!lport->lro_enabled || !lport->lro_xid ||
934	(lport->lro_xid >= max_xid)) {
935	lport->lro_xid = 0;
936	goto skip_oem;
937	}
938
939	/*
940	* Reuse existing offload em instance in case
941	* it is already allocated on real eth device
942	*/
943	if (is_vlan_dev(dev: fcoe->netdev))
944	cur_real_dev = vlan_dev_real_dev(dev: fcoe->netdev);
945	else
946	cur_real_dev = fcoe->netdev;
947
948	list_for_each_entry(oldfcoe, &fcoe_hostlist, list) {
949	if (is_vlan_dev(dev: oldfcoe->netdev))
950	old_real_dev = vlan_dev_real_dev(dev: oldfcoe->netdev);
951	else
952	old_real_dev = oldfcoe->netdev;
953
954	if (cur_real_dev == old_real_dev) {
955	fcoe->oem = oldfcoe->oem;
956	break;
957	}
958	}
959
960	if (fcoe->oem) {
961	if (!fc_exch_mgr_add(lport, fcoe->oem, match: fcoe_oem_match)) {
962	printk(KERN_ERR "fcoe_em_config: failed to add "
963	"offload em:%p on interface:%s\n",
964	fcoe->oem, fcoe->netdev->name);
965	return -ENOMEM;
966	}
967	} else {
968	fcoe->oem = fc_exch_mgr_alloc(lport, class: FC_CLASS_3,
969	FCOE_MIN_XID, max_xid: lport->lro_xid,
970	match: fcoe_oem_match);
971	if (!fcoe->oem) {
972	printk(KERN_ERR "fcoe_em_config: failed to allocate "
973	"em for offload exches on interface:%s\n",
974	fcoe->netdev->name);
975	return -ENOMEM;
976	}
977	}
978
979	/*
980	* Exclude offload EM xid range from next EM xid range.
981	*/
982	min_xid += lport->lro_xid + 1;
983
984	skip_oem:
985	if (!fc_exch_mgr_alloc(lport, class: FC_CLASS_3, min_xid, max_xid, NULL)) {
986	printk(KERN_ERR "fcoe_em_config: failed to "
987	"allocate em on interface %s\n", fcoe->netdev->name);
988	return -ENOMEM;
989	}
990
991	return 0;
992	}
993
994	/**
995	* fcoe_if_destroy() - Tear down a SW FCoE instance
996	* @lport: The local port to be destroyed
997	*
998	* Locking: Must be called with the RTNL mutex held.
999	*
1000	*/
1001	static void fcoe_if_destroy(struct fc_lport *lport)
1002	{
1003	struct fcoe_port *port = lport_priv(lport);
1004	struct fcoe_interface *fcoe = port->priv;
1005	struct net_device *netdev = fcoe->netdev;
1006
1007	FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
1008
1009	/* Logout of the fabric */
1010	fc_fabric_logoff(lport);
1011
1012	/* Cleanup the fc_lport */
1013	fc_lport_destroy(lport);
1014
1015	/* Stop the transmit retry timer */
1016	del_timer_sync(timer: &port->timer);
1017
1018	/* Free existing transmit skbs */
1019	fcoe_clean_pending_queue(lport);
1020
1021	if (!is_zero_ether_addr(addr: port->data_src_addr))
1022	dev_uc_del(dev: netdev, addr: port->data_src_addr);
1023	if (lport->vport)
1024	synchronize_net();
1025	else
1026	fcoe_interface_remove(fcoe);
1027
1028	/* Free queued packets for the per-CPU receive threads */
1029	fcoe_percpu_clean(lport);
1030
1031	/* Detach from the scsi-ml */
1032	fc_remove_host(lport->host);
1033	scsi_remove_host(lport->host);
1034
1035	/* Destroy lport scsi_priv */
1036	fc_fcp_destroy(lport);
1037
1038	/* There are no more rports or I/O, free the EM */
1039	fc_exch_mgr_free(lport);
1040
1041	/* Free memory used by statistical counters */
1042	fc_lport_free_stats(lport);
1043
1044	/*
1045	* Release the Scsi_Host for vport but hold on to
1046	* master lport until it fcoe interface fully cleaned-up.
1047	*/
1048	if (lport->vport)
1049	scsi_host_put(t: lport->host);
1050	}
1051
1052	/**
1053	* fcoe_ddp_setup() - Call a LLD's ddp_setup through the net device
1054	* @lport: The local port to setup DDP for
1055	* @xid: The exchange ID for this DDP transfer
1056	* @sgl: The scatterlist describing this transfer
1057	* @sgc: The number of sg items
1058	*
1059	* Returns: 0 if the DDP context was not configured
1060	*/
1061	static int fcoe_ddp_setup(struct fc_lport *lport, u16 xid,
1062	struct scatterlist *sgl, unsigned int sgc)
1063	{
1064	struct net_device *netdev = fcoe_netdev(lport);
1065
1066	if (netdev->netdev_ops->ndo_fcoe_ddp_setup)
1067	return netdev->netdev_ops->ndo_fcoe_ddp_setup(netdev,
1068	xid, sgl,
1069	sgc);
1070
1071	return 0;
1072	}
1073
1074	/**
1075	* fcoe_ddp_target() - Call a LLD's ddp_target through the net device
1076	* @lport: The local port to setup DDP for
1077	* @xid: The exchange ID for this DDP transfer
1078	* @sgl: The scatterlist describing this transfer
1079	* @sgc: The number of sg items
1080	*
1081	* Returns: 0 if the DDP context was not configured
1082	*/
1083	static int fcoe_ddp_target(struct fc_lport *lport, u16 xid,
1084	struct scatterlist *sgl, unsigned int sgc)
1085	{
1086	struct net_device *netdev = fcoe_netdev(lport);
1087
1088	if (netdev->netdev_ops->ndo_fcoe_ddp_target)
1089	return netdev->netdev_ops->ndo_fcoe_ddp_target(netdev, xid,
1090	sgl, sgc);
1091
1092	return 0;
1093	}
1094
1095
1096	/**
1097	* fcoe_ddp_done() - Call a LLD's ddp_done through the net device
1098	* @lport: The local port to complete DDP on
1099	* @xid: The exchange ID for this DDP transfer
1100	*
1101	* Returns: the length of data that have been completed by DDP
1102	*/
1103	static int fcoe_ddp_done(struct fc_lport *lport, u16 xid)
1104	{
1105	struct net_device *netdev = fcoe_netdev(lport);
1106
1107	if (netdev->netdev_ops->ndo_fcoe_ddp_done)
1108	return netdev->netdev_ops->ndo_fcoe_ddp_done(netdev, xid);
1109	return 0;
1110	}
1111
1112	/**
1113	* fcoe_if_create() - Create a FCoE instance on an interface
1114	* @fcoe: The FCoE interface to create a local port on
1115	* @parent: The device pointer to be the parent in sysfs for the SCSI host
1116	* @npiv: Indicates if the port is a vport or not
1117	*
1118	* Creates a fc_lport instance and a Scsi_Host instance and configure them.
1119	*
1120	* Returns: The allocated fc_lport or an error pointer
1121	*/
1122	static struct fc_lport *fcoe_if_create(struct fcoe_interface *fcoe,
1123	struct device *parent, int npiv)
1124	{
1125	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
1126	struct net_device *netdev = fcoe->netdev;
1127	struct fc_lport *lport, *n_port;
1128	struct fcoe_port *port;
1129	struct Scsi_Host *shost;
1130	int rc;
1131	/*
1132	* parent is only a vport if npiv is 1,
1133	* but we'll only use vport in that case so go ahead and set it
1134	*/
1135	struct fc_vport *vport = dev_to_vport(parent);
1136
1137	FCOE_NETDEV_DBG(netdev, "Create Interface\n");
1138
1139	if (!npiv)
1140	lport = libfc_host_alloc(sht: &fcoe_shost_template, priv_size: sizeof(*port));
1141	else
1142	lport = libfc_vport_create(vport, privsize: sizeof(*port));
1143
1144	if (!lport) {
1145	FCOE_NETDEV_DBG(netdev, "Could not allocate host structure\n");
1146	rc = -ENOMEM;
1147	goto out;
1148	}
1149	port = lport_priv(lport);
1150	port->lport = lport;
1151	port->priv = fcoe;
1152	port->get_netdev = fcoe_netdev;
1153	port->max_queue_depth = FCOE_MAX_QUEUE_DEPTH;
1154	port->min_queue_depth = FCOE_MIN_QUEUE_DEPTH;
1155	INIT_WORK(&port->destroy_work, fcoe_destroy_work);
1156
1157	/*
1158	* Need to add the lport to the hostlist
1159	* so we catch NETDEV_CHANGE events.
1160	*/
1161	fcoe_hostlist_add(lport);
1162
1163	/* configure a fc_lport including the exchange manager */
1164	rc = fcoe_lport_config(lport);
1165	if (rc) {
1166	FCOE_NETDEV_DBG(netdev, "Could not configure lport for the "
1167	"interface\n");
1168	goto out_host_put;
1169	}
1170
1171	if (npiv) {
1172	FCOE_NETDEV_DBG(netdev, "Setting vport names, "
1173	"%16.16llx %16.16llx\n",
1174	vport->node_name, vport->port_name);
1175	fc_set_wwnn(lport, wwnn: vport->node_name);
1176	fc_set_wwpn(lport, wwpn: vport->port_name);
1177	}
1178
1179	/* configure lport network properties */
1180	rc = fcoe_netdev_config(lport, netdev);
1181	if (rc) {
1182	FCOE_NETDEV_DBG(netdev, "Could not configure netdev for the "
1183	"interface\n");
1184	goto out_lp_destroy;
1185	}
1186
1187	/* configure lport scsi host properties */
1188	rc = fcoe_shost_config(lport, dev: parent);
1189	if (rc) {
1190	FCOE_NETDEV_DBG(netdev, "Could not configure shost for the "
1191	"interface\n");
1192	goto out_lp_destroy;
1193	}
1194
1195	/* Initialize the library */
1196	rc = fcoe_libfc_config(lport, ctlr, &fcoe_libfc_fcn_templ, init_fcp: 1);
1197	if (rc) {
1198	FCOE_NETDEV_DBG(netdev, "Could not configure libfc for the "
1199	"interface\n");
1200	goto out_lp_destroy;
1201	}
1202
1203	/* Initialized FDMI information */
1204	fcoe_fdmi_info(lport, netdev);
1205
1206	/*
1207	* fcoe_em_alloc() and fcoe_hostlist_add() both
1208	* need to be atomic with respect to other changes to the
1209	* hostlist since fcoe_em_alloc() looks for an existing EM
1210	* instance on host list updated by fcoe_hostlist_add().
1211	*
1212	* This is currently handled through the fcoe_config_mutex
1213	* begin held.
1214	*/
1215	if (!npiv)
1216	/* lport exch manager allocation */
1217	rc = fcoe_em_config(lport);
1218	else {
1219	shost = vport_to_shost(vport);
1220	n_port = shost_priv(shost);
1221	rc = fc_exch_mgr_list_clone(src: n_port, dst: lport);
1222	}
1223
1224	if (rc) {
1225	FCOE_NETDEV_DBG(netdev, "Could not configure the EM\n");
1226	goto out_lp_destroy;
1227	}
1228
1229	return lport;
1230
1231	out_lp_destroy:
1232	fc_exch_mgr_free(lport);
1233	out_host_put:
1234	fcoe_hostlist_del(lport);
1235	scsi_host_put(t: lport->host);
1236	out:
1237	return ERR_PTR(error: rc);
1238	}
1239
1240	/**
1241	* fcoe_if_init() - Initialization routine for fcoe.ko
1242	*
1243	* Attaches the SW FCoE transport to the FC transport
1244	*
1245	* Returns: 0 on success
1246	*/
1247	static int __init fcoe_if_init(void)
1248	{
1249	/* attach to scsi transport */
1250	fcoe_nport_scsi_transport =
1251	fc_attach_transport(&fcoe_nport_fc_functions);
1252	if (!fcoe_nport_scsi_transport)
1253	goto err;
1254
1255	fcoe_vport_scsi_transport =
1256	fc_attach_transport(&fcoe_vport_fc_functions);
1257	if (!fcoe_vport_scsi_transport)
1258	goto err_vport;
1259
1260	return 0;
1261
1262	err_vport:
1263	fc_release_transport(fcoe_nport_scsi_transport);
1264	err:
1265	printk(KERN_ERR "fcoe: Failed to attach to the FC transport\n");
1266	return -ENODEV;
1267	}
1268
1269	/**
1270	* fcoe_if_exit() - Tear down fcoe.ko
1271	*
1272	* Detaches the SW FCoE transport from the FC transport
1273	*
1274	* Returns: 0 on success
1275	*/
1276	static int __exit fcoe_if_exit(void)
1277	{
1278	fc_release_transport(fcoe_nport_scsi_transport);
1279	fc_release_transport(fcoe_vport_scsi_transport);
1280	fcoe_nport_scsi_transport = NULL;
1281	fcoe_vport_scsi_transport = NULL;
1282	return 0;
1283	}
1284
1285	static void fcoe_thread_cleanup_local(unsigned int cpu)
1286	{
1287	struct page *crc_eof;
1288	struct fcoe_percpu_s *p;
1289
1290	p = per_cpu_ptr(&fcoe_percpu, cpu);
1291	spin_lock_bh(lock: &p->fcoe_rx_list.lock);
1292	crc_eof = p->crc_eof_page;
1293	p->crc_eof_page = NULL;
1294	p->crc_eof_offset = 0;
1295	spin_unlock_bh(lock: &p->fcoe_rx_list.lock);
1296
1297	if (crc_eof)
1298	put_page(page: crc_eof);
1299	flush_work(work: &p->work);
1300	}
1301
1302	/**
1303	* fcoe_select_cpu() - Selects CPU to handle post-processing of incoming
1304	* command.
1305	*
1306	* This routine selects next CPU based on cpumask to distribute
1307	* incoming requests in round robin.
1308	*
1309	* Returns: int CPU number
1310	*/
1311	static inline unsigned int fcoe_select_cpu(void)
1312	{
1313	static unsigned int selected_cpu;
1314
1315	selected_cpu = cpumask_next(n: selected_cpu, cpu_online_mask);
1316	if (selected_cpu >= nr_cpu_ids)
1317	selected_cpu = cpumask_first(cpu_online_mask);
1318
1319	return selected_cpu;
1320	}
1321
1322	/**
1323	* fcoe_rcv() - Receive packets from a net device
1324	* @skb: The received packet
1325	* @netdev: The net device that the packet was received on
1326	* @ptype: The packet type context
1327	* @olddev: The last device net device
1328	*
1329	* This routine is called by NET_RX_SOFTIRQ. It receives a packet, builds a
1330	* FC frame and passes the frame to libfc.
1331	*
1332	* Returns: 0 for success
1333	*/
1334	static int fcoe_rcv(struct sk_buff *skb, struct net_device *netdev,
1335	struct packet_type *ptype, struct net_device *olddev)
1336	{
1337	struct fc_lport *lport;
1338	struct fcoe_rcv_info *fr;
1339	struct fcoe_ctlr *ctlr;
1340	struct fcoe_interface *fcoe;
1341	struct fc_frame_header *fh;
1342	struct fcoe_percpu_s *fps;
1343	struct ethhdr *eh;
1344	unsigned int cpu;
1345
1346	fcoe = container_of(ptype, struct fcoe_interface, fcoe_packet_type);
1347	ctlr = fcoe_to_ctlr(fcoe);
1348	lport = ctlr->lp;
1349	if (unlikely(!lport)) {
1350	FCOE_NETDEV_DBG(netdev, "Cannot find hba structure\n");
1351	goto err2;
1352	}
1353	if (!lport->link_up)
1354	goto err2;
1355
1356	FCOE_NETDEV_DBG(netdev,
1357	"skb_info: len:%d data_len:%d head:%p data:%p tail:%p end:%p sum:%d dev:%s\n",
1358	skb->len, skb->data_len, skb->head, skb->data,
1359	skb_tail_pointer(skb), skb_end_pointer(skb),
1360	skb->csum, skb->dev ? skb->dev->name : "<NULL>");
1361
1362
1363	skb = skb_share_check(skb, GFP_ATOMIC);
1364
1365	if (skb == NULL)
1366	return NET_RX_DROP;
1367
1368	eh = eth_hdr(skb);
1369
1370	if (is_fip_mode(fip: ctlr) &&
1371	!ether_addr_equal(addr1: eh->h_source, addr2: ctlr->dest_addr)) {
1372	FCOE_NETDEV_DBG(netdev, "wrong source mac address:%pM\n",
1373	eh->h_source);
1374	goto err;
1375	}
1376
1377	/*
1378	* Check for minimum frame length, and make sure required FCoE
1379	* and FC headers are pulled into the linear data area.
1380	*/
1381	if (unlikely((skb->len < FCOE_MIN_FRAME) ||
1382	!pskb_may_pull(skb, FCOE_HEADER_LEN)))
1383	goto err;
1384
1385	skb_set_transport_header(skb, offset: sizeof(struct fcoe_hdr));
1386	fh = (struct fc_frame_header *) skb_transport_header(skb);
1387
1388	if (ntoh24(p: &eh->h_dest[3]) != ntoh24(p: fh->fh_d_id)) {
1389	FCOE_NETDEV_DBG(netdev, "FC frame d_id mismatch with MAC:%pM\n",
1390	eh->h_dest);
1391	goto err;
1392	}
1393
1394	fr = fcoe_dev_from_skb(skb);
1395	fr->fr_dev = lport;
1396
1397	/*
1398	* In case the incoming frame's exchange is originated from
1399	* the initiator, then received frame's exchange id is ANDed
1400	* with fc_cpu_mask bits to get the same cpu on which exchange
1401	* was originated, otherwise select cpu using rx exchange id
1402	* or fcoe_select_cpu().
1403	*/
1404	if (ntoh24(p: fh->fh_f_ctl) & FC_FC_EX_CTX)
1405	cpu = ntohs(fh->fh_ox_id) & fc_cpu_mask;
1406	else {
1407	if (ntohs(fh->fh_rx_id) == FC_XID_UNKNOWN)
1408	cpu = fcoe_select_cpu();
1409	else
1410	cpu = ntohs(fh->fh_rx_id) & fc_cpu_mask;
1411	}
1412
1413	if (cpu >= nr_cpu_ids)
1414	goto err;
1415
1416	fps = &per_cpu(fcoe_percpu, cpu);
1417	spin_lock(lock: &fps->fcoe_rx_list.lock);
1418	/*
1419	* We now have a valid CPU that we're targeting for
1420	* this skb. We also have this receive thread locked,
1421	* so we're free to queue skbs into it's queue.
1422	*/
1423
1424	/*
1425	* Note: We used to have a set of conditions under which we would
1426	* call fcoe_recv_frame directly, rather than queuing to the rx list
1427	* as it could save a few cycles, but doing so is prohibited, as
1428	* fcoe_recv_frame has several paths that may sleep, which is forbidden
1429	* in softirq context.
1430	*/
1431	__skb_queue_tail(list: &fps->fcoe_rx_list, newsk: skb);
1432	schedule_work_on(cpu, work: &fps->work);
1433	spin_unlock(lock: &fps->fcoe_rx_list.lock);
1434
1435	return NET_RX_SUCCESS;
1436	err:
1437	this_cpu_inc(lport->stats->ErrorFrames);
1438	err2:
1439	kfree_skb(skb);
1440	return NET_RX_DROP;
1441	}
1442
1443	/**
1444	* fcoe_alloc_paged_crc_eof() - Allocate a page to be used for the trailer CRC
1445	* @skb: The packet to be transmitted
1446	* @tlen: The total length of the trailer
1447	*
1448	* Returns: 0 for success
1449	*/
1450	static int fcoe_alloc_paged_crc_eof(struct sk_buff *skb, int tlen)
1451	{
1452	struct fcoe_percpu_s *fps;
1453	int rc;
1454
1455	local_lock(&fcoe_percpu.lock);
1456	fps = this_cpu_ptr(&fcoe_percpu);
1457	rc = fcoe_get_paged_crc_eof(skb, tlen, fps);
1458	local_unlock(&fcoe_percpu.lock);
1459
1460	return rc;
1461	}
1462
1463	/**
1464	* fcoe_xmit() - Transmit a FCoE frame
1465	* @lport: The local port that the frame is to be transmitted for
1466	* @fp: The frame to be transmitted
1467	*
1468	* Return: 0 for success
1469	*/
1470	static int fcoe_xmit(struct fc_lport *lport, struct fc_frame *fp)
1471	{
1472	int wlen;
1473	u32 crc;
1474	struct ethhdr *eh;
1475	struct fcoe_crc_eof *cp;
1476	struct sk_buff *skb;
1477	struct fc_frame_header *fh;
1478	unsigned int hlen; /* header length implies the version */
1479	unsigned int tlen; /* trailer length */
1480	unsigned int elen; /* eth header, may include vlan */
1481	struct fcoe_port *port = lport_priv(lport);
1482	struct fcoe_interface *fcoe = port->priv;
1483	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
1484	u8 sof, eof;
1485	struct fcoe_hdr *hp;
1486
1487	WARN_ON((fr_len(fp) % sizeof(u32)) != 0);
1488
1489	fh = fc_frame_header_get(fp);
1490	skb = fp_skb(fp);
1491
1492	if (!lport->link_up) {
1493	kfree_skb(skb);
1494	return 0;
1495	}
1496
1497	if (unlikely(fh->fh_type == FC_TYPE_ELS) &&
1498	fcoe_ctlr_els_send(ctlr, lport, skb))
1499	return 0;
1500
1501	sof = fr_sof(fp);
1502	eof = fr_eof(fp);
1503
1504	elen = sizeof(struct ethhdr);
1505	hlen = sizeof(struct fcoe_hdr);
1506	tlen = sizeof(struct fcoe_crc_eof);
1507	wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;
1508
1509	/* crc offload */
1510	if (likely(lport->crc_offload)) {
1511	skb->ip_summed = CHECKSUM_PARTIAL;
1512	skb->csum_start = skb_headroom(skb);
1513	skb->csum_offset = skb->len;
1514	crc = 0;
1515	} else {
1516	skb->ip_summed = CHECKSUM_NONE;
1517	crc = fcoe_fc_crc(fp);
1518	}
1519
1520	/* copy port crc and eof to the skb buff */
1521	if (skb_is_nonlinear(skb)) {
1522	skb_frag_t *frag;
1523	if (fcoe_alloc_paged_crc_eof(skb, tlen)) {
1524	kfree_skb(skb);
1525	return -ENOMEM;
1526	}
1527	frag = &skb_shinfo(skb)->frags[skb_shinfo(skb)->nr_frags - 1];
1528	cp = kmap_atomic(page: skb_frag_page(frag)) + skb_frag_off(frag);
1529	} else {
1530	cp = skb_put(skb, len: tlen);
1531	}
1532
1533	memset(cp, 0, sizeof(*cp));
1534	cp->fcoe_eof = eof;
1535	cp->fcoe_crc32 = cpu_to_le32(~crc);
1536
1537	if (skb_is_nonlinear(skb)) {
1538	kunmap_atomic(cp);
1539	cp = NULL;
1540	}
1541
1542	/* adjust skb network/transport offsets to match mac/fcoe/port */
1543	skb_push(skb, len: elen + hlen);
1544	skb_reset_mac_header(skb);
1545	skb_reset_network_header(skb);
1546	skb->mac_len = elen;
1547	skb->protocol = htons(ETH_P_FCOE);
1548	skb->priority = fcoe->priority;
1549
1550	if (is_vlan_dev(dev: fcoe->netdev) &&
1551	fcoe->realdev->features & NETIF_F_HW_VLAN_CTAG_TX) {
1552	/* must set skb->dev before calling vlan_put_tag */
1553	skb->dev = fcoe->realdev;
1554	__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
1555	vlan_tci: vlan_dev_vlan_id(dev: fcoe->netdev));
1556	} else
1557	skb->dev = fcoe->netdev;
1558
1559	/* fill up mac and fcoe headers */
1560	eh = eth_hdr(skb);
1561	eh->h_proto = htons(ETH_P_FCOE);
1562	memcpy(eh->h_dest, ctlr->dest_addr, ETH_ALEN);
1563	if (ctlr->map_dest)
1564	memcpy(eh->h_dest + 3, fh->fh_d_id, 3);
1565
1566	if (unlikely(ctlr->flogi_oxid != FC_XID_UNKNOWN))
1567	memcpy(eh->h_source, ctlr->ctl_src_addr, ETH_ALEN);
1568	else
1569	memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);
1570
1571	hp = (struct fcoe_hdr *)(eh + 1);
1572	memset(hp, 0, sizeof(*hp));
1573	if (FC_FCOE_VER)
1574	FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
1575	hp->fcoe_sof = sof;
1576
1577	/* fcoe lso, mss is in max_payload which is non-zero for FCP data */
1578	if (lport->seq_offload && fr_max_payload(fp)) {
1579	skb_shinfo(skb)->gso_type = SKB_GSO_FCOE;
1580	skb_shinfo(skb)->gso_size = fr_max_payload(fp);
1581	} else {
1582	skb_shinfo(skb)->gso_type = 0;
1583	skb_shinfo(skb)->gso_size = 0;
1584	}
1585	/* update tx stats: regardless if LLD fails */
1586	this_cpu_inc(lport->stats->TxFrames);
1587	this_cpu_add(lport->stats->TxWords, wlen);
1588
1589	/* send down to lld */
1590	fr_dev(fp) = lport;
1591	fcoe_port_send(port, skb);
1592	return 0;
1593	}
1594
1595	/**
1596	* fcoe_filter_frames() - filter out bad fcoe frames, i.e. bad CRC
1597	* @lport: The local port the frame was received on
1598	* @fp: The received frame
1599	*
1600	* Return: 0 on passing filtering checks
1601	*/
1602	static inline int fcoe_filter_frames(struct fc_lport *lport,
1603	struct fc_frame *fp)
1604	{
1605	struct fcoe_ctlr *ctlr;
1606	struct fcoe_interface *fcoe;
1607	struct fc_frame_header *fh;
1608	struct sk_buff *skb = (struct sk_buff *)fp;
1609
1610	/*
1611	* We only check CRC if no offload is available and if it is
1612	* it's solicited data, in which case, the FCP layer would
1613	* check it during the copy.
1614	*/
1615	if (lport->crc_offload && skb->ip_summed == CHECKSUM_UNNECESSARY)
1616	fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
1617	else
1618	fr_flags(fp) |= FCPHF_CRC_UNCHECKED;
1619
1620	fh = fc_frame_header_get(fp);
1621	if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA && fh->fh_type == FC_TYPE_FCP)
1622	return 0;
1623
1624	fcoe = ((struct fcoe_port *)lport_priv(lport))->priv;
1625	ctlr = fcoe_to_ctlr(fcoe);
1626	if (is_fip_mode(fip: ctlr) && fc_frame_payload_op(fp) == ELS_LOGO &&
1627	ntoh24(p: fh->fh_s_id) == FC_FID_FLOGI) {
1628	FCOE_DBG("fcoe: dropping FCoE lport LOGO in fip mode\n");
1629	return -EINVAL;
1630	}
1631
1632	if (!(fr_flags(fp) & FCPHF_CRC_UNCHECKED) ||
1633	le32_to_cpu(fr_crc(fp)) == ~crc32(~0, skb->data, skb->len)) {
1634	fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
1635	return 0;
1636	}
1637
1638	if (this_cpu_inc_return(lport->stats->InvalidCRCCount) < 5)
1639	printk(KERN_WARNING "fcoe: dropping frame with CRC error\n");
1640	return -EINVAL;
1641	}
1642
1643	/**
1644	* fcoe_recv_frame() - process a single received frame
1645	* @skb: frame to process
1646	*/
1647	static void fcoe_recv_frame(struct sk_buff *skb)
1648	{
1649	u32 fr_len;
1650	struct fc_lport *lport;
1651	struct fcoe_rcv_info *fr;
1652	struct fcoe_crc_eof crc_eof;
1653	struct fc_frame *fp;
1654	struct fcoe_hdr *hp;
1655
1656	fr = fcoe_dev_from_skb(skb);
1657	lport = fr->fr_dev;
1658	if (unlikely(!lport)) {
1659	FCOE_NETDEV_DBG(skb->dev, "NULL lport in skb\n");
1660	kfree_skb(skb);
1661	return;
1662	}
1663
1664	FCOE_NETDEV_DBG(skb->dev,
1665	"skb_info: len:%d data_len:%d head:%p data:%p tail:%p end:%p sum:%d dev:%s\n",
1666	skb->len, skb->data_len,
1667	skb->head, skb->data, skb_tail_pointer(skb),
1668	skb_end_pointer(skb), skb->csum,
1669	skb->dev ? skb->dev->name : "<NULL>");
1670
1671	skb_linearize(skb); /* check for skb_is_nonlinear is within skb_linearize */
1672
1673	/*
1674	* Frame length checks and setting up the header pointers
1675	* was done in fcoe_rcv already.
1676	*/
1677	hp = (struct fcoe_hdr *) skb_network_header(skb);
1678
1679	if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
1680	struct fc_stats *stats;
1681
1682	stats = per_cpu_ptr(lport->stats, raw_smp_processor_id());
1683	if (READ_ONCE(stats->ErrorFrames) < 5)
1684	printk(KERN_WARNING "fcoe: FCoE version "
1685	"mismatch: The frame has "
1686	"version %x, but the "
1687	"initiator supports version "
1688	"%x\n", FC_FCOE_DECAPS_VER(hp),
1689	FC_FCOE_VER);
1690	goto drop;
1691	}
1692
1693	skb_pull(skb, len: sizeof(struct fcoe_hdr));
1694	fr_len = skb->len - sizeof(struct fcoe_crc_eof);
1695
1696	this_cpu_inc(lport->stats->RxFrames);
1697	this_cpu_add(lport->stats->RxWords, fr_len / FCOE_WORD_TO_BYTE);
1698
1699	fp = (struct fc_frame *)skb;
1700	fc_frame_init(fp);
1701	fr_dev(fp) = lport;
1702	fr_sof(fp) = hp->fcoe_sof;
1703
1704	/* Copy out the CRC and EOF trailer for access */
1705	if (skb_copy_bits(skb, offset: fr_len, to: &crc_eof, len: sizeof(crc_eof)))
1706	goto drop;
1707	fr_eof(fp) = crc_eof.fcoe_eof;
1708	fr_crc(fp) = crc_eof.fcoe_crc32;
1709	if (pskb_trim(skb, len: fr_len))
1710	goto drop;
1711
1712	if (!fcoe_filter_frames(lport, fp)) {
1713	fc_exch_recv(lport, fp);
1714	return;
1715	}
1716	drop:
1717	this_cpu_inc(lport->stats->ErrorFrames);
1718	kfree_skb(skb);
1719	}
1720
1721	/**
1722	* fcoe_receive_work() - The per-CPU worker
1723	* @work: The work struct
1724	*
1725	*/
1726	static void fcoe_receive_work(struct work_struct *work)
1727	{
1728	struct fcoe_percpu_s *p;
1729	struct sk_buff *skb;
1730	struct sk_buff_head tmp;
1731
1732	p = container_of(work, struct fcoe_percpu_s, work);
1733	skb_queue_head_init(list: &tmp);
1734
1735	spin_lock_bh(lock: &p->fcoe_rx_list.lock);
1736	skb_queue_splice_init(list: &p->fcoe_rx_list, head: &tmp);
1737	spin_unlock_bh(lock: &p->fcoe_rx_list.lock);
1738
1739	if (!skb_queue_len(list_: &tmp))
1740	return;
1741
1742	while ((skb = __skb_dequeue(list: &tmp)))
1743	fcoe_recv_frame(skb);
1744	}
1745
1746	/**
1747	* fcoe_dev_setup() - Setup the link change notification interface
1748	*/
1749	static void fcoe_dev_setup(void)
1750	{
1751	register_dcbevent_notifier(nb: &dcb_notifier);
1752	register_netdevice_notifier(nb: &fcoe_notifier);
1753	}
1754
1755	/**
1756	* fcoe_dev_cleanup() - Cleanup the link change notification interface
1757	*/
1758	static void fcoe_dev_cleanup(void)
1759	{
1760	unregister_dcbevent_notifier(nb: &dcb_notifier);
1761	unregister_netdevice_notifier(nb: &fcoe_notifier);
1762	}
1763
1764	static struct fcoe_interface *
1765	fcoe_hostlist_lookup_realdev_port(struct net_device *netdev)
1766	{
1767	struct fcoe_interface *fcoe;
1768	struct net_device *real_dev;
1769
1770	list_for_each_entry(fcoe, &fcoe_hostlist, list) {
1771	if (is_vlan_dev(dev: fcoe->netdev))
1772	real_dev = vlan_dev_real_dev(dev: fcoe->netdev);
1773	else
1774	real_dev = fcoe->netdev;
1775
1776	if (netdev == real_dev)
1777	return fcoe;
1778	}
1779	return NULL;
1780	}
1781
1782	static int fcoe_dcb_app_notification(struct notifier_block *notifier,
1783	ulong event, void *ptr)
1784	{
1785	struct dcb_app_type *entry = ptr;
1786	struct fcoe_ctlr *ctlr;
1787	struct fcoe_interface *fcoe;
1788	struct net_device *netdev;
1789	int prio;
1790
1791	if (entry->app.selector != DCB_APP_IDTYPE_ETHTYPE)
1792	return NOTIFY_OK;
1793
1794	netdev = dev_get_by_index(net: &init_net, ifindex: entry->ifindex);
1795	if (!netdev)
1796	return NOTIFY_OK;
1797
1798	fcoe = fcoe_hostlist_lookup_realdev_port(netdev);
1799	dev_put(dev: netdev);
1800	if (!fcoe)
1801	return NOTIFY_OK;
1802
1803	ctlr = fcoe_to_ctlr(fcoe);
1804
1805	if (entry->dcbx & DCB_CAP_DCBX_VER_CEE)
1806	prio = ffs(entry->app.priority) - 1;
1807	else
1808	prio = entry->app.priority;
1809
1810	if (prio < 0)
1811	return NOTIFY_OK;
1812
1813	if (entry->app.protocol == ETH_P_FIP ||
1814	entry->app.protocol == ETH_P_FCOE)
1815	ctlr->priority = prio;
1816
1817	if (entry->app.protocol == ETH_P_FCOE)
1818	fcoe->priority = prio;
1819
1820	return NOTIFY_OK;
1821	}
1822
1823	/**
1824	* fcoe_device_notification() - Handler for net device events
1825	* @notifier: The context of the notification
1826	* @event: The type of event
1827	* @ptr: The net device that the event was on
1828	*
1829	* This function is called by the Ethernet driver in case of link change event.
1830	*
1831	* Returns: 0 for success
1832	*/
1833	static int fcoe_device_notification(struct notifier_block *notifier,
1834	ulong event, void *ptr)
1835	{
1836	struct fcoe_ctlr_device *cdev;
1837	struct fc_lport *lport = NULL;
1838	struct net_device *netdev = netdev_notifier_info_to_dev(info: ptr);
1839	struct fcoe_ctlr *ctlr;
1840	struct fcoe_interface *fcoe;
1841	u32 link_possible = 1;
1842	u32 mfs;
1843	int rc = NOTIFY_OK;
1844
1845	list_for_each_entry(fcoe, &fcoe_hostlist, list) {
1846	if (fcoe->netdev == netdev) {
1847	ctlr = fcoe_to_ctlr(fcoe);
1848	lport = ctlr->lp;
1849	break;
1850	}
1851	}
1852	if (!lport) {
1853	rc = NOTIFY_DONE;
1854	goto out;
1855	}
1856
1857	switch (event) {
1858	case NETDEV_DOWN:
1859	case NETDEV_GOING_DOWN:
1860	link_possible = 0;
1861	break;
1862	case NETDEV_UP:
1863	case NETDEV_CHANGE:
1864	break;
1865	case NETDEV_CHANGEMTU:
1866	if (netdev->features & NETIF_F_FCOE_MTU)
1867	break;
1868	mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
1869	sizeof(struct fcoe_crc_eof));
1870	if (mfs >= FC_MIN_MAX_FRAME)
1871	fc_set_mfs(lport, mfs);
1872	break;
1873	case NETDEV_REGISTER:
1874	break;
1875	case NETDEV_UNREGISTER:
1876	list_del(entry: &fcoe->list);
1877	fcoe_vport_remove(lport);
1878	mutex_lock(&fcoe_config_mutex);
1879	fcoe_if_destroy(lport);
1880	if (!fcoe->removed)
1881	fcoe_interface_remove(fcoe);
1882	fcoe_interface_cleanup(fcoe);
1883	mutex_unlock(lock: &fcoe_config_mutex);
1884	fcoe_ctlr_device_delete(fcoe_ctlr_to_ctlr_dev(ctlr));
1885	goto out;
1886	case NETDEV_FEAT_CHANGE:
1887	fcoe_netdev_features_change(lport, netdev);
1888	break;
1889	default:
1890	FCOE_NETDEV_DBG(netdev, "Unknown event %ld "
1891	"from netdev netlink\n", event);
1892	}
1893
1894	fcoe_link_speed_update(lport);
1895
1896	cdev = fcoe_ctlr_to_ctlr_dev(ctlr);
1897
1898	if (link_possible && !fcoe_link_ok(lport)) {
1899	switch (cdev->enabled) {
1900	case FCOE_CTLR_DISABLED:
1901	pr_info("Link up while interface is disabled.\n");
1902	break;
1903	case FCOE_CTLR_ENABLED:
1904	case FCOE_CTLR_UNUSED:
1905	fcoe_ctlr_link_up(ctlr);
1906	}
1907	} else if (fcoe_ctlr_link_down(ctlr)) {
1908	switch (cdev->enabled) {
1909	case FCOE_CTLR_DISABLED:
1910	pr_info("Link down while interface is disabled.\n");
1911	break;
1912	case FCOE_CTLR_ENABLED:
1913	case FCOE_CTLR_UNUSED:
1914	this_cpu_inc(lport->stats->LinkFailureCount);
1915	fcoe_clean_pending_queue(lport);
1916	}
1917	}
1918	out:
1919	return rc;
1920	}
1921
1922	/**
1923	* fcoe_disable() - Disables a FCoE interface
1924	* @netdev : The net_device object the Ethernet interface to create on
1925	*
1926	* Called from fcoe transport.
1927	*
1928	* Returns: 0 for success
1929	*
1930	* Deprecated: use fcoe_ctlr_enabled()
1931	*/
1932	static int fcoe_disable(struct net_device *netdev)
1933	{
1934	struct fcoe_ctlr *ctlr;
1935	struct fcoe_interface *fcoe;
1936	int rc = 0;
1937
1938	mutex_lock(&fcoe_config_mutex);
1939
1940	rtnl_lock();
1941	fcoe = fcoe_hostlist_lookup_port(netdev);
1942	rtnl_unlock();
1943
1944	if (fcoe) {
1945	ctlr = fcoe_to_ctlr(fcoe);
1946	fcoe_ctlr_link_down(ctlr);
1947	fcoe_clean_pending_queue(ctlr->lp);
1948	} else
1949	rc = -ENODEV;
1950
1951	mutex_unlock(lock: &fcoe_config_mutex);
1952	return rc;
1953	}
1954
1955	/**
1956	* fcoe_enable() - Enables a FCoE interface
1957	* @netdev : The net_device object the Ethernet interface to create on
1958	*
1959	* Called from fcoe transport.
1960	*
1961	* Returns: 0 for success
1962	*/
1963	static int fcoe_enable(struct net_device *netdev)
1964	{
1965	struct fcoe_ctlr *ctlr;
1966	struct fcoe_interface *fcoe;
1967	int rc = 0;
1968
1969	mutex_lock(&fcoe_config_mutex);
1970	rtnl_lock();
1971	fcoe = fcoe_hostlist_lookup_port(netdev);
1972	rtnl_unlock();
1973
1974	if (!fcoe) {
1975	rc = -ENODEV;
1976	goto out;
1977	}
1978
1979	ctlr = fcoe_to_ctlr(fcoe);
1980
1981	if (!fcoe_link_ok(ctlr->lp))
1982	fcoe_ctlr_link_up(ctlr);
1983
1984	out:
1985	mutex_unlock(lock: &fcoe_config_mutex);
1986	return rc;
1987	}
1988
1989	/**
1990	* fcoe_ctlr_enabled() - Enable or disable an FCoE Controller
1991	* @cdev: The FCoE Controller that is being enabled or disabled
1992	*
1993	* fcoe_sysfs will ensure that the state of 'enabled' has
1994	* changed, so no checking is necessary here. This routine simply
1995	* calls fcoe_enable or fcoe_disable, both of which are deprecated.
1996	* When those routines are removed the functionality can be merged
1997	* here.
1998	*/
1999	static int fcoe_ctlr_enabled(struct fcoe_ctlr_device *cdev)
2000	{
2001	struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr: cdev);
2002	struct fc_lport *lport = ctlr->lp;
2003	struct net_device *netdev = fcoe_netdev(lport);
2004
2005	switch (cdev->enabled) {
2006	case FCOE_CTLR_ENABLED:
2007	return fcoe_enable(netdev);
2008	case FCOE_CTLR_DISABLED:
2009	return fcoe_disable(netdev);
2010	case FCOE_CTLR_UNUSED:
2011	default:
2012	return -ENOTSUPP;
2013	}
2014	}
2015
2016	/**
2017	* fcoe_ctlr_mode() - Switch FIP mode
2018	* @ctlr_dev: The FCoE Controller that is being modified
2019	*
2020	* When the FIP mode has been changed we need to update
2021	* the multicast addresses to ensure we get the correct
2022	* frames.
2023	*/
2024	static void fcoe_ctlr_mode(struct fcoe_ctlr_device *ctlr_dev)
2025	{
2026	struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr: ctlr_dev);
2027	struct fcoe_interface *fcoe = fcoe_ctlr_priv(ctlr);
2028
2029	if (ctlr_dev->mode == FIP_CONN_TYPE_VN2VN &&
2030	ctlr->mode != FIP_MODE_VN2VN) {
2031	dev_mc_del(dev: fcoe->netdev, FIP_ALL_ENODE_MACS);
2032	dev_mc_add(dev: fcoe->netdev, FIP_ALL_VN2VN_MACS);
2033	dev_mc_add(dev: fcoe->netdev, FIP_ALL_P2P_MACS);
2034	} else if (ctlr->mode != FIP_MODE_FABRIC) {
2035	dev_mc_del(dev: fcoe->netdev, FIP_ALL_VN2VN_MACS);
2036	dev_mc_del(dev: fcoe->netdev, FIP_ALL_P2P_MACS);
2037	dev_mc_add(dev: fcoe->netdev, FIP_ALL_ENODE_MACS);
2038	}
2039	fcoe_ctlr_set_fip_mode(ctlr_dev);
2040	}
2041
2042	/**
2043	* fcoe_destroy() - Destroy a FCoE interface
2044	* @netdev : The net_device object the Ethernet interface to create on
2045	*
2046	* Called from fcoe transport
2047	*
2048	* Returns: 0 for success
2049	*/
2050	static int fcoe_destroy(struct net_device *netdev)
2051	{
2052	struct fcoe_ctlr *ctlr;
2053	struct fcoe_interface *fcoe;
2054	struct fc_lport *lport;
2055	struct fcoe_port *port;
2056	int rc = 0;
2057
2058	mutex_lock(&fcoe_config_mutex);
2059	rtnl_lock();
2060	fcoe = fcoe_hostlist_lookup_port(netdev);
2061	if (!fcoe) {
2062	rc = -ENODEV;
2063	goto out_nodev;
2064	}
2065	ctlr = fcoe_to_ctlr(fcoe);
2066	lport = ctlr->lp;
2067	port = lport_priv(lport);
2068	list_del(entry: &fcoe->list);
2069	queue_work(wq: fcoe_wq, work: &port->destroy_work);
2070	out_nodev:
2071	rtnl_unlock();
2072	mutex_unlock(lock: &fcoe_config_mutex);
2073	return rc;
2074	}
2075
2076	/**
2077	* fcoe_destroy_work() - Destroy a FCoE port in a deferred work context
2078	* @work: Handle to the FCoE port to be destroyed
2079	*/
2080	static void fcoe_destroy_work(struct work_struct *work)
2081	{
2082	struct fcoe_ctlr_device *cdev;
2083	struct fcoe_ctlr *ctlr;
2084	struct fcoe_port *port;
2085	struct fcoe_interface *fcoe;
2086
2087	port = container_of(work, struct fcoe_port, destroy_work);
2088
2089	fcoe_vport_remove(port->lport);
2090
2091	mutex_lock(&fcoe_config_mutex);
2092
2093	fcoe = port->priv;
2094	ctlr = fcoe_to_ctlr(fcoe);
2095	cdev = fcoe_ctlr_to_ctlr_dev(ctlr);
2096
2097	rtnl_lock();
2098	fcoe_if_destroy(lport: port->lport);
2099	if (!fcoe->removed)
2100	fcoe_interface_remove(fcoe);
2101	rtnl_unlock();
2102	fcoe_interface_cleanup(fcoe);
2103
2104	mutex_unlock(lock: &fcoe_config_mutex);
2105
2106	fcoe_ctlr_device_delete(cdev);
2107	}
2108
2109	/**
2110	* fcoe_match() - Check if the FCoE is supported on the given netdevice
2111	* @netdev : The net_device object the Ethernet interface to create on
2112	*
2113	* Called from fcoe transport.
2114	*
2115	* Returns: always returns true as this is the default FCoE transport,
2116	* i.e., support all netdevs.
2117	*/
2118	static bool fcoe_match(struct net_device *netdev)
2119	{
2120	return true;
2121	}
2122
2123	/**
2124	* fcoe_dcb_create() - Initialize DCB attributes and hooks
2125	* @fcoe: The new FCoE interface
2126	*/
2127	static void fcoe_dcb_create(struct fcoe_interface *fcoe)
2128	{
2129	int ctlr_prio = TC_PRIO_BESTEFFORT;
2130	int fcoe_prio = TC_PRIO_INTERACTIVE;
2131	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
2132	#ifdef CONFIG_DCB
2133	int dcbx;
2134	u8 fup, up;
2135	struct net_device *netdev = fcoe->realdev;
2136	struct dcb_app app = {
2137	.priority = 0,
2138	.protocol = ETH_P_FCOE
2139	};
2140
2141	/* setup DCB priority attributes. */
2142	if (netdev && netdev->dcbnl_ops && netdev->dcbnl_ops->getdcbx) {
2143	dcbx = netdev->dcbnl_ops->getdcbx(netdev);
2144
2145	if (dcbx & DCB_CAP_DCBX_VER_IEEE) {
2146	app.selector = IEEE_8021QAZ_APP_SEL_ETHERTYPE;
2147	up = dcb_ieee_getapp_mask(netdev, &app);
2148	app.protocol = ETH_P_FIP;
2149	fup = dcb_ieee_getapp_mask(netdev, &app);
2150	} else {
2151	app.selector = DCB_APP_IDTYPE_ETHTYPE;
2152	up = dcb_getapp(netdev, &app);
2153	app.protocol = ETH_P_FIP;
2154	fup = dcb_getapp(netdev, &app);
2155	}
2156
2157	fcoe_prio = ffs(up) ? ffs(up) - 1 : 0;
2158	ctlr_prio = ffs(fup) ? ffs(fup) - 1 : fcoe_prio;
2159	}
2160	#endif
2161	fcoe->priority = fcoe_prio;
2162	ctlr->priority = ctlr_prio;
2163	}
2164
2165	enum fcoe_create_link_state {
2166	FCOE_CREATE_LINK_DOWN,
2167	FCOE_CREATE_LINK_UP,
2168	};
2169
2170	/**
2171	* _fcoe_create() - (internal) Create a fcoe interface
2172	* @netdev : The net_device object the Ethernet interface to create on
2173	* @fip_mode: The FIP mode for this creation
2174	* @link_state: The ctlr link state on creation
2175	*
2176	* Called from either the libfcoe 'create' module parameter
2177	* via fcoe_create or from fcoe_syfs's ctlr_create file.
2178	*
2179	* libfcoe's 'create' module parameter is deprecated so some
2180	* consolidation of code can be done when that interface is
2181	* removed.
2182	*/
2183	static int _fcoe_create(struct net_device *netdev, enum fip_mode fip_mode,
2184	enum fcoe_create_link_state link_state)
2185	{
2186	int rc = 0;
2187	struct fcoe_ctlr_device *ctlr_dev;
2188	struct fcoe_ctlr *ctlr;
2189	struct fcoe_interface *fcoe;
2190	struct fc_lport *lport;
2191
2192	mutex_lock(&fcoe_config_mutex);
2193	rtnl_lock();
2194
2195	/* look for existing lport */
2196	if (fcoe_hostlist_lookup(netdev)) {
2197	rc = -EEXIST;
2198	goto out_nodev;
2199	}
2200
2201	fcoe = fcoe_interface_create(netdev, fip_mode);
2202	if (IS_ERR(ptr: fcoe)) {
2203	rc = PTR_ERR(ptr: fcoe);
2204	goto out_nodev;
2205	}
2206
2207	ctlr = fcoe_to_ctlr(fcoe);
2208	ctlr_dev = fcoe_ctlr_to_ctlr_dev(ctlr);
2209	lport = fcoe_if_create(fcoe, parent: &ctlr_dev->dev, npiv: 0);
2210	if (IS_ERR(ptr: lport)) {
2211	printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
2212	netdev->name);
2213	rc = -EIO;
2214	if (!fcoe->removed)
2215	fcoe_interface_remove(fcoe);
2216	rtnl_unlock();
2217	fcoe_interface_cleanup(fcoe);
2218	mutex_unlock(lock: &fcoe_config_mutex);
2219	fcoe_ctlr_device_delete(ctlr_dev);
2220	return rc;
2221	}
2222
2223	/* Make this the "master" N_Port */
2224	ctlr->lp = lport;
2225
2226	/* setup DCB priority attributes. */
2227	fcoe_dcb_create(fcoe);
2228
2229	/* start FIP Discovery and FLOGI */
2230	lport->boot_time = jiffies;
2231	fc_fabric_login(lport);
2232
2233	/*
2234	* If the fcoe_ctlr_device is to be set to DISABLED
2235	* it must be done after the lport is added to the
2236	* hostlist, but before the rtnl_lock is released.
2237	* This is because the rtnl_lock protects the
2238	* hostlist that fcoe_device_notification uses. If
2239	* the FCoE Controller is intended to be created
2240	* DISABLED then 'enabled' needs to be considered
2241	* handling link events. 'enabled' must be set
2242	* before the lport can be found in the hostlist
2243	* when a link up event is received.
2244	*/
2245	if (link_state == FCOE_CREATE_LINK_UP)
2246	ctlr_dev->enabled = FCOE_CTLR_ENABLED;
2247	else
2248	ctlr_dev->enabled = FCOE_CTLR_DISABLED;
2249
2250	if (link_state == FCOE_CREATE_LINK_UP &&
2251	!fcoe_link_ok(lport)) {
2252	rtnl_unlock();
2253	fcoe_ctlr_link_up(ctlr);
2254	mutex_unlock(lock: &fcoe_config_mutex);
2255	return rc;
2256	}
2257
2258	out_nodev:
2259	rtnl_unlock();
2260	mutex_unlock(lock: &fcoe_config_mutex);
2261
2262	return rc;
2263	}
2264
2265	/**
2266	* fcoe_create() - Create a fcoe interface
2267	* @netdev : The net_device object the Ethernet interface to create on
2268	* @fip_mode: The FIP mode for this creation
2269	*
2270	* Called from fcoe transport
2271	*
2272	* Returns: 0 for success
2273	*/
2274	static int fcoe_create(struct net_device *netdev, enum fip_mode fip_mode)
2275	{
2276	return _fcoe_create(netdev, fip_mode, link_state: FCOE_CREATE_LINK_UP);
2277	}
2278
2279	/**
2280	* fcoe_ctlr_alloc() - Allocate a fcoe interface from fcoe_sysfs
2281	* @netdev: The net_device to be used by the allocated FCoE Controller
2282	*
2283	* This routine is called from fcoe_sysfs. It will start the fcoe_ctlr
2284	* in a link_down state. The allows the user an opportunity to configure
2285	* the FCoE Controller from sysfs before enabling the FCoE Controller.
2286	*
2287	* Creating in with this routine starts the FCoE Controller in Fabric
2288	* mode. The user can change to VN2VN or another mode before enabling.
2289	*/
2290	static int fcoe_ctlr_alloc(struct net_device *netdev)
2291	{
2292	return _fcoe_create(netdev, fip_mode: FIP_MODE_FABRIC,
2293	link_state: FCOE_CREATE_LINK_DOWN);
2294	}
2295
2296	/**
2297	* fcoe_link_ok() - Check if the link is OK for a local port
2298	* @lport: The local port to check link on
2299	*
2300	* Returns: 0 if link is UP and OK, -1 if not
2301	*
2302	*/
2303	static int fcoe_link_ok(struct fc_lport *lport)
2304	{
2305	struct net_device *netdev = fcoe_netdev(lport);
2306
2307	if (netif_oper_up(dev: netdev))
2308	return 0;
2309	return -1;
2310	}
2311
2312	/**
2313	* fcoe_percpu_clean() - Clear all pending skbs for an local port
2314	* @lport: The local port whose skbs are to be cleared
2315	*
2316	* Must be called with fcoe_create_mutex held to single-thread completion.
2317	*
2318	* This flushes the pending skbs by flush the work item for each CPU. The work
2319	* item on each possible CPU is flushed because we may have used the per-CPU
2320	* struct of an offline CPU.
2321	*/
2322	static void fcoe_percpu_clean(struct fc_lport *lport)
2323	{
2324	struct fcoe_percpu_s *pp;
2325	unsigned int cpu;
2326
2327	for_each_possible_cpu(cpu) {
2328	pp = &per_cpu(fcoe_percpu, cpu);
2329
2330	flush_work(work: &pp->work);
2331	}
2332	}
2333
2334	/**
2335	* fcoe_reset() - Reset a local port
2336	* @shost: The SCSI host associated with the local port to be reset
2337	*
2338	* Returns: Always 0 (return value required by FC transport template)
2339	*/
2340	static int fcoe_reset(struct Scsi_Host *shost)
2341	{
2342	struct fc_lport *lport = shost_priv(shost);
2343	struct fcoe_port *port = lport_priv(lport);
2344	struct fcoe_interface *fcoe = port->priv;
2345	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
2346	struct fcoe_ctlr_device *cdev = fcoe_ctlr_to_ctlr_dev(ctlr);
2347
2348	fcoe_ctlr_link_down(ctlr);
2349	fcoe_clean_pending_queue(ctlr->lp);
2350
2351	if (cdev->enabled != FCOE_CTLR_DISABLED &&
2352	!fcoe_link_ok(lport: ctlr->lp))
2353	fcoe_ctlr_link_up(ctlr);
2354	return 0;
2355	}
2356
2357	/**
2358	* fcoe_hostlist_lookup_port() - Find the FCoE interface associated with a net device
2359	* @netdev: The net device used as a key
2360	*
2361	* Locking: Must be called with the RNL mutex held.
2362	*
2363	* Returns: NULL or the FCoE interface
2364	*/
2365	static struct fcoe_interface *
2366	fcoe_hostlist_lookup_port(const struct net_device *netdev)
2367	{
2368	struct fcoe_interface *fcoe;
2369
2370	list_for_each_entry(fcoe, &fcoe_hostlist, list) {
2371	if (fcoe->netdev == netdev)
2372	return fcoe;
2373	}
2374	return NULL;
2375	}
2376
2377	/**
2378	* fcoe_hostlist_lookup() - Find the local port associated with a
2379	* given net device
2380	* @netdev: The netdevice used as a key
2381	*
2382	* Locking: Must be called with the RTNL mutex held
2383	*
2384	* Returns: NULL or the local port
2385	*/
2386	static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *netdev)
2387	{
2388	struct fcoe_ctlr *ctlr;
2389	struct fcoe_interface *fcoe;
2390
2391	fcoe = fcoe_hostlist_lookup_port(netdev);
2392	ctlr = fcoe_to_ctlr(fcoe);
2393	return (fcoe) ? ctlr->lp : NULL;
2394	}
2395
2396	/**
2397	* fcoe_hostlist_add() - Add the FCoE interface identified by a local
2398	* port to the hostlist
2399	* @lport: The local port that identifies the FCoE interface to be added
2400	*
2401	* Locking: must be called with the RTNL mutex held
2402	*
2403	* Returns: 0 for success
2404	*/
2405	static int fcoe_hostlist_add(const struct fc_lport *lport)
2406	{
2407	struct fcoe_interface *fcoe;
2408	struct fcoe_port *port;
2409
2410	fcoe = fcoe_hostlist_lookup_port(netdev: fcoe_netdev(lport));
2411	if (!fcoe) {
2412	port = lport_priv(lport);
2413	fcoe = port->priv;
2414	list_add_tail(new: &fcoe->list, head: &fcoe_hostlist);
2415	}
2416	return 0;
2417	}
2418
2419	/**
2420	* fcoe_hostlist_del() - Remove the FCoE interface identified by a local
2421	* port to the hostlist
2422	* @lport: The local port that identifies the FCoE interface to be added
2423	*
2424	* Locking: must be called with the RTNL mutex held
2425	*
2426	*/
2427	static void fcoe_hostlist_del(const struct fc_lport *lport)
2428	{
2429	struct fcoe_interface *fcoe;
2430	struct fcoe_port *port;
2431
2432	port = lport_priv(lport);
2433	fcoe = port->priv;
2434	list_del(entry: &fcoe->list);
2435	return;
2436	}
2437
2438	static struct fcoe_transport fcoe_sw_transport = {
2439	.name = {FCOE_TRANSPORT_DEFAULT},
2440	.attached = false,
2441	.list = LIST_HEAD_INIT(fcoe_sw_transport.list),
2442	.match = fcoe_match,
2443	.alloc = fcoe_ctlr_alloc,
2444	.create = fcoe_create,
2445	.destroy = fcoe_destroy,
2446	.enable = fcoe_enable,
2447	.disable = fcoe_disable,
2448	};
2449
2450	/**
2451	* fcoe_init() - Initialize fcoe.ko
2452	*
2453	* Returns: 0 on success, or a negative value on failure
2454	*/
2455	static int __init fcoe_init(void)
2456	{
2457	struct fcoe_percpu_s *p;
2458	unsigned int cpu;
2459	int rc = 0;
2460
2461	fcoe_wq = alloc_workqueue(fmt: "fcoe", flags: 0, max_active: 0);
2462	if (!fcoe_wq)
2463	return -ENOMEM;
2464
2465	/* register as a fcoe transport */
2466	rc = fcoe_transport_attach(ft: &fcoe_sw_transport);
2467	if (rc) {
2468	printk(KERN_ERR "failed to register an fcoe transport, check "
2469	"if libfcoe is loaded\n");
2470	goto out_destroy;
2471	}
2472
2473	mutex_lock(&fcoe_config_mutex);
2474
2475	for_each_possible_cpu(cpu) {
2476	p = per_cpu_ptr(&fcoe_percpu, cpu);
2477	INIT_WORK(&p->work, fcoe_receive_work);
2478	skb_queue_head_init(list: &p->fcoe_rx_list);
2479	local_lock_init(&p->lock);
2480	}
2481
2482	/* Setup link change notification */
2483	fcoe_dev_setup();
2484
2485	rc = fcoe_if_init();
2486	if (rc)
2487	goto out_free;
2488
2489	mutex_unlock(lock: &fcoe_config_mutex);
2490	return 0;
2491
2492	out_free:
2493	mutex_unlock(lock: &fcoe_config_mutex);
2494	fcoe_transport_detach(ft: &fcoe_sw_transport);
2495	out_destroy:
2496	destroy_workqueue(wq: fcoe_wq);
2497	return rc;
2498	}
2499	module_init(fcoe_init);
2500
2501	/**
2502	* fcoe_exit() - Clean up fcoe.ko
2503	*
2504	* Returns: 0 on success or a negative value on failure
2505	*/
2506	static void __exit fcoe_exit(void)
2507	{
2508	struct fcoe_interface *fcoe, *tmp;
2509	struct fcoe_ctlr *ctlr;
2510	struct fcoe_port *port;
2511	unsigned int cpu;
2512
2513	mutex_lock(&fcoe_config_mutex);
2514
2515	fcoe_dev_cleanup();
2516
2517	/* releases the associated fcoe hosts */
2518	rtnl_lock();
2519	list_for_each_entry_safe(fcoe, tmp, &fcoe_hostlist, list) {
2520	ctlr = fcoe_to_ctlr(fcoe);
2521	port = lport_priv(lport: ctlr->lp);
2522	fcoe_hostlist_del(lport: port->lport);
2523	queue_work(wq: fcoe_wq, work: &port->destroy_work);
2524	}
2525	rtnl_unlock();
2526
2527	for_each_possible_cpu(cpu)
2528	fcoe_thread_cleanup_local(cpu);
2529
2530	mutex_unlock(lock: &fcoe_config_mutex);
2531
2532	/*
2533	* destroy_work's may be chained but destroy_workqueue()
2534	* can take care of them. Just kill the fcoe_wq.
2535	*/
2536	destroy_workqueue(wq: fcoe_wq);
2537
2538	/*
2539	* Detaching from the scsi transport must happen after all
2540	* destroys are done on the fcoe_wq. destroy_workqueue will
2541	* enusre the fcoe_wq is flushed.
2542	*/
2543	fcoe_if_exit();
2544
2545	/* detach from fcoe transport */
2546	fcoe_transport_detach(ft: &fcoe_sw_transport);
2547	}
2548	module_exit(fcoe_exit);
2549
2550	/**
2551	* fcoe_flogi_resp() - FCoE specific FLOGI and FDISC response handler
2552	* @seq: active sequence in the FLOGI or FDISC exchange
2553	* @fp: response frame, or error encoded in a pointer (timeout)
2554	* @arg: pointer to the fcoe_ctlr structure
2555	*
2556	* This handles MAC address management for FCoE, then passes control on to
2557	* the libfc FLOGI response handler.
2558	*/
2559	static void fcoe_flogi_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
2560	{
2561	struct fcoe_ctlr *fip = arg;
2562	struct fc_exch *exch = fc_seq_exch(seq);
2563	struct fc_lport *lport = exch->lp;
2564	u8 *mac;
2565
2566	if (IS_ERR(ptr: fp))
2567	goto done;
2568
2569	mac = fr_cb(fp)->granted_mac;
2570	/* pre-FIP */
2571	if (is_zero_ether_addr(addr: mac))
2572	fcoe_ctlr_recv_flogi(fip, lport, fp);
2573	else
2574	fcoe_update_src_mac(lport, addr: mac);
2575	done:
2576	fc_lport_flogi_resp(seq, fp, lport);
2577	}
2578
2579	/**
2580	* fcoe_logo_resp() - FCoE specific LOGO response handler
2581	* @seq: active sequence in the LOGO exchange
2582	* @fp: response frame, or error encoded in a pointer (timeout)
2583	* @arg: pointer to the fcoe_ctlr structure
2584	*
2585	* This handles MAC address management for FCoE, then passes control on to
2586	* the libfc LOGO response handler.
2587	*/
2588	static void fcoe_logo_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
2589	{
2590	struct fc_lport *lport = arg;
2591	static u8 zero_mac[ETH_ALEN] = { 0 };
2592
2593	if (!IS_ERR(ptr: fp))
2594	fcoe_update_src_mac(lport, addr: zero_mac);
2595	fc_lport_logo_resp(seq, fp, lport);
2596	}
2597
2598	/*
2599	* fcoe_elsct_send - FCoE specific ELS handler
2600	*
2601	* This does special case handling of FIP encapsualted ELS exchanges for FCoE,
2602	* using FCoE specific response handlers and passing the FIP controller as
2603	* the argument (the lport is still available from the exchange).
2604	*
2605	* Most of the work here is just handed off to the libfc routine.
2606	*/
2607	static struct fc_seq *fcoe_elsct_send(struct fc_lport *lport, u32 did,
2608	struct fc_frame *fp, unsigned int op,
2609	void (*resp)(struct fc_seq *,
2610	struct fc_frame *,
2611	void *),
2612	void *arg, u32 timeout)
2613	{
2614	struct fcoe_port *port = lport_priv(lport);
2615	struct fcoe_interface *fcoe = port->priv;
2616	struct fcoe_ctlr *fip = fcoe_to_ctlr(fcoe);
2617	struct fc_frame_header *fh = fc_frame_header_get(fp);
2618
2619	switch (op) {
2620	case ELS_FLOGI:
2621	case ELS_FDISC:
2622	if (lport->point_to_multipoint)
2623	break;
2624	return fc_elsct_send(lport, did, fp, op, resp: fcoe_flogi_resp,
2625	arg: fip, timer_msec: timeout);
2626	case ELS_LOGO:
2627	/* only hook onto fabric logouts, not port logouts */
2628	if (ntoh24(p: fh->fh_d_id) != FC_FID_FLOGI)
2629	break;
2630	return fc_elsct_send(lport, did, fp, op, resp: fcoe_logo_resp,
2631	arg: lport, timer_msec: timeout);
2632	}
2633	return fc_elsct_send(lport, did, fp, op, resp, arg, timer_msec: timeout);
2634	}
2635
2636	/**
2637	* fcoe_vport_create() - create an fc_host/scsi_host for a vport
2638	* @vport: fc_vport object to create a new fc_host for
2639	* @disabled: start the new fc_host in a disabled state by default?
2640	*
2641	* Returns: 0 for success
2642	*/
2643	static int fcoe_vport_create(struct fc_vport *vport, bool disabled)
2644	{
2645	struct Scsi_Host *shost = vport_to_shost(vport);
2646	struct fc_lport *n_port = shost_priv(shost);
2647	struct fcoe_port *port = lport_priv(lport: n_port);
2648	struct fcoe_interface *fcoe = port->priv;
2649	struct net_device *netdev = fcoe->netdev;
2650	struct fc_lport *vn_port;
2651	int rc;
2652	char buf[32];
2653
2654	rc = fcoe_validate_vport_create(vport);
2655	if (rc) {
2656	fcoe_wwn_to_str(wwn: vport->port_name, buf, len: sizeof(buf));
2657	printk(KERN_ERR "fcoe: Failed to create vport, "
2658	"WWPN (0x%s) already exists\n",
2659	buf);
2660	return rc;
2661	}
2662
2663	mutex_lock(&fcoe_config_mutex);
2664	rtnl_lock();
2665	vn_port = fcoe_if_create(fcoe, parent: &vport->dev, npiv: 1);
2666	rtnl_unlock();
2667	mutex_unlock(lock: &fcoe_config_mutex);
2668
2669	if (IS_ERR(ptr: vn_port)) {
2670	printk(KERN_ERR "fcoe: fcoe_vport_create(%s) failed\n",
2671	netdev->name);
2672	return -EIO;
2673	}
2674
2675	if (disabled) {
2676	fc_vport_set_state(vport, new_state: FC_VPORT_DISABLED);
2677	} else {
2678	vn_port->boot_time = jiffies;
2679	fc_fabric_login(vn_port);
2680	fc_vport_setlink(vn_port);
2681	}
2682	return 0;
2683	}
2684
2685	/**
2686	* fcoe_vport_destroy() - destroy the fc_host/scsi_host for a vport
2687	* @vport: fc_vport object that is being destroyed
2688	*
2689	* Returns: 0 for success
2690	*/
2691	static int fcoe_vport_destroy(struct fc_vport *vport)
2692	{
2693	struct Scsi_Host *shost = vport_to_shost(vport);
2694	struct fc_lport *n_port = shost_priv(shost);
2695	struct fc_lport *vn_port = vport->dd_data;
2696
2697	mutex_lock(&n_port->lp_mutex);
2698	list_del(entry: &vn_port->list);
2699	mutex_unlock(lock: &n_port->lp_mutex);
2700
2701	mutex_lock(&fcoe_config_mutex);
2702	rtnl_lock();
2703	fcoe_if_destroy(lport: vn_port);
2704	rtnl_unlock();
2705	mutex_unlock(lock: &fcoe_config_mutex);
2706
2707	return 0;
2708	}
2709
2710	/**
2711	* fcoe_vport_remove() - remove attached vports
2712	* @lport: lport for which the vports should be removed
2713	*/
2714	static void fcoe_vport_remove(struct fc_lport *lport)
2715	{
2716	struct Scsi_Host *shost;
2717	struct fc_host_attrs *fc_host;
2718	unsigned long flags;
2719	struct fc_vport *vport;
2720	struct fc_vport *next_vport;
2721
2722	shost = lport->host;
2723	fc_host = shost_to_fc_host(shost);
2724
2725	/* Loop through all the vports and mark them for deletion */
2726	spin_lock_irqsave(shost->host_lock, flags);
2727	list_for_each_entry_safe(vport, next_vport, &fc_host->vports, peers) {
2728	if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)) {
2729	continue;
2730	} else {
2731	vport->flags |= FC_VPORT_DELETING;
2732	queue_work(fc_host_work_q(shost),
2733	work: &vport->vport_delete_work);
2734	}
2735	}
2736	spin_unlock_irqrestore(lock: shost->host_lock, flags);
2737
2738	flush_workqueue(fc_host_work_q(shost));
2739	}
2740
2741	/**
2742	* fcoe_vport_disable() - change vport state
2743	* @vport: vport to bring online/offline
2744	* @disable: should the vport be disabled?
2745	*/
2746	static int fcoe_vport_disable(struct fc_vport *vport, bool disable)
2747	{
2748	struct fc_lport *lport = vport->dd_data;
2749
2750	if (disable) {
2751	fc_vport_set_state(vport, new_state: FC_VPORT_DISABLED);
2752	fc_fabric_logoff(lport);
2753	} else {
2754	lport->boot_time = jiffies;
2755	fc_fabric_login(lport);
2756	fc_vport_setlink(lport);
2757	}
2758
2759	return 0;
2760	}
2761
2762	/**
2763	* fcoe_set_vport_symbolic_name() - append vport string to symbolic name
2764	* @vport: fc_vport with a new symbolic name string
2765	*
2766	* After generating a new symbolic name string, a new RSPN_ID request is
2767	* sent to the name server. There is no response handler, so if it fails
2768	* for some reason it will not be retried.
2769	*/
2770	static void fcoe_set_vport_symbolic_name(struct fc_vport *vport)
2771	{
2772	struct fc_lport *lport = vport->dd_data;
2773	struct fc_frame *fp;
2774	size_t len;
2775
2776	snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
2777	fmt: "%s v%s over %s : %s", FCOE_NAME, FCOE_VERSION,
2778	fcoe_netdev(lport)->name, vport->symbolic_name);
2779
2780	if (lport->state != LPORT_ST_READY)
2781	return;
2782
2783	len = strnlen(fc_host_symbolic_name(lport->host), maxlen: 255);
2784	fp = fc_frame_alloc(dev: lport,
2785	len: sizeof(struct fc_ct_hdr) +
2786	sizeof(struct fc_ns_rspn) + len);
2787	if (!fp)
2788	return;
2789	lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RSPN_ID,
2790	NULL, NULL, 3 * lport->r_a_tov);
2791	}
2792
2793	static void fcoe_fcf_get_vlan_id(struct fcoe_fcf_device *fcf_dev)
2794	{
2795	struct fcoe_ctlr_device *ctlr_dev =
2796	fcoe_fcf_dev_to_ctlr_dev(fcf_dev);
2797	struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr: ctlr_dev);
2798	struct fcoe_interface *fcoe = fcoe_ctlr_priv(ctlr);
2799
2800	fcf_dev->vlan_id = vlan_dev_vlan_id(dev: fcoe->netdev);
2801	}
2802
2803	/**
2804	* fcoe_set_port_id() - Callback from libfc when Port_ID is set.
2805	* @lport: the local port
2806	* @port_id: the port ID
2807	* @fp: the received frame, if any, that caused the port_id to be set.
2808	*
2809	* This routine handles the case where we received a FLOGI and are
2810	* entering point-to-point mode. We need to call fcoe_ctlr_recv_flogi()
2811	* so it can set the non-mapped mode and gateway address.
2812	*
2813	* The FLOGI LS_ACC is handled by fcoe_flogi_resp().
2814	*/
2815	static void fcoe_set_port_id(struct fc_lport *lport,
2816	u32 port_id, struct fc_frame *fp)
2817	{
2818	struct fcoe_port *port = lport_priv(lport);
2819	struct fcoe_interface *fcoe = port->priv;
2820	struct fcoe_ctlr *ctlr = fcoe_to_ctlr(fcoe);
2821
2822	if (fp && fc_frame_payload_op(fp) == ELS_FLOGI)
2823	fcoe_ctlr_recv_flogi(ctlr, lport, fp);
2824	}
2825