Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / drivers / scsi / fcoe / fc_transport_fcoe.c
1 /*
2  * Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License along with
14  * this program; if not, write to the Free Software Foundation, Inc.,
15  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
16  *
17  * Maintained at www.Open-FCoE.org
18  */
19
20 #include <linux/pci.h>
21 #include <scsi/libfcoe.h>
22 #include <scsi/fc_transport_fcoe.h>
23
24 /* internal fcoe transport */
25 struct fcoe_transport_internal {
26         struct fcoe_transport *t;
27         struct net_device *netdev;
28         struct list_head list;
29 };
30
31 /* fcoe transports list and its lock */
32 static LIST_HEAD(fcoe_transports);
33 static DEFINE_MUTEX(fcoe_transports_lock);
34
35 /**
36  * fcoe_transport_default() - Returns ptr to the default transport fcoe_sw
37  */
38 struct fcoe_transport *fcoe_transport_default(void)
39 {
40         return &fcoe_sw_transport;
41 }
42
43 /**
44  * fcoe_transport_to_pcidev() - get the pci dev from a netdev
45  * @netdev: the netdev that pci dev will be retrived from
46  *
47  * Returns: NULL or the corrsponding pci_dev
48  */
49 struct pci_dev *fcoe_transport_pcidev(const struct net_device *netdev)
50 {
51         if (!netdev->dev.parent)
52                 return NULL;
53         return to_pci_dev(netdev->dev.parent);
54 }
55
56 /**
57  * fcoe_transport_device_lookup() - Lookup a transport
58  * @netdev: the netdev the transport to be attached to
59  *
60  * This will look for existing offload driver, if not found, it falls back to
61  * the default sw hba (fcoe_sw) as its fcoe transport.
62  *
63  * Returns: 0 for success
64  */
65 static struct fcoe_transport_internal *
66 fcoe_transport_device_lookup(struct fcoe_transport *t,
67                              struct net_device *netdev)
68 {
69         struct fcoe_transport_internal *ti;
70
71         /* assign the transpor to this device */
72         mutex_lock(&t->devlock);
73         list_for_each_entry(ti, &t->devlist, list) {
74                 if (ti->netdev == netdev) {
75                         mutex_unlock(&t->devlock);
76                         return ti;
77                 }
78         }
79         mutex_unlock(&t->devlock);
80         return NULL;
81 }
82 /**
83  * fcoe_transport_device_add() - Assign a transport to a device
84  * @netdev: the netdev the transport to be attached to
85  *
86  * This will look for existing offload driver, if not found, it falls back to
87  * the default sw hba (fcoe_sw) as its fcoe transport.
88  *
89  * Returns: 0 for success
90  */
91 static int fcoe_transport_device_add(struct fcoe_transport *t,
92                                      struct net_device *netdev)
93 {
94         struct fcoe_transport_internal *ti;
95
96         ti = fcoe_transport_device_lookup(t, netdev);
97         if (ti) {
98                 printk(KERN_DEBUG "fcoe_transport_device_add:"
99                        "device %s is already added to transport %s\n",
100                        netdev->name, t->name);
101                 return -EEXIST;
102         }
103         /* allocate an internal struct to host the netdev and the list */
104         ti = kzalloc(sizeof(*ti), GFP_KERNEL);
105         if (!ti)
106                 return -ENOMEM;
107
108         ti->t = t;
109         ti->netdev = netdev;
110         INIT_LIST_HEAD(&ti->list);
111         dev_hold(ti->netdev);
112
113         mutex_lock(&t->devlock);
114         list_add(&ti->list, &t->devlist);
115         mutex_unlock(&t->devlock);
116
117         printk(KERN_DEBUG "fcoe_transport_device_add:"
118                        "device %s added to transport %s\n",
119                        netdev->name, t->name);
120
121         return 0;
122 }
123
124 /**
125  * fcoe_transport_device_remove() - Remove a device from its transport
126  * @netdev: the netdev the transport to be attached to
127  *
128  * This removes the device from the transport so the given transport will
129  * not manage this device any more
130  *
131  * Returns: 0 for success
132  */
133 static int fcoe_transport_device_remove(struct fcoe_transport *t,
134                                         struct net_device *netdev)
135 {
136         struct fcoe_transport_internal *ti;
137
138         ti = fcoe_transport_device_lookup(t, netdev);
139         if (!ti) {
140                 printk(KERN_DEBUG "fcoe_transport_device_remove:"
141                        "device %s is not managed by transport %s\n",
142                        netdev->name, t->name);
143                 return -ENODEV;
144         }
145         mutex_lock(&t->devlock);
146         list_del(&ti->list);
147         mutex_unlock(&t->devlock);
148         printk(KERN_DEBUG "fcoe_transport_device_remove:"
149                "device %s removed from transport %s\n",
150                netdev->name, t->name);
151         dev_put(ti->netdev);
152         kfree(ti);
153         return 0;
154 }
155
156 /**
157  * fcoe_transport_device_remove_all() - Remove all from transport devlist
158  *
159  * This removes the device from the transport so the given transport will
160  * not manage this device any more
161  *
162  * Returns: 0 for success
163  */
164 static void fcoe_transport_device_remove_all(struct fcoe_transport *t)
165 {
166         struct fcoe_transport_internal *ti, *tmp;
167
168         mutex_lock(&t->devlock);
169         list_for_each_entry_safe(ti, tmp, &t->devlist, list) {
170                 list_del(&ti->list);
171                 kfree(ti);
172         }
173         mutex_unlock(&t->devlock);
174 }
175
176 /**
177  * fcoe_transport_match() - Use the bus device match function to match the hw
178  * @t: The fcoe transport to check
179  * @netdev: The netdev to match against
180  *
181  * This function is used to check if the given transport wants to manage the
182  * input netdev. if the transports implements the match function, it will be
183  * called, o.w. we just compare the pci vendor and device id.
184  *
185  * Returns: true for match up
186  */
187 static bool fcoe_transport_match(struct fcoe_transport *t,
188                                  struct net_device *netdev)
189 {
190         /* match transport by vendor and device id */
191         struct pci_dev *pci;
192
193         pci = fcoe_transport_pcidev(netdev);
194
195         if (pci) {
196                 printk(KERN_DEBUG "fcoe_transport_match:"
197                        "%s:%x:%x -- %s:%x:%x\n",
198                        t->name, t->vendor, t->device,
199                        netdev->name, pci->vendor, pci->device);
200
201                 /* if transport supports match */
202                 if (t->match)
203                         return t->match(netdev);
204
205                 /* else just compare the vendor and device id: pci only */
206                 return (t->vendor == pci->vendor) && (t->device == pci->device);
207         }
208         return false;
209 }
210
211 /**
212  * fcoe_transport_lookup() - Check if the transport is already registered
213  * @t: the transport to be looked up
214  *
215  * This compares the parent device (pci) vendor and device id
216  *
217  * Returns: NULL if not found
218  *
219  * TODO: return default sw transport if no other transport is found
220  */
221 static struct fcoe_transport *
222 fcoe_transport_lookup(struct net_device *netdev)
223 {
224         struct fcoe_transport *t;
225
226         mutex_lock(&fcoe_transports_lock);
227         list_for_each_entry(t, &fcoe_transports, list) {
228                 if (fcoe_transport_match(t, netdev)) {
229                         mutex_unlock(&fcoe_transports_lock);
230                         return t;
231                 }
232         }
233         mutex_unlock(&fcoe_transports_lock);
234
235         printk(KERN_DEBUG "fcoe_transport_lookup:"
236                "use default transport for %s\n", netdev->name);
237         return fcoe_transport_default();
238 }
239
240 /**
241  * fcoe_transport_register() - Adds a fcoe transport to the fcoe transports list
242  * @t: ptr to the fcoe transport to be added
243  *
244  * Returns: 0 for success
245  */
246 int fcoe_transport_register(struct fcoe_transport *t)
247 {
248         struct fcoe_transport *tt;
249
250         /* TODO - add fcoe_transport specific initialization here */
251         mutex_lock(&fcoe_transports_lock);
252         list_for_each_entry(tt, &fcoe_transports, list) {
253                 if (tt == t) {
254                         mutex_unlock(&fcoe_transports_lock);
255                         return -EEXIST;
256                 }
257         }
258         list_add_tail(&t->list, &fcoe_transports);
259         mutex_unlock(&fcoe_transports_lock);
260
261         printk(KERN_DEBUG "fcoe_transport_register:%s\n", t->name);
262
263         return 0;
264 }
265 EXPORT_SYMBOL_GPL(fcoe_transport_register);
266
267 /**
268  * fcoe_transport_unregister() - Remove the tranport fro the fcoe transports list
269  * @t: ptr to the fcoe transport to be removed
270  *
271  * Returns: 0 for success
272  */
273 int fcoe_transport_unregister(struct fcoe_transport *t)
274 {
275         struct fcoe_transport *tt, *tmp;
276
277         mutex_lock(&fcoe_transports_lock);
278         list_for_each_entry_safe(tt, tmp, &fcoe_transports, list) {
279                 if (tt == t) {
280                         list_del(&t->list);
281                         mutex_unlock(&fcoe_transports_lock);
282                         fcoe_transport_device_remove_all(t);
283                         printk(KERN_DEBUG "fcoe_transport_unregister:%s\n",
284                                t->name);
285                         return 0;
286                 }
287         }
288         mutex_unlock(&fcoe_transports_lock);
289         return -ENODEV;
290 }
291 EXPORT_SYMBOL_GPL(fcoe_transport_unregister);
292
293 /**
294  * fcoe_load_transport_driver() - Load an offload driver by alias name
295  * @netdev: the target net device
296  *
297  * Requests for an offload driver module as the fcoe transport, if fails, it
298  * falls back to use the SW HBA (fcoe_sw) as its transport
299  *
300  * TODO -
301  *      1. supports only PCI device
302  *      2. needs fix for VLAn and bonding
303  *      3. pure hw fcoe hba may not have netdev
304  *
305  * Returns: 0 for success
306  */
307 int fcoe_load_transport_driver(struct net_device *netdev)
308 {
309         struct pci_dev *pci;
310         struct device *dev = netdev->dev.parent;
311
312         if (fcoe_transport_lookup(netdev)) {
313                 /* load default transport */
314                 printk(KERN_DEBUG "fcoe: already loaded transport for %s\n",
315                        netdev->name);
316                 return -EEXIST;
317         }
318
319         pci = to_pci_dev(dev);
320         if (dev->bus != &pci_bus_type) {
321                 printk(KERN_DEBUG "fcoe: support noly PCI device\n");
322                 return -ENODEV;
323         }
324         printk(KERN_DEBUG "fcoe: loading driver fcoe-pci-0x%04x-0x%04x\n",
325                pci->vendor, pci->device);
326
327         return request_module("fcoe-pci-0x%04x-0x%04x",
328                               pci->vendor, pci->device);
329
330 }
331 EXPORT_SYMBOL_GPL(fcoe_load_transport_driver);
332
333 /**
334  * fcoe_transport_attach() - Load transport to fcoe
335  * @netdev: the netdev the transport to be attached to
336  *
337  * This will look for existing offload driver, if not found, it falls back to
338  * the default sw hba (fcoe_sw) as its fcoe transport.
339  *
340  * Returns: 0 for success
341  */
342 int fcoe_transport_attach(struct net_device *netdev)
343 {
344         struct fcoe_transport *t;
345
346         /* find the corresponding transport */
347         t = fcoe_transport_lookup(netdev);
348         if (!t) {
349                 printk(KERN_DEBUG "fcoe_transport_attach"
350                        ":no transport for %s:use %s\n",
351                        netdev->name, t->name);
352                 return -ENODEV;
353         }
354         /* add to the transport */
355         if (fcoe_transport_device_add(t, netdev)) {
356                 printk(KERN_DEBUG "fcoe_transport_attach"
357                        ":failed to add %s to tramsport %s\n",
358                        netdev->name, t->name);
359                 return -EIO;
360         }
361         /* transport create function */
362         if (t->create)
363                 t->create(netdev);
364
365         printk(KERN_DEBUG "fcoe_transport_attach:transport %s for %s\n",
366                t->name, netdev->name);
367         return 0;
368 }
369 EXPORT_SYMBOL_GPL(fcoe_transport_attach);
370
371 /**
372  * fcoe_transport_release() - Unload transport from fcoe
373  * @netdev: the net device on which fcoe is to be released
374  *
375  * Returns: 0 for success
376  */
377 int fcoe_transport_release(struct net_device *netdev)
378 {
379         struct fcoe_transport *t;
380
381         /* find the corresponding transport */
382         t = fcoe_transport_lookup(netdev);
383         if (!t) {
384                 printk(KERN_DEBUG "fcoe_transport_release:"
385                        "no transport for %s:use %s\n",
386                        netdev->name, t->name);
387                 return -ENODEV;
388         }
389         /* remove the device from the transport */
390         if (fcoe_transport_device_remove(t, netdev)) {
391                 printk(KERN_DEBUG "fcoe_transport_release:"
392                        "failed to add %s to tramsport %s\n",
393                        netdev->name, t->name);
394                 return -EIO;
395         }
396         /* transport destroy function */
397         if (t->destroy)
398                 t->destroy(netdev);
399
400         printk(KERN_DEBUG "fcoe_transport_release:"
401                "device %s dettached from transport %s\n",
402                netdev->name, t->name);
403
404         return 0;
405 }
406 EXPORT_SYMBOL_GPL(fcoe_transport_release);
407
408 /**
409  * fcoe_transport_init() - Initializes fcoe transport layer
410  *
411  * This prepares for the fcoe transport layer
412  *
413  * Returns: none
414  */
415 int __init fcoe_transport_init(void)
416 {
417         INIT_LIST_HEAD(&fcoe_transports);
418         mutex_init(&fcoe_transports_lock);
419         return 0;
420 }
421
422 /**
423  * fcoe_transport_exit() - Cleans up the fcoe transport layer
424  *
425  * This cleans up the fcoe transport layer. removing any transport on the list,
426  * note that the transport destroy func is not called here.
427  *
428  * Returns: none
429  */
430 int __exit fcoe_transport_exit(void)
431 {
432         struct fcoe_transport *t, *tmp;
433
434         mutex_lock(&fcoe_transports_lock);
435         list_for_each_entry_safe(t, tmp, &fcoe_transports, list) {
436                 list_del(&t->list);
437                 mutex_unlock(&fcoe_transports_lock);
438                 fcoe_transport_device_remove_all(t);
439                 mutex_lock(&fcoe_transports_lock);
440         }
441         mutex_unlock(&fcoe_transports_lock);
442         return 0;
443 }