Imported xen patches.
[people/pmueller/ipfire-2.x.git] / src / patches / 60005_sfc-driverlink.patch1
1 From: David Riddoch <driddoch@solarflare.com>
2 commit d96c061bfd1839e34e136de0555564520acc97af
3 Author: Steve Hodgson <shodgson@solarflare.com>
4 Date: Mon Jul 14 15:38:47 2008 +0100
5
6 Subject: sfc: Driverlink API for exporting hardware features to client drivers
7
8 References: FATE#303479
9 Acked-by: jbeulich@novell.com
10
11 Index: head-2008-08-18/drivers/net/sfc/Makefile
12 ===================================================================
13 --- head-2008-08-18.orig/drivers/net/sfc/Makefile 2008-08-18 10:16:43.000000000 +0200
14 +++ head-2008-08-18/drivers/net/sfc/Makefile 2008-08-18 10:16:46.000000000 +0200
15 @@ -1,5 +1,5 @@
16 sfc-y += efx.o falcon.o tx.o rx.o falcon_xmac.o \
17 selftest.o ethtool.o xfp_phy.o \
18 - mdio_10g.o tenxpress.o boards.o sfe4001.o
19 -
20 + mdio_10g.o tenxpress.o boards.o sfe4001.o \
21 + driverlink.o
22 obj-$(CONFIG_SFC) += sfc.o
23 Index: head-2008-08-18/drivers/net/sfc/driverlink.c
24 ===================================================================
25 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
26 +++ head-2008-08-18/drivers/net/sfc/driverlink.c 2008-08-18 10:16:46.000000000 +0200
27 @@ -0,0 +1,367 @@
28 +/****************************************************************************
29 + * Driver for Solarflare Solarstorm network controllers and boards
30 + * Copyright 2005 Fen Systems Ltd.
31 + * Copyright 2005-2008 Solarflare Communications Inc.
32 + *
33 + * This program is free software; you can redistribute it and/or modify it
34 + * under the terms of the GNU General Public License version 2 as published
35 + * by the Free Software Foundation, incorporated herein by reference.
36 + */
37 +
38 +#include <linux/module.h>
39 +#include <linux/list.h>
40 +#include <linux/skbuff.h>
41 +#include <linux/rtnetlink.h>
42 +#include "net_driver.h"
43 +#include "efx.h"
44 +#include "driverlink_api.h"
45 +#include "driverlink.h"
46 +
47 +/* Protects @efx_driverlink_lock and @efx_driver_list */
48 +static DEFINE_MUTEX(efx_driverlink_lock);
49 +
50 +/* List of all registered drivers */
51 +static LIST_HEAD(efx_driver_list);
52 +
53 +/* List of all registered Efx ports */
54 +static LIST_HEAD(efx_port_list);
55 +
56 +/**
57 + * Driver link handle used internally to track devices
58 + * @efx_dev: driverlink device handle exported to consumers
59 + * @efx: efx_nic backing the driverlink device
60 + * @port_node: per-device list head
61 + * @driver_node: per-driver list head
62 + */
63 +struct efx_dl_handle {
64 + struct efx_dl_device efx_dev;
65 + struct efx_nic *efx;
66 + struct list_head port_node;
67 + struct list_head driver_node;
68 +};
69 +
70 +static struct efx_dl_handle *efx_dl_handle(struct efx_dl_device *efx_dev)
71 +{
72 + return container_of(efx_dev, struct efx_dl_handle, efx_dev);
73 +}
74 +
75 +/* Remove an Efx device, and call the driver's remove() callback if
76 + * present. The caller must hold @efx_driverlink_lock. */
77 +static void efx_dl_del_device(struct efx_dl_device *efx_dev)
78 +{
79 + struct efx_dl_handle *efx_handle = efx_dl_handle(efx_dev);
80 +
81 + EFX_INFO(efx_handle->efx, "%s driverlink client unregistering\n",
82 + efx_dev->driver->name);
83 +
84 + if (efx_dev->driver->remove)
85 + efx_dev->driver->remove(efx_dev);
86 +
87 + list_del(&efx_handle->driver_node);
88 + list_del(&efx_handle->port_node);
89 +
90 + kfree(efx_handle);
91 +}
92 +
93 +/* Attempt to probe the given device with the driver, creating a
94 + * new &struct efx_dl_device. If the probe routine returns an error,
95 + * then the &struct efx_dl_device is destroyed */
96 +static void efx_dl_try_add_device(struct efx_nic *efx,
97 + struct efx_dl_driver *driver)
98 +{
99 + struct efx_dl_handle *efx_handle;
100 + struct efx_dl_device *efx_dev;
101 + int rc;
102 +
103 + efx_handle = kzalloc(sizeof(*efx_handle), GFP_KERNEL);
104 + if (!efx_handle)
105 + goto fail;
106 + efx_dev = &efx_handle->efx_dev;
107 + efx_handle->efx = efx;
108 + efx_dev->driver = driver;
109 + efx_dev->pci_dev = efx->pci_dev;
110 + INIT_LIST_HEAD(&efx_handle->port_node);
111 + INIT_LIST_HEAD(&efx_handle->driver_node);
112 +
113 + rc = driver->probe(efx_dev, efx->net_dev,
114 + efx->dl_info, efx->silicon_rev);
115 + if (rc)
116 + goto fail;
117 +
118 + list_add_tail(&efx_handle->driver_node, &driver->device_list);
119 + list_add_tail(&efx_handle->port_node, &efx->dl_device_list);
120 +
121 + EFX_INFO(efx, "%s driverlink client registered\n", driver->name);
122 + return;
123 +
124 + fail:
125 + EFX_INFO(efx, "%s driverlink client skipped\n", driver->name);
126 +
127 + kfree(efx_handle);
128 +}
129 +
130 +/* Unregister a driver from the driverlink layer, calling the
131 + * driver's remove() callback for every attached device */
132 +void efx_dl_unregister_driver(struct efx_dl_driver *driver)
133 +{
134 + struct efx_dl_handle *efx_handle, *efx_handle_n;
135 +
136 + printk(KERN_INFO "Efx driverlink unregistering %s driver\n",
137 + driver->name);
138 +
139 + mutex_lock(&efx_driverlink_lock);
140 +
141 + list_for_each_entry_safe(efx_handle, efx_handle_n,
142 + &driver->device_list, driver_node)
143 + efx_dl_del_device(&efx_handle->efx_dev);
144 +
145 + list_del(&driver->node);
146 +
147 + mutex_unlock(&efx_driverlink_lock);
148 +}
149 +EXPORT_SYMBOL(efx_dl_unregister_driver);
150 +
151 +/* Register a new driver with the driverlink layer. The driver's
152 + * probe routine will be called for every attached nic. */
153 +int efx_dl_register_driver(struct efx_dl_driver *driver)
154 +{
155 + struct efx_nic *efx;
156 + int rc;
157 +
158 + printk(KERN_INFO "Efx driverlink registering %s driver\n",
159 + driver->name);
160 +
161 + INIT_LIST_HEAD(&driver->node);
162 + INIT_LIST_HEAD(&driver->device_list);
163 +
164 + rc = mutex_lock_interruptible(&efx_driverlink_lock);
165 + if (rc)
166 + return rc;
167 +
168 + list_add_tail(&driver->node, &efx_driver_list);
169 + list_for_each_entry(efx, &efx_port_list, dl_node)
170 + efx_dl_try_add_device(efx, driver);
171 +
172 + mutex_unlock(&efx_driverlink_lock);
173 +
174 + return 0;
175 +}
176 +EXPORT_SYMBOL(efx_dl_register_driver);
177 +
178 +void efx_dl_unregister_nic(struct efx_nic *efx)
179 +{
180 + struct efx_dl_handle *efx_handle, *efx_handle_n;
181 +
182 + mutex_lock(&efx_driverlink_lock);
183 +
184 + list_for_each_entry_safe_reverse(efx_handle, efx_handle_n,
185 + &efx->dl_device_list,
186 + port_node)
187 + efx_dl_del_device(&efx_handle->efx_dev);
188 +
189 + list_del(&efx->dl_node);
190 +
191 + mutex_unlock(&efx_driverlink_lock);
192 +}
193 +
194 +int efx_dl_register_nic(struct efx_nic *efx)
195 +{
196 + struct efx_dl_driver *driver;
197 + int rc;
198 +
199 + rc = mutex_lock_interruptible(&efx_driverlink_lock);
200 + if (rc)
201 + return rc;
202 +
203 + list_add_tail(&efx->dl_node, &efx_port_list);
204 + list_for_each_entry(driver, &efx_driver_list, node)
205 + efx_dl_try_add_device(efx, driver);
206 +
207 + mutex_unlock(&efx_driverlink_lock);
208 +
209 + return 0;
210 +}
211 +
212 +/* Dummy callback implementations.
213 + * To avoid a branch point on the fast-path, the callbacks are always
214 + * implemented - they are never NULL.
215 + */
216 +static enum efx_veto efx_dummy_tx_packet_callback(struct efx_dl_device *efx_dev,
217 + struct sk_buff *skb)
218 +{
219 + return EFX_ALLOW_PACKET;
220 +}
221 +
222 +static enum efx_veto efx_dummy_rx_packet_callback(struct efx_dl_device *efx_dev,
223 + const char *pkt_buf, int len)
224 +{
225 + return EFX_ALLOW_PACKET;
226 +}
227 +
228 +static int efx_dummy_request_mtu_callback(struct efx_dl_device *efx_dev,
229 + int new_mtu)
230 +{
231 + return 0;
232 +}
233 +
234 +static void efx_dummy_mtu_changed_callback(struct efx_dl_device *efx_dev,
235 + int mtu)
236 +{
237 + return;
238 +}
239 +
240 +static void efx_dummy_event_callback(struct efx_dl_device *efx_dev, void *event)
241 +{
242 + return;
243 +}
244 +
245 +struct efx_dl_callbacks efx_default_callbacks = {
246 + .tx_packet = efx_dummy_tx_packet_callback,
247 + .rx_packet = efx_dummy_rx_packet_callback,
248 + .request_mtu = efx_dummy_request_mtu_callback,
249 + .mtu_changed = efx_dummy_mtu_changed_callback,
250 + .event = efx_dummy_event_callback,
251 +};
252 +
253 +void efx_dl_unregister_callbacks(struct efx_dl_device *efx_dev,
254 + struct efx_dl_callbacks *callbacks)
255 +{
256 + struct efx_dl_handle *efx_handle = efx_dl_handle(efx_dev);
257 + struct efx_nic *efx = efx_handle->efx;
258 +
259 + efx_suspend(efx);
260 +
261 + EFX_INFO(efx, "removing callback hooks into %s driver\n",
262 + efx_dev->driver->name);
263 +
264 + if (callbacks->tx_packet) {
265 + BUG_ON(efx->dl_cb_dev.tx_packet != efx_dev);
266 + efx->dl_cb.tx_packet = efx_default_callbacks.tx_packet;
267 + efx->dl_cb_dev.tx_packet = NULL;
268 + }
269 + if (callbacks->rx_packet) {
270 + BUG_ON(efx->dl_cb_dev.rx_packet != efx_dev);
271 + efx->dl_cb.rx_packet = efx_default_callbacks.rx_packet;
272 + efx->dl_cb_dev.rx_packet = NULL;
273 + }
274 + if (callbacks->request_mtu) {
275 + BUG_ON(efx->dl_cb_dev.request_mtu != efx_dev);
276 + efx->dl_cb.request_mtu = efx_default_callbacks.request_mtu;
277 + efx->dl_cb_dev.request_mtu = NULL;
278 + }
279 + if (callbacks->mtu_changed) {
280 + BUG_ON(efx->dl_cb_dev.mtu_changed != efx_dev);
281 + efx->dl_cb.mtu_changed = efx_default_callbacks.mtu_changed;
282 + efx->dl_cb_dev.mtu_changed = NULL;
283 + }
284 + if (callbacks->event) {
285 + BUG_ON(efx->dl_cb_dev.event != efx_dev);
286 + efx->dl_cb.event = efx_default_callbacks.event;
287 + efx->dl_cb_dev.event = NULL;
288 + }
289 +
290 + efx_resume(efx);
291 +}
292 +EXPORT_SYMBOL(efx_dl_unregister_callbacks);
293 +
294 +int efx_dl_register_callbacks(struct efx_dl_device *efx_dev,
295 + struct efx_dl_callbacks *callbacks)
296 +{
297 + struct efx_dl_handle *efx_handle = efx_dl_handle(efx_dev);
298 + struct efx_nic *efx = efx_handle->efx;
299 + int rc = 0;
300 +
301 + efx_suspend(efx);
302 +
303 + /* Check that the requested callbacks are not already hooked. */
304 + if ((callbacks->tx_packet && efx->dl_cb_dev.tx_packet) ||
305 + (callbacks->rx_packet && efx->dl_cb_dev.rx_packet) ||
306 + (callbacks->request_mtu && efx->dl_cb_dev.request_mtu) ||
307 + (callbacks->mtu_changed && efx->dl_cb_dev.mtu_changed) ||
308 + (callbacks->event && efx->dl_cb_dev.event)) {
309 + rc = -EBUSY;
310 + goto out;
311 + }
312 +
313 + EFX_INFO(efx, "adding callback hooks to %s driver\n",
314 + efx_dev->driver->name);
315 +
316 + /* Hook in the requested callbacks, leaving any NULL members
317 + * referencing the members of @efx_default_callbacks */
318 + if (callbacks->tx_packet) {
319 + efx->dl_cb.tx_packet = callbacks->tx_packet;
320 + efx->dl_cb_dev.tx_packet = efx_dev;
321 + }
322 + if (callbacks->rx_packet) {
323 + efx->dl_cb.rx_packet = callbacks->rx_packet;
324 + efx->dl_cb_dev.rx_packet = efx_dev;
325 + }
326 + if (callbacks->request_mtu) {
327 + efx->dl_cb.request_mtu = callbacks->request_mtu;
328 + efx->dl_cb_dev.request_mtu = efx_dev;
329 + }
330 + if (callbacks->mtu_changed) {
331 + efx->dl_cb.mtu_changed = callbacks->mtu_changed;
332 + efx->dl_cb_dev.mtu_changed = efx_dev;
333 + }
334 + if (callbacks->event) {
335 + efx->dl_cb.event = callbacks->event;
336 + efx->dl_cb_dev.event = efx_dev;
337 + }
338 +
339 + out:
340 + efx_resume(efx);
341 +
342 + return rc;
343 +}
344 +EXPORT_SYMBOL(efx_dl_register_callbacks);
345 +
346 +void efx_dl_schedule_reset(struct efx_dl_device *efx_dev)
347 +{
348 + struct efx_dl_handle *efx_handle = efx_dl_handle(efx_dev);
349 + struct efx_nic *efx = efx_handle->efx;
350 +
351 + efx_schedule_reset(efx, RESET_TYPE_ALL);
352 +}
353 +EXPORT_SYMBOL(efx_dl_schedule_reset);
354 +
355 +void efx_dl_reset_unlock(void)
356 +{
357 + mutex_unlock(&efx_driverlink_lock);
358 +}
359 +
360 +/* Suspend ready for reset, serialising against all the driverlink interfacse
361 + * and calling the suspend() callback of every registered driver */
362 +void efx_dl_reset_suspend(struct efx_nic *efx)
363 +{
364 + struct efx_dl_handle *efx_handle;
365 + struct efx_dl_device *efx_dev;
366 +
367 + mutex_lock(&efx_driverlink_lock);
368 +
369 + list_for_each_entry_reverse(efx_handle,
370 + &efx->dl_device_list,
371 + port_node) {
372 + efx_dev = &efx_handle->efx_dev;
373 + if (efx_dev->driver->reset_suspend)
374 + efx_dev->driver->reset_suspend(efx_dev);
375 + }
376 +}
377 +
378 +/* Resume after a reset, calling the resume() callback of every registered
379 + * driver, and releasing @Efx_driverlink_lock acquired in
380 + * efx_dl_reset_resume() */
381 +void efx_dl_reset_resume(struct efx_nic *efx, int ok)
382 +{
383 + struct efx_dl_handle *efx_handle;
384 + struct efx_dl_device *efx_dev;
385 +
386 + list_for_each_entry(efx_handle, &efx->dl_device_list,
387 + port_node) {
388 + efx_dev = &efx_handle->efx_dev;
389 + if (efx_dev->driver->reset_resume)
390 + efx_dev->driver->reset_resume(efx_dev, ok);
391 + }
392 +
393 + mutex_unlock(&efx_driverlink_lock);
394 +}
395 Index: head-2008-08-18/drivers/net/sfc/driverlink.h
396 ===================================================================
397 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
398 +++ head-2008-08-18/drivers/net/sfc/driverlink.h 2008-08-18 10:16:46.000000000 +0200
399 @@ -0,0 +1,43 @@
400 +/****************************************************************************
401 + * Driver for Solarflare Solarstorm network controllers and boards
402 + * Copyright 2005 Fen Systems Ltd.
403 + * Copyright 2006-2008 Solarflare Communications Inc.
404 + *
405 + * This program is free software; you can redistribute it and/or modify it
406 + * under the terms of the GNU General Public License version 2 as published
407 + * by the Free Software Foundation, incorporated herein by reference.
408 + */
409 +
410 +#ifndef EFX_DRIVERLINK_H
411 +#define EFX_DRIVERLINK_H
412 +
413 +/* Forward declarations */
414 +struct efx_dl_device;
415 +struct efx_nic;
416 +
417 +/* Efx callback devices
418 + *
419 + * A list of the devices that own each callback. The partner to
420 + * struct efx_dl_callbacks.
421 + */
422 +struct efx_dl_cb_devices {
423 + struct efx_dl_device *tx_packet;
424 + struct efx_dl_device *rx_packet;
425 + struct efx_dl_device *request_mtu;
426 + struct efx_dl_device *mtu_changed;
427 + struct efx_dl_device *event;
428 +};
429 +
430 +extern struct efx_dl_callbacks efx_default_callbacks;
431 +
432 +#define EFX_DL_CALLBACK(_port, _name, ...) \
433 + (_port)->dl_cb._name((_port)->dl_cb_dev._name, __VA_ARGS__)
434 +
435 +extern int efx_dl_register_nic(struct efx_nic *efx);
436 +extern void efx_dl_unregister_nic(struct efx_nic *efx);
437 +
438 +/* Suspend and resume client drivers over a hardware reset */
439 +extern void efx_dl_reset_suspend(struct efx_nic *efx);
440 +extern void efx_dl_reset_resume(struct efx_nic *efx, int ok);
441 +
442 +#endif /* EFX_DRIVERLINK_H */
443 Index: head-2008-08-18/drivers/net/sfc/driverlink_api.h
444 ===================================================================
445 --- /dev/null 1970-01-01 00:00:00.000000000 +0000
446 +++ head-2008-08-18/drivers/net/sfc/driverlink_api.h 2008-08-18 10:16:46.000000000 +0200
447 @@ -0,0 +1,303 @@
448 +/****************************************************************************
449 + * Driver for Solarflare Solarstorm network controllers and boards
450 + * Copyright 2005-2006 Fen Systems Ltd.
451 + * Copyright 2005-2008 Solarflare Communications Inc.
452 + *
453 + * This program is free software; you can redistribute it and/or modify it
454 + * under the terms of the GNU General Public License version 2 as published
455 + * by the Free Software Foundation, incorporated herein by reference.
456 + */
457 +
458 +#ifndef EFX_DRIVERLINK_API_H
459 +#define EFX_DRIVERLINK_API_H
460 +
461 +#include <linux/list.h>
462 +
463 +/* Forward declarations */
464 +struct pci_dev;
465 +struct net_device;
466 +struct sk_buff;
467 +struct efx_dl_device;
468 +struct efx_dl_device_info;
469 +
470 +/* An extra safeguard in addition to symbol versioning */
471 +#define EFX_DRIVERLINK_API_VERSION 2
472 +
473 +/**
474 + * struct efx_dl_driver - An Efx driverlink device driver
475 + *
476 + * A driverlink client defines and initializes as many instances of
477 + * efx_dl_driver as required, registering each one with
478 + * efx_dl_register_driver().
479 + *
480 + * @name: Name of the driver
481 + * @probe: Called when device added
482 + * The client should use the @def_info linked list and @silicon_rev
483 + * to determine if they wish to attach to this device.
484 + * Context: process, driverlink semaphore held
485 + * @remove: Called when device removed
486 + * The client must ensure the finish all operations with this
487 + * device before returning from this method.
488 + * Context: process, driverlink semaphore held
489 + * @reset_suspend: Called before device is reset
490 + * Called immediately before a hardware reset. The client must stop all
491 + * hardware processing before returning from this method. Callbacks will
492 + * be inactive when this method is called.
493 + * Context: process, driverlink semaphore held. rtnl_lock may be held
494 + * @reset_resume: Called after device is reset
495 + * Called after a hardware reset. If @ok is true, the client should
496 + * state and resume normal operations. If @ok is false, the client should
497 + * abandon use of the hardware resources. remove() will still be called.
498 + * Context: process, driverlink semaphore held. rtnl_lock may be held
499 + */
500 +struct efx_dl_driver {
501 + const char *name;
502 +
503 + int (*probe) (struct efx_dl_device *efx_dl_dev,
504 + const struct net_device *net_dev,
505 + const struct efx_dl_device_info *dev_info,
506 + const char *silicon_rev);
507 + void (*remove) (struct efx_dl_device *efx_dev);
508 + void (*reset_suspend) (struct efx_dl_device *efx_dev);
509 + void (*reset_resume) (struct efx_dl_device *efx_dev, int ok);
510 +
511 +/* private: */
512 + struct list_head node;
513 + struct list_head device_list;
514 +};
515 +
516 +/**
517 + * enum efx_dl_device_info_type - Device information identifier.
518 + *
519 + * Used to identify each item in the &struct efx_dl_device_info linked list
520 + * provided to each driverlink client in the probe() @dev_info member.
521 + *
522 + * @EFX_DL_FALCON_RESOURCES: Information type is &struct efx_dl_falcon_resources
523 + */
524 +enum efx_dl_device_info_type {
525 + /** Falcon resources available for export */
526 + EFX_DL_FALCON_RESOURCES = 0,
527 +};
528 +
529 +/**
530 + * struct efx_dl_device_info - device information structure
531 + *
532 + * @next: Link to next structure, if any
533 + * @type: Type code for this structure
534 + */
535 +struct efx_dl_device_info {
536 + struct efx_dl_device_info *next;
537 + enum efx_dl_device_info_type type;
538 +};
539 +
540 +/**
541 + * enum efx_dl_falcon_resource_flags - Falcon resource information flags.
542 + *
543 + * Flags that describe hardware variations for the current Falcon device.
544 + *
545 + * @EFX_DL_FALCON_DUAL_FUNC: Port is dual-function.
546 + * Certain silicon revisions have two pci functions, and require
547 + * certain hardware resources to be accessed via the secondary
548 + * function
549 + * @EFX_DL_FALCON_USE_MSI: Port is initialised to use MSI/MSI-X interrupts.
550 + * Falcon supports traditional legacy interrupts and MSI/MSI-X
551 + * interrupts. The choice is made at run time by the sfc driver, and
552 + * notified to the clients by this enumeration
553 + */
554 +enum efx_dl_falcon_resource_flags {
555 + EFX_DL_FALCON_DUAL_FUNC = 0x1,
556 + EFX_DL_FALCON_USE_MSI = 0x2,
557 +};
558 +
559 +/**
560 + * struct efx_dl_falcon_resources - Falcon resource information.
561 + *
562 + * This structure describes Falcon hardware resources available for
563 + * use by a driverlink driver.
564 + *
565 + * @hdr: Resource linked list header
566 + * @biu_lock: Register access lock.
567 + * Some Falcon revisions require register access for configuration
568 + * registers to be serialised between ports and PCI functions.
569 + * The sfc driver will provide the appropriate lock semantics for
570 + * the underlying hardware.
571 + * @buffer_table_min: First available buffer table entry
572 + * @buffer_table_lim: Last available buffer table entry + 1
573 + * @evq_timer_min: First available event queue with timer
574 + * @evq_timer_lim: Last available event queue with timer + 1
575 + * @evq_int_min: First available event queue with interrupt
576 + * @evq_int_lim: Last available event queue with interrupt + 1
577 + * @rxq_min: First available RX queue
578 + * @rxq_lim: Last available RX queue + 1
579 + * @txq_min: First available TX queue
580 + * @txq_lim: Last available TX queue + 1
581 + * @flags: Hardware variation flags
582 + */
583 +struct efx_dl_falcon_resources {
584 + struct efx_dl_device_info hdr;
585 + spinlock_t *biu_lock;
586 + unsigned buffer_table_min;
587 + unsigned buffer_table_lim;
588 + unsigned evq_timer_min;
589 + unsigned evq_timer_lim;
590 + unsigned evq_int_min;
591 + unsigned evq_int_lim;
592 + unsigned rxq_min;
593 + unsigned rxq_lim;
594 + unsigned txq_min;
595 + unsigned txq_lim;
596 + enum efx_dl_falcon_resource_flags flags;
597 +};
598 +
599 +/**
600 + * struct efx_dl_device - An Efx driverlink device.
601 + *
602 + * @pci_dev: PCI device used by the sfc driver.
603 + * @priv: Driver private data
604 + * Driverlink clients can use this to store a pointer to their
605 + * internal per-device data structure. Each (driver, device)
606 + * tuple has a separate &struct efx_dl_device, so clients can use
607 + * this @priv field independently.
608 + * @driver: Efx driverlink driver for this device
609 + */
610 +struct efx_dl_device {
611 + struct pci_dev *pci_dev;
612 + void *priv;
613 + struct efx_dl_driver *driver;
614 +};
615 +
616 +/**
617 + * enum efx_veto - Packet veto request flag.
618 + *
619 + * This is the return type for the rx_packet() and tx_packet() methods
620 + * in &struct efx_dl_callbacks.
621 + *
622 + * @EFX_ALLOW_PACKET: Packet may be transmitted/received
623 + * @EFX_VETO_PACKET: Packet must not be transmitted/received
624 + */
625 +enum efx_veto {
626 + EFX_ALLOW_PACKET = 0,
627 + EFX_VETO_PACKET = 1,
628 +};
629 +
630 +/**
631 + * struct efx_dl_callbacks - Efx callbacks
632 + *
633 + * This is a tighly controlled set of simple callbacks, that are attached
634 + * to the sfc driver via efx_dl_register_callbacks(). They export just enough
635 + * state to allow clients to make use of the available hardware resources.
636 + *
637 + * For efficiency, only one client can hook each callback. Since these
638 + * callbacks are called on packet transmit and reception paths, and the
639 + * sfc driver may have multiple tx and rx queues per port, clients should
640 + * avoid acquiring locks or allocating memory.
641 + *
642 + * @tx_packet: Called when packet is about to be transmitted
643 + * Called for every packet about to be transmitted, providing means
644 + * for the client to snoop traffic, and veto transmission by returning
645 + * %EFX_VETO_PACKET (the sfc driver will subsequently free the skb).
646 + * Context: tasklet, netif_tx_lock held
647 + * @rx_packet: Called when packet is received
648 + * Called for every received packet (after LRO), allowing the client
649 + * to snoop every received packet (on every rx queue), and veto
650 + * reception by returning %EFX_VETO_PACKET.
651 + * Context: tasklet
652 + * @request_mtu: Called to request MTU change.
653 + * Called whenever the user requests the net_dev mtu to be changed.
654 + * If the client returns an error, the mtu change is aborted. The sfc
655 + * driver guarantees that no other callbacks are running.
656 + * Context: process, rtnl_lock held.
657 + * @mtu_changed: Called when MTU has been changed.
658 + * Called after the mtu has been successfully changed, always after
659 + * a previous call to request_mtu(). The sfc driver guarantees that no
660 + * other callbacks are running.
661 + * Context: process, rtnl_lock held.
662 + * @event: Called when a hardware NIC event is not understood by the sfc driver.
663 + * Context: tasklet.
664 + */
665 +struct efx_dl_callbacks {
666 + enum efx_veto (*tx_packet) (struct efx_dl_device *efx_dev,
667 + struct sk_buff *skb);
668 + enum efx_veto (*rx_packet) (struct efx_dl_device *efx_dev,
669 + const char *pkt_hdr, int pkt_len);
670 + int (*request_mtu) (struct efx_dl_device *efx_dev, int new_mtu);
671 + void (*mtu_changed) (struct efx_dl_device *efx_dev, int mtu);
672 + void (*event) (struct efx_dl_device *efx_dev, void *p_event);
673 +};
674 +
675 +/* Include API version number in symbol used for efx_dl_register_driver */
676 +#define efx_dl_stringify_1(x, y) x ## y
677 +#define efx_dl_stringify_2(x, y) efx_dl_stringify_1(x, y)
678 +#define efx_dl_register_driver \
679 + efx_dl_stringify_2(efx_dl_register_driver_api_ver_, \
680 + EFX_DRIVERLINK_API_VERSION)
681 +
682 +/* Exported driverlink api used to register and unregister the client driver
683 + * and any callbacks [only one per port allowed], and to allow a client driver
684 + * to request reset to recover from an error condition.
685 + *
686 + * All of these functions acquire the driverlink semaphore, so must not be
687 + * called from an efx_dl_driver or efx_dl_callbacks member, and must be called
688 + * from process context.
689 + */
690 +extern int efx_dl_register_driver(struct efx_dl_driver *driver);
691 +
692 +extern void efx_dl_unregister_driver(struct efx_dl_driver *driver);
693 +
694 +extern int efx_dl_register_callbacks(struct efx_dl_device *efx_dev,
695 + struct efx_dl_callbacks *callbacks);
696 +
697 +extern void efx_dl_unregister_callbacks(struct efx_dl_device *efx_dev,
698 + struct efx_dl_callbacks *callbacks);
699 +
700 +/* Schedule a reset without grabbing any locks */
701 +extern void efx_dl_schedule_reset(struct efx_dl_device *efx_dev);
702 +
703 +/**
704 + * efx_dl_for_each_device_info_matching - iterate an efx_dl_device_info list
705 + * @_dev_info: Pointer to first &struct efx_dl_device_info
706 + * @_type: Type code to look for
707 + * @_info_type: Structure type corresponding to type code
708 + * @_field: Name of &struct efx_dl_device_info field in the type
709 + * @_p: Iterator variable
710 + *
711 + * Example:
712 + * struct efx_dl_falcon_resources *res;
713 + * efx_dl_for_each_device_info_matching(dev_info, EFX_DL_FALCON_RESOURCES,
714 + * struct efx_dl_falcon_resources,
715 + * hdr, res) {
716 + * if (res->flags & EFX_DL_FALCON_DUAL_FUNC)
717 + * ....
718 + * }
719 + */
720 +#define efx_dl_for_each_device_info_matching(_dev_info, _type, \
721 + _info_type, _field, _p) \
722 + for ((_p) = container_of((_dev_info), _info_type, _field); \
723 + (_p) != NULL; \
724 + (_p) = container_of((_p)->_field.next, _info_type, _field))\
725 + if ((_p)->_field.type != _type) \
726 + continue; \
727 + else
728 +
729 +/**
730 + * efx_dl_search_device_info - search an efx_dl_device_info list
731 + * @_dev_info: Pointer to first &struct efx_dl_device_info
732 + * @_type: Type code to look for
733 + * @_info_type: Structure type corresponding to type code
734 + * @_field: Name of &struct efx_dl_device_info member in this type
735 + * @_p: Result variable
736 + *
737 + * Example:
738 + * struct efx_dl_falcon_resources *res;
739 + * efx_dl_search_device_info(dev_info, EFX_DL_FALCON_RESOURCES,
740 + * struct efx_dl_falcon_resources, hdr, res);
741 + * if (res)
742 + * ....
743 + */
744 +#define efx_dl_search_device_info(_dev_info, _type, _info_type, \
745 + _field, _p) \
746 + efx_dl_for_each_device_info_matching((_dev_info), (_type), \
747 + _info_type, _field, (_p)) \
748 + break;
749 +
750 +#endif /* EFX_DRIVERLINK_API_H */
751 Index: head-2008-08-18/drivers/net/sfc/efx.c
752 ===================================================================
753 --- head-2008-08-18.orig/drivers/net/sfc/efx.c 2008-08-18 10:16:43.000000000 +0200
754 +++ head-2008-08-18/drivers/net/sfc/efx.c 2008-08-18 10:16:46.000000000 +0200
755 @@ -1427,6 +1427,11 @@ static int efx_change_mtu(struct net_dev
756
757 efx_stop_all(efx);
758
759 + /* Ask driverlink client if we can change MTU */
760 + rc = EFX_DL_CALLBACK(efx, request_mtu, new_mtu);
761 + if (rc)
762 + goto out;
763 +
764 EFX_LOG(efx, "changing MTU to %d\n", new_mtu);
765
766 efx_fini_channels(efx);
767 @@ -1435,6 +1440,10 @@ static int efx_change_mtu(struct net_dev
768 if (rc)
769 goto fail;
770
771 + /* Notify driverlink client of new MTU */
772 + EFX_DL_CALLBACK(efx, mtu_changed, new_mtu);
773 +
774 + out:
775 efx_start_all(efx);
776 return rc;
777
778 @@ -1587,6 +1596,23 @@ static void efx_unregister_netdev(struct
779 * Device reset and suspend
780 *
781 **************************************************************************/
782 +/* Serialise access to the driverlink callbacks, by quiescing event processing
783 + * (without flushing the descriptor queues), and acquiring the rtnl_lock */
784 +void efx_suspend(struct efx_nic *efx)
785 +{
786 + EFX_LOG(efx, "suspending operations\n");
787 +
788 + rtnl_lock();
789 + efx_stop_all(efx);
790 +}
791 +
792 +void efx_resume(struct efx_nic *efx)
793 +{
794 + EFX_LOG(efx, "resuming operations\n");
795 +
796 + efx_start_all(efx);
797 + rtnl_unlock();
798 +}
799
800 /* The final hardware and software finalisation before reset. */
801 static int efx_reset_down(struct efx_nic *efx, struct ethtool_cmd *ecmd)
802 @@ -1649,8 +1675,8 @@ static int efx_reset(struct efx_nic *efx
803 enum reset_type method = efx->reset_pending;
804 int rc;
805
806 - /* Serialise with kernel interfaces */
807 rtnl_lock();
808 + efx_dl_reset_suspend(efx);
809
810 /* If we're not RUNNING then don't reset. Leave the reset_pending
811 * flag set so that efx_pci_probe_main will be retried */
812 @@ -1717,6 +1743,7 @@ static int efx_reset(struct efx_nic *efx
813 efx_start_all(efx);
814
815 unlock_rtnl:
816 + efx_dl_reset_resume(efx, 1);
817 rtnl_unlock();
818 return 0;
819
820 @@ -1729,6 +1756,7 @@ static int efx_reset(struct efx_nic *efx
821 efx->state = STATE_DISABLED;
822
823 mutex_unlock(&efx->mac_lock);
824 + efx_dl_reset_resume(efx, 0);
825 rtnl_unlock();
826 efx_unregister_netdev(efx);
827 efx_fini_port(efx);
828 @@ -1871,6 +1899,9 @@ static int efx_init_struct(struct efx_ni
829 mutex_init(&efx->mac_lock);
830 efx->phy_op = &efx_dummy_phy_operations;
831 efx->mii.dev = net_dev;
832 + INIT_LIST_HEAD(&efx->dl_node);
833 + INIT_LIST_HEAD(&efx->dl_device_list);
834 + efx->dl_cb = efx_default_callbacks;
835 INIT_WORK(&efx->reconfigure_work, efx_reconfigure_work);
836 atomic_set(&efx->netif_stop_count, 1);
837
838 @@ -1990,6 +2021,7 @@ static void efx_pci_remove(struct pci_de
839 efx = pci_get_drvdata(pci_dev);
840 if (!efx)
841 return;
842 + efx_dl_unregister_nic(efx);
843
844 /* Mark the NIC as fini, then stop the interface */
845 rtnl_lock();
846 @@ -2157,8 +2189,15 @@ static int __devinit efx_pci_probe(struc
847
848 EFX_LOG(efx, "initialisation successful\n");
849
850 + /* Register with driverlink layer */
851 + rc = efx_dl_register_nic(efx);
852 + if (rc)
853 + goto fail6;
854 +
855 return 0;
856
857 + fail6:
858 + efx_unregister_netdev(efx);
859 fail5:
860 efx_pci_remove_main(efx);
861 fail4:
862 Index: head-2008-08-18/drivers/net/sfc/falcon.c
863 ===================================================================
864 --- head-2008-08-18.orig/drivers/net/sfc/falcon.c 2008-08-18 10:16:43.000000000 +0200
865 +++ head-2008-08-18/drivers/net/sfc/falcon.c 2008-08-18 10:16:46.000000000 +0200
866 @@ -36,12 +36,12 @@
867
868 /**
869 * struct falcon_nic_data - Falcon NIC state
870 - * @next_buffer_table: First available buffer table id
871 + * @resources: Resource information for driverlink client
872 * @pci_dev2: The secondary PCI device if present
873 * @i2c_data: Operations and state for I2C bit-bashing algorithm
874 */
875 struct falcon_nic_data {
876 - unsigned next_buffer_table;
877 + struct efx_dl_falcon_resources resources;
878 struct pci_dev *pci_dev2;
879 struct i2c_algo_bit_data i2c_data;
880 };
881 @@ -322,8 +322,8 @@ static int falcon_alloc_special_buffer(s
882 memset(buffer->addr, 0xff, len);
883
884 /* Select new buffer ID */
885 - buffer->index = nic_data->next_buffer_table;
886 - nic_data->next_buffer_table += buffer->entries;
887 + buffer->index = nic_data->resources.buffer_table_min;
888 + nic_data->resources.buffer_table_min += buffer->entries;
889
890 EFX_LOG(efx, "allocating special buffers %d-%d at %llx+%x "
891 "(virt %p phys %lx)\n", buffer->index,
892 @@ -1115,10 +1115,12 @@ static void falcon_handle_driver_event(s
893 case TX_DESCQ_FLS_DONE_EV_DECODE:
894 EFX_TRACE(efx, "channel %d TXQ %d flushed\n",
895 channel->channel, ev_sub_data);
896 + EFX_DL_CALLBACK(efx, event, event);
897 break;
898 case RX_DESCQ_FLS_DONE_EV_DECODE:
899 EFX_TRACE(efx, "channel %d RXQ %d flushed\n",
900 channel->channel, ev_sub_data);
901 + EFX_DL_CALLBACK(efx, event, event);
902 break;
903 case EVQ_INIT_DONE_EV_DECODE:
904 EFX_LOG(efx, "channel %d EVQ %d initialised\n",
905 @@ -1127,14 +1129,17 @@ static void falcon_handle_driver_event(s
906 case SRM_UPD_DONE_EV_DECODE:
907 EFX_TRACE(efx, "channel %d SRAM update done\n",
908 channel->channel);
909 + EFX_DL_CALLBACK(efx, event, event);
910 break;
911 case WAKE_UP_EV_DECODE:
912 EFX_TRACE(efx, "channel %d RXQ %d wakeup event\n",
913 channel->channel, ev_sub_data);
914 + EFX_DL_CALLBACK(efx, event, event);
915 break;
916 case TIMER_EV_DECODE:
917 EFX_TRACE(efx, "channel %d RX queue %d timer expired\n",
918 channel->channel, ev_sub_data);
919 + EFX_DL_CALLBACK(efx, event, event);
920 break;
921 case RX_RECOVERY_EV_DECODE:
922 EFX_ERR(efx, "channel %d seen DRIVER RX_RESET event. "
923 @@ -1159,6 +1164,7 @@ static void falcon_handle_driver_event(s
924 EFX_TRACE(efx, "channel %d unknown driver event code %d "
925 "data %04x\n", channel->channel, ev_sub_code,
926 ev_sub_data);
927 + EFX_DL_CALLBACK(efx, event, event);
928 break;
929 }
930 }
931 @@ -2371,6 +2377,59 @@ static int falcon_probe_nvconfig(struct
932 return rc;
933 }
934
935 +/* Looks at available SRAM resources and silicon revision, and works out
936 + * how many queues we can support, and where things like descriptor caches
937 + * should live. */
938 +static int falcon_dimension_resources(struct efx_nic *efx)
939 +{
940 + unsigned internal_dcs_entries;
941 + struct falcon_nic_data *nic_data = efx->nic_data;
942 + struct efx_dl_falcon_resources *res = &nic_data->resources;
943 +
944 + /* Fill out the driverlink resource list */
945 + res->hdr.type = EFX_DL_FALCON_RESOURCES;
946 + res->biu_lock = &efx->biu_lock;
947 + efx->dl_info = &res->hdr;
948 +
949 + /* NB. The minimum values get increased as this driver initialises
950 + * its resources, so this should prevent any overlap.
951 + */
952 + switch (falcon_rev(efx)) {
953 + case FALCON_REV_A1:
954 + res->rxq_min = 16;
955 + res->txq_min = 16;
956 + res->evq_int_min = 4;
957 + res->evq_int_lim = 5;
958 + res->evq_timer_min = 5;
959 + res->evq_timer_lim = 4096;
960 + internal_dcs_entries = 8192;
961 + break;
962 + case FALCON_REV_B0:
963 + default:
964 + res->rxq_min = 0;
965 + res->txq_min = 0;
966 + res->evq_int_min = 0;
967 + res->evq_int_lim = 64;
968 + res->evq_timer_min = 64;
969 + res->evq_timer_lim = 4096;
970 + internal_dcs_entries = 4096;
971 + break;
972 + }
973 +
974 + /* Internal SRAM only for now */
975 + res->rxq_lim = internal_dcs_entries / RX_DC_ENTRIES;
976 + res->txq_lim = internal_dcs_entries / TX_DC_ENTRIES;
977 + res->buffer_table_lim = 8192;
978 +
979 + if (FALCON_IS_DUAL_FUNC(efx))
980 + res->flags |= EFX_DL_FALCON_DUAL_FUNC;
981 +
982 + if (EFX_INT_MODE_USE_MSI(efx))
983 + res->flags |= EFX_DL_FALCON_USE_MSI;
984 +
985 + return 0;
986 +}
987 +
988 /* Probe the NIC variant (revision, ASIC vs FPGA, function count, port
989 * count, port speed). Set workaround and feature flags accordingly.
990 */
991 @@ -2403,10 +2462,12 @@ static int falcon_probe_nic_variant(stru
992 EFX_ERR(efx, "1G mode not supported\n");
993 return -ENODEV;
994 }
995 + efx->silicon_rev = "falcon/a1";
996 break;
997 }
998
999 case FALCON_REV_B0:
1000 + efx->silicon_rev = "falcon/b0";
1001 break;
1002
1003 default:
1004 @@ -2472,6 +2533,10 @@ int falcon_probe_nic(struct efx_nic *efx
1005 if (rc)
1006 goto fail5;
1007
1008 + rc = falcon_dimension_resources(efx);
1009 + if (rc)
1010 + goto fail6;
1011 +
1012 /* Initialise I2C adapter */
1013 efx->i2c_adap.owner = THIS_MODULE;
1014 nic_data->i2c_data = falcon_i2c_bit_operations;
1015 @@ -2481,10 +2546,12 @@ int falcon_probe_nic(struct efx_nic *efx
1016 strlcpy(efx->i2c_adap.name, "SFC4000 GPIO", sizeof(efx->i2c_adap.name));
1017 rc = i2c_bit_add_bus(&efx->i2c_adap);
1018 if (rc)
1019 - goto fail5;
1020 + goto fail6;
1021
1022 return 0;
1023
1024 + fail6:
1025 + efx->dl_info = NULL;
1026 fail5:
1027 falcon_free_buffer(efx, &efx->irq_status);
1028 fail4:
1029 @@ -2675,6 +2742,7 @@ void falcon_remove_nic(struct efx_nic *e
1030 /* Tear down the private nic state */
1031 kfree(efx->nic_data);
1032 efx->nic_data = NULL;
1033 + efx->dl_info = NULL;
1034 }
1035
1036 void falcon_update_nic_stats(struct efx_nic *efx)
1037 Index: head-2008-08-18/drivers/net/sfc/net_driver.h
1038 ===================================================================
1039 --- head-2008-08-18.orig/drivers/net/sfc/net_driver.h 2008-08-18 10:16:43.000000000 +0200
1040 +++ head-2008-08-18/drivers/net/sfc/net_driver.h 2008-08-18 10:16:46.000000000 +0200
1041 @@ -30,6 +30,8 @@
1042
1043 #include "enum.h"
1044 #include "bitfield.h"
1045 +#include "driverlink_api.h"
1046 +#include "driverlink.h"
1047
1048 #define EFX_MAX_LRO_DESCRIPTORS 8
1049 #define EFX_MAX_LRO_AGGR MAX_SKB_FRAGS
1050 @@ -676,6 +678,12 @@ union efx_multicast_hash {
1051 * @loopback_mode: Loopback status
1052 * @loopback_modes: Supported loopback mode bitmask
1053 * @loopback_selftest: Offline self-test private state
1054 + * @silicon_rev: Silicon revision description for driverlink
1055 + * @dl_info: Linked list of hardware parameters exposed through driverlink
1056 + * @dl_node: Driverlink port list
1057 + * @dl_device_list: Driverlink device list
1058 + * @dl_cb: Driverlink callbacks table
1059 + * @dl_cb_dev: Driverlink callback owner devices
1060 *
1061 * The @priv field of the corresponding &struct net_device points to
1062 * this.
1063 @@ -752,6 +760,13 @@ struct efx_nic {
1064 unsigned int loopback_modes;
1065
1066 void *loopback_selftest;
1067 +
1068 + const char *silicon_rev;
1069 + struct efx_dl_device_info *dl_info;
1070 + struct list_head dl_node;
1071 + struct list_head dl_device_list;
1072 + struct efx_dl_callbacks dl_cb;
1073 + struct efx_dl_cb_devices dl_cb_dev;
1074 };
1075
1076 static inline int efx_dev_registered(struct efx_nic *efx)
1077 Index: head-2008-08-18/drivers/net/sfc/rx.c
1078 ===================================================================
1079 --- head-2008-08-18.orig/drivers/net/sfc/rx.c 2008-08-18 10:16:43.000000000 +0200
1080 +++ head-2008-08-18/drivers/net/sfc/rx.c 2008-08-18 10:16:46.000000000 +0200
1081 @@ -549,8 +549,22 @@ static inline void efx_rx_packet__check_
1082 static inline void efx_rx_packet_lro(struct efx_channel *channel,
1083 struct efx_rx_buffer *rx_buf)
1084 {
1085 + struct efx_nic *efx = channel->efx;
1086 struct net_lro_mgr *lro_mgr = &channel->lro_mgr;
1087 void *priv = channel;
1088 + enum efx_veto veto;
1089 +
1090 + /* It would be faster if we had access to packets at the
1091 + * other side of generic LRO. Unfortunately, there isn't
1092 + * an obvious interface to this, so veto packets before LRO */
1093 + veto = EFX_DL_CALLBACK(efx, rx_packet, rx_buf->data, rx_buf->len);
1094 + if (unlikely(veto)) {
1095 + EFX_TRACE(efx, "LRO RX vetoed by driverlink %s driver\n",
1096 + efx->dl_cb_dev.rx_packet->driver->name);
1097 + /* Free the buffer now */
1098 + efx_free_rx_buffer(efx, rx_buf);
1099 + return;
1100 + }
1101
1102 /* Pass the skb/page into the LRO engine */
1103 if (rx_buf->page) {
1104 @@ -686,6 +700,7 @@ void __efx_rx_packet(struct efx_channel
1105 struct efx_rx_buffer *rx_buf, int checksummed)
1106 {
1107 struct efx_nic *efx = channel->efx;
1108 + enum efx_veto veto;
1109 struct sk_buff *skb;
1110 int lro = efx->net_dev->features & NETIF_F_LRO;
1111
1112 @@ -723,6 +738,16 @@ void __efx_rx_packet(struct efx_channel
1113 goto done;
1114 }
1115
1116 + /* Allow callback to veto the packet */
1117 + veto = EFX_DL_CALLBACK(efx, rx_packet, rx_buf->data, rx_buf->len);
1118 + if (unlikely(veto)) {
1119 + EFX_LOG(efx, "RX vetoed by driverlink %s driver\n",
1120 + efx->dl_cb_dev.rx_packet->driver->name);
1121 + /* Free the buffer now */
1122 + efx_free_rx_buffer(efx, rx_buf);
1123 + goto done;
1124 + }
1125 +
1126 /* Form an skb if required */
1127 if (rx_buf->page) {
1128 int hdr_len = min(rx_buf->len, EFX_SKB_HEADERS);
1129 Index: head-2008-08-18/drivers/net/sfc/tx.c
1130 ===================================================================
1131 --- head-2008-08-18.orig/drivers/net/sfc/tx.c 2008-08-18 10:16:43.000000000 +0200
1132 +++ head-2008-08-18/drivers/net/sfc/tx.c 2008-08-18 10:16:46.000000000 +0200
1133 @@ -368,7 +368,21 @@ inline int efx_xmit(struct efx_nic *efx,
1134 int efx_hard_start_xmit(struct sk_buff *skb, struct net_device *net_dev)
1135 {
1136 struct efx_nic *efx = net_dev->priv;
1137 - return efx_xmit(efx, &efx->tx_queue[0], skb);
1138 + struct efx_tx_queue *tx_queue = &efx->tx_queue[0];
1139 + enum efx_veto veto;
1140 +
1141 + /* See if driverlink wants to veto the packet. */
1142 + veto = EFX_DL_CALLBACK(efx, tx_packet, skb);
1143 + if (unlikely(veto)) {
1144 + EFX_TRACE(efx, "TX queue %d packet vetoed by "
1145 + "driverlink %s driver\n", tx_queue->queue,
1146 + efx->dl_cb_dev.tx_packet->driver->name);
1147 + /* Free the skb; nothing else will do it */
1148 + dev_kfree_skb_any(skb);
1149 + return NETDEV_TX_OK;
1150 + }
1151 +
1152 + return efx_xmit(efx, tx_queue, skb);
1153 }
1154
1155 void efx_xmit_done(struct efx_tx_queue *tx_queue, unsigned int index)