4 * Copyright(c) 2017 Cavium, Inc.. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Cavium, Inc. nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 #include "lio_common.h"
40 #include "lio_response_manager.h"
41 #include "lio_device.h"
44 #include "lio_network.h"
45 #include "cn23xx_pf_device.h"
46 #include "lio_image.h"
47 #include "lio_ioctl.h"
51 /* Number of milliseconds to wait for DDR initialization */
52 #define LIO_DDR_TIMEOUT 10000
53 #define LIO_MAX_FW_TYPE_LEN 8
55 static char fw_type[LIO_MAX_FW_TYPE_LEN];
56 TUNABLE_STR("hw.lio.fw_type", fw_type, sizeof(fw_type));
59 * Integers that specify number of queues per PF.
60 * Valid range is 0 to 64.
61 * Use 0 to derive from CPU count.
63 static int num_queues_per_pf0;
64 static int num_queues_per_pf1;
65 TUNABLE_INT("hw.lio.num_queues_per_pf0", &num_queues_per_pf0);
66 TUNABLE_INT("hw.lio.num_queues_per_pf1", &num_queues_per_pf1);
69 static int lio_rss = 1;
70 TUNABLE_INT("hw.lio.rss", &lio_rss);
74 unsigned int lio_hwlro = 0;
75 TUNABLE_INT("hw.lio.hwlro", &lio_hwlro);
78 * Bitmask indicating which consoles have debug
79 * output redirected to syslog.
81 static unsigned long console_bitmask;
82 TUNABLE_ULONG("hw.lio.console_bitmask", &console_bitmask);
85 * \brief determines if a given console has debug enabled.
86 * @param console console to check
87 * @returns 1 = enabled. 0 otherwise
90 lio_console_debug_enabled(uint32_t console)
93 return (console_bitmask >> (console)) & 0x1;
96 static int lio_detach(device_t dev);
98 static int lio_device_init(struct octeon_device *octeon_dev);
99 static int lio_chip_specific_setup(struct octeon_device *oct);
100 static void lio_watchdog(void *param);
101 static int lio_load_firmware(struct octeon_device *oct);
102 static int lio_nic_starter(struct octeon_device *oct);
103 static int lio_init_nic_module(struct octeon_device *oct);
104 static int lio_setup_nic_devices(struct octeon_device *octeon_dev);
105 static int lio_link_info(struct lio_recv_info *recv_info, void *ptr);
106 static void lio_if_cfg_callback(struct octeon_device *oct, uint32_t status,
108 static int lio_set_rxcsum_command(struct ifnet *ifp, int command,
110 static int lio_setup_glists(struct octeon_device *oct, struct lio *lio,
112 static void lio_destroy_nic_device(struct octeon_device *oct, int ifidx);
113 static inline void lio_update_link_status(struct ifnet *ifp,
114 union octeon_link_status *ls);
115 static void lio_send_rx_ctrl_cmd(struct lio *lio, int start_stop);
116 static int lio_stop_nic_module(struct octeon_device *oct);
117 static void lio_destroy_resources(struct octeon_device *oct);
118 static int lio_setup_rx_oom_poll_fn(struct ifnet *ifp);
120 static void lio_vlan_rx_add_vid(void *arg, struct ifnet *ifp, uint16_t vid);
121 static void lio_vlan_rx_kill_vid(void *arg, struct ifnet *ifp,
123 static struct octeon_device *
124 lio_get_other_octeon_device(struct octeon_device *oct);
126 static int lio_wait_for_oq_pkts(struct octeon_device *oct);
128 int lio_send_rss_param(struct lio *lio);
129 static int lio_dbg_console_print(struct octeon_device *oct,
130 uint32_t console_num, char *prefix,
133 /* Polling interval for determining when NIC application is alive */
134 #define LIO_STARTER_POLL_INTERVAL_MS 100
138 * This array contains the list of IDs on which the driver should load.
140 struct lio_vendor_info {
143 uint16_t subdevice_id;
148 static struct lio_vendor_info lio_pci_tbl[] = {
150 {PCI_VENDOR_ID_CAVIUM, LIO_CN23XX_PF_VID, LIO_CN2350_10G_SUBDEVICE,
154 {PCI_VENDOR_ID_CAVIUM, LIO_CN23XX_PF_VID, LIO_CN2350_10G_SUBDEVICE1,
158 {PCI_VENDOR_ID_CAVIUM, LIO_CN23XX_PF_VID, LIO_CN2360_10G_SUBDEVICE,
162 {PCI_VENDOR_ID_CAVIUM, LIO_CN23XX_PF_VID, LIO_CN2350_25G_SUBDEVICE,
166 {PCI_VENDOR_ID_CAVIUM, LIO_CN23XX_PF_VID, LIO_CN2360_25G_SUBDEVICE,
172 static char *lio_strings[] = {
173 "LiquidIO 2350 10GbE Server Adapter",
174 "LiquidIO 2360 10GbE Server Adapter",
175 "LiquidIO 2350 25GbE Server Adapter",
176 "LiquidIO 2360 25GbE Server Adapter",
179 struct lio_if_cfg_resp {
181 struct octeon_if_cfg_info cfg_info;
185 struct lio_if_cfg_context {
190 struct lio_rx_ctl_context {
196 lio_probe(device_t dev)
198 struct lio_vendor_info *tbl;
202 uint16_t subdevice_id;
204 char device_ver[256];
206 vendor_id = pci_get_vendor(dev);
207 if (vendor_id != PCI_VENDOR_ID_CAVIUM)
210 device_id = pci_get_device(dev);
211 subdevice_id = pci_get_subdevice(dev);
212 revision_id = pci_get_revid(dev);
215 while (tbl->vendor_id) {
216 if ((vendor_id == tbl->vendor_id) &&
217 (device_id == tbl->device_id) &&
218 (subdevice_id == tbl->subdevice_id) &&
219 (revision_id == tbl->revision_id)) {
220 sprintf(device_ver, "%s, Version - %s",
221 lio_strings[tbl->index], LIO_VERSION);
222 device_set_desc_copy(dev, device_ver);
223 return (BUS_PROBE_DEFAULT);
233 lio_attach(device_t device)
235 struct octeon_device *oct_dev = NULL;
238 int timeout, ret = 1;
239 uint8_t bus, dev, function;
241 oct_dev = lio_allocate_device(device);
242 if (oct_dev == NULL) {
243 device_printf(device, "Error: Unable to allocate device\n");
247 oct_dev->tx_budget = LIO_DEFAULT_TX_PKTS_PROCESS_BUDGET;
248 oct_dev->rx_budget = LIO_DEFAULT_RX_PKTS_PROCESS_BUDGET;
249 oct_dev->msix_on = LIO_FLAG_MSIX_ENABLED;
251 oct_dev->device = device;
252 bus = pci_get_bus(device);
253 dev = pci_get_slot(device);
254 function = pci_get_function(device);
256 lio_dev_info(oct_dev, "Initializing device %x:%x %02x:%02x.%01x\n",
257 pci_get_vendor(device), pci_get_device(device), bus, dev,
260 if (lio_device_init(oct_dev)) {
261 lio_dev_err(oct_dev, "Failed to init device\n");
266 scratch1 = lio_read_csr64(oct_dev, LIO_CN23XX_SLI_SCRATCH1);
267 if (!(scratch1 & 4ULL)) {
269 * Bit 2 of SLI_SCRATCH_1 is a flag that indicates that
270 * the lio watchdog kernel thread is running for this
271 * NIC. Each NIC gets one watchdog kernel thread.
274 lio_write_csr64(oct_dev, LIO_CN23XX_SLI_SCRATCH1, scratch1);
276 error = kproc_create(lio_watchdog, oct_dev,
277 &oct_dev->watchdog_task, 0, 0,
278 "liowd/%02hhx:%02hhx.%hhx", bus,
281 kproc_resume(oct_dev->watchdog_task);
283 oct_dev->watchdog_task = NULL;
285 "failed to create kernel_thread\n");
290 oct_dev->rx_pause = 1;
291 oct_dev->tx_pause = 1;
294 while (timeout < LIO_NIC_STARTER_TIMEOUT) {
295 lio_mdelay(LIO_STARTER_POLL_INTERVAL_MS);
296 timeout += LIO_STARTER_POLL_INTERVAL_MS;
299 * During the boot process interrupts are not available.
300 * So polling for first control message from FW.
303 lio_droq_bh(oct_dev->droq[0], 0);
305 if (atomic_load_acq_int(&oct_dev->status) == LIO_DEV_CORE_OK) {
306 ret = lio_nic_starter(oct_dev);
312 lio_dev_err(oct_dev, "Firmware failed to start\n");
317 lio_dev_dbg(oct_dev, "Device is ready\n");
323 lio_detach(device_t dev)
325 struct octeon_device *oct_dev = device_get_softc(dev);
327 lio_dev_dbg(oct_dev, "Stopping device\n");
328 if (oct_dev->watchdog_task) {
331 kproc_suspend(oct_dev->watchdog_task, 0);
333 scratch1 = lio_read_csr64(oct_dev, LIO_CN23XX_SLI_SCRATCH1);
335 lio_write_csr64(oct_dev, LIO_CN23XX_SLI_SCRATCH1, scratch1);
338 if (oct_dev->app_mode && (oct_dev->app_mode == LIO_DRV_NIC_APP))
339 lio_stop_nic_module(oct_dev);
342 * Reset the octeon device and cleanup all memory allocated for
343 * the octeon device by driver.
345 lio_destroy_resources(oct_dev);
347 lio_dev_info(oct_dev, "Device removed\n");
350 * This octeon device has been removed. Update the global
351 * data structure to reflect this. Free the device structure.
353 lio_free_device_mem(oct_dev);
358 lio_shutdown(device_t dev)
360 struct octeon_device *oct_dev = device_get_softc(dev);
361 struct lio *lio = if_getsoftc(oct_dev->props.ifp);
363 lio_send_rx_ctrl_cmd(lio, 0);
369 lio_suspend(device_t dev)
376 lio_resume(device_t dev)
383 lio_event(struct module *mod, int event, void *junk)
388 lio_init_device_list(LIO_CFG_TYPE_DEFAULT);
397 /*********************************************************************
398 * FreeBSD Device Interface Entry Points
399 * *******************************************************************/
400 static device_method_t lio_methods[] = {
401 /* Device interface */
402 DEVMETHOD(device_probe, lio_probe),
403 DEVMETHOD(device_attach, lio_attach),
404 DEVMETHOD(device_detach, lio_detach),
405 DEVMETHOD(device_shutdown, lio_shutdown),
406 DEVMETHOD(device_suspend, lio_suspend),
407 DEVMETHOD(device_resume, lio_resume),
411 static driver_t lio_driver = {
412 LIO_DRV_NAME, lio_methods, sizeof(struct octeon_device),
415 devclass_t lio_devclass;
416 DRIVER_MODULE(lio, pci, lio_driver, lio_devclass, lio_event, 0);
418 MODULE_DEPEND(lio, pci, 1, 1, 1);
419 MODULE_DEPEND(lio, ether, 1, 1, 1);
420 MODULE_DEPEND(lio, firmware, 1, 1, 1);
423 fw_type_is_none(void)
425 return strncmp(fw_type, LIO_FW_NAME_TYPE_NONE,
426 sizeof(LIO_FW_NAME_TYPE_NONE)) == 0;
430 * \brief Device initialization for each Octeon device that is probed
431 * @param octeon_dev octeon device
434 lio_device_init(struct octeon_device *octeon_dev)
436 unsigned long ddr_timeout = LIO_DDR_TIMEOUT;
437 char *dbg_enb = NULL;
440 uint8_t bus, dev, function;
441 char bootcmd[] = "\n";
443 bus = pci_get_bus(octeon_dev->device);
444 dev = pci_get_slot(octeon_dev->device);
445 function = pci_get_function(octeon_dev->device);
447 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_BEGIN_STATE);
449 /* Enable access to the octeon device */
450 if (pci_enable_busmaster(octeon_dev->device)) {
451 lio_dev_err(octeon_dev, "pci_enable_device failed\n");
455 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_PCI_ENABLE_DONE);
457 /* Identify the Octeon type and map the BAR address space. */
458 if (lio_chip_specific_setup(octeon_dev)) {
459 lio_dev_err(octeon_dev, "Chip specific setup failed\n");
463 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_PCI_MAP_DONE);
466 * Only add a reference after setting status 'OCT_DEV_PCI_MAP_DONE',
467 * since that is what is required for the reference to be removed
468 * during de-initialization (see 'octeon_destroy_resources').
470 lio_register_device(octeon_dev, bus, dev, function, true);
473 octeon_dev->app_mode = LIO_DRV_INVALID_APP;
475 if (!lio_cn23xx_pf_fw_loaded(octeon_dev) && !fw_type_is_none()) {
477 /* Do a soft reset of the Octeon device. */
478 if (octeon_dev->fn_list.soft_reset(octeon_dev))
481 /* things might have changed */
482 if (!lio_cn23xx_pf_fw_loaded(octeon_dev))
491 * Initialize the dispatch mechanism used to push packets arriving on
492 * Octeon Output queues.
494 if (lio_init_dispatch_list(octeon_dev))
497 lio_register_dispatch_fn(octeon_dev, LIO_OPCODE_NIC,
498 LIO_OPCODE_NIC_CORE_DRV_ACTIVE,
499 lio_core_drv_init, octeon_dev);
500 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_DISPATCH_INIT_DONE);
502 ret = octeon_dev->fn_list.setup_device_regs(octeon_dev);
504 lio_dev_err(octeon_dev,
505 "Failed to configure device registers\n");
509 /* Initialize soft command buffer pool */
510 if (lio_setup_sc_buffer_pool(octeon_dev)) {
511 lio_dev_err(octeon_dev, "sc buffer pool allocation failed\n");
515 atomic_store_rel_int(&octeon_dev->status,
516 LIO_DEV_SC_BUFF_POOL_INIT_DONE);
518 if (lio_allocate_ioq_vector(octeon_dev)) {
519 lio_dev_err(octeon_dev,
520 "IOQ vector allocation failed\n");
524 atomic_store_rel_int(&octeon_dev->status,
525 LIO_DEV_MSIX_ALLOC_VECTOR_DONE);
527 for (i = 0; i < LIO_MAX_POSSIBLE_INSTR_QUEUES; i++) {
528 octeon_dev->instr_queue[i] =
529 malloc(sizeof(struct lio_instr_queue),
530 M_DEVBUF, M_NOWAIT | M_ZERO);
531 if (octeon_dev->instr_queue[i] == NULL)
535 /* Setup the data structures that manage this Octeon's Input queues. */
536 if (lio_setup_instr_queue0(octeon_dev)) {
537 lio_dev_err(octeon_dev,
538 "Instruction queue initialization failed\n");
542 atomic_store_rel_int(&octeon_dev->status,
543 LIO_DEV_INSTR_QUEUE_INIT_DONE);
546 * Initialize lists to manage the requests of different types that
547 * arrive from user & kernel applications for this octeon device.
550 if (lio_setup_response_list(octeon_dev)) {
551 lio_dev_err(octeon_dev, "Response list allocation failed\n");
555 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_RESP_LIST_INIT_DONE);
557 for (i = 0; i < LIO_MAX_POSSIBLE_OUTPUT_QUEUES; i++) {
558 octeon_dev->droq[i] = malloc(sizeof(*octeon_dev->droq[i]),
559 M_DEVBUF, M_NOWAIT | M_ZERO);
560 if (octeon_dev->droq[i] == NULL)
564 if (lio_setup_output_queue0(octeon_dev)) {
565 lio_dev_err(octeon_dev, "Output queue initialization failed\n");
569 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_DROQ_INIT_DONE);
572 * Setup the interrupt handler and record the INT SUM register address
574 if (lio_setup_interrupt(octeon_dev,
575 octeon_dev->sriov_info.num_pf_rings))
578 /* Enable Octeon device interrupts */
579 octeon_dev->fn_list.enable_interrupt(octeon_dev, OCTEON_ALL_INTR);
581 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_INTR_SET_DONE);
584 * Send Credit for Octeon Output queues. Credits are always sent BEFORE
585 * the output queue is enabled.
586 * This ensures that we'll receive the f/w CORE DRV_ACTIVE message in
587 * case we've configured CN23XX_SLI_GBL_CONTROL[NOPTR_D] = 0.
588 * Otherwise, it is possible that the DRV_ACTIVE message will be sent
589 * before any credits have been issued, causing the ring to be reset
590 * (and the f/w appear to never have started).
592 for (j = 0; j < octeon_dev->num_oqs; j++)
593 lio_write_csr32(octeon_dev,
594 octeon_dev->droq[j]->pkts_credit_reg,
595 octeon_dev->droq[j]->max_count);
597 /* Enable the input and output queues for this Octeon device */
598 ret = octeon_dev->fn_list.enable_io_queues(octeon_dev);
600 lio_dev_err(octeon_dev, "Failed to enable input/output queues");
604 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_IO_QUEUES_DONE);
607 lio_dev_dbg(octeon_dev, "Waiting for DDR initialization...\n");
609 lio_dev_info(octeon_dev,
610 "WAITING. Set ddr_timeout to non-zero value to proceed with initialization.\n");
613 lio_sleep_timeout(LIO_RESET_MSECS);
616 * Wait for the octeon to initialize DDR after the
619 while (!ddr_timeout) {
620 if (pause("-", lio_ms_to_ticks(100))) {
621 /* user probably pressed Control-C */
626 ret = lio_wait_for_ddr_init(octeon_dev, &ddr_timeout);
628 lio_dev_err(octeon_dev,
629 "DDR not initialized. Please confirm that board is configured to boot from Flash, ret: %d\n",
634 if (lio_wait_for_bootloader(octeon_dev, 1100)) {
635 lio_dev_err(octeon_dev, "Board not responding\n");
639 /* Divert uboot to take commands from host instead. */
640 ret = lio_console_send_cmd(octeon_dev, bootcmd, 50);
642 lio_dev_dbg(octeon_dev, "Initializing consoles\n");
643 ret = lio_init_consoles(octeon_dev);
645 lio_dev_err(octeon_dev, "Could not access board consoles\n");
650 * If console debug enabled, specify empty string to
651 * use default enablement ELSE specify NULL string for
654 dbg_enb = lio_console_debug_enabled(0) ? "" : NULL;
655 ret = lio_add_console(octeon_dev, 0, dbg_enb);
658 lio_dev_err(octeon_dev, "Could not access board console\n");
660 } else if (lio_console_debug_enabled(0)) {
662 * If console was added AND we're logging console output
663 * then set our console print function.
665 octeon_dev->console[0].print = lio_dbg_console_print;
668 atomic_store_rel_int(&octeon_dev->status,
669 LIO_DEV_CONSOLE_INIT_DONE);
671 lio_dev_dbg(octeon_dev, "Loading firmware\n");
673 ret = lio_load_firmware(octeon_dev);
675 lio_dev_err(octeon_dev, "Could not load firmware to board\n");
680 atomic_store_rel_int(&octeon_dev->status, LIO_DEV_HOST_OK);
686 * \brief PCI FLR for each Octeon device.
687 * @param oct octeon device
690 lio_pci_flr(struct octeon_device *oct)
692 uint32_t exppos, status;
694 pci_find_cap(oct->device, PCIY_EXPRESS, &exppos);
696 pci_save_state(oct->device);
698 /* Quiesce the device completely */
699 pci_write_config(oct->device, PCIR_COMMAND, PCIM_CMD_INTxDIS, 2);
701 /* Wait for Transaction Pending bit clean */
704 status = pci_read_config(oct->device, exppos + PCIER_DEVICE_STA, 2);
705 if (status & PCIEM_STA_TRANSACTION_PND) {
706 lio_dev_info(oct, "Function reset incomplete after 100ms, sleeping for 5 seconds\n");
709 status = pci_read_config(oct->device, exppos + PCIER_DEVICE_STA, 2);
710 if (status & PCIEM_STA_TRANSACTION_PND)
711 lio_dev_info(oct, "Function reset still incomplete after 5s, reset anyway\n");
714 pci_write_config(oct->device, exppos + PCIER_DEVICE_CTL, PCIEM_CTL_INITIATE_FLR, 2);
717 pci_restore_state(oct->device);
721 * \brief Debug console print function
722 * @param octeon_dev octeon device
723 * @param console_num console number
724 * @param prefix first portion of line to display
725 * @param suffix second portion of line to display
727 * The OCTEON debug console outputs entire lines (excluding '\n').
728 * Normally, the line will be passed in the 'prefix' parameter.
729 * However, due to buffering, it is possible for a line to be split into two
730 * parts, in which case they will be passed as the 'prefix' parameter and
731 * 'suffix' parameter.
734 lio_dbg_console_print(struct octeon_device *oct, uint32_t console_num,
735 char *prefix, char *suffix)
738 if (prefix != NULL && suffix != NULL)
739 lio_dev_info(oct, "%u: %s%s\n", console_num, prefix, suffix);
740 else if (prefix != NULL)
741 lio_dev_info(oct, "%u: %s\n", console_num, prefix);
742 else if (suffix != NULL)
743 lio_dev_info(oct, "%u: %s\n", console_num, suffix);
749 lio_watchdog(void *param)
752 uint16_t mask_of_crashed_or_stuck_cores = 0;
753 struct octeon_device *oct = param;
754 bool err_msg_was_printed[12];
756 bzero(err_msg_was_printed, sizeof(err_msg_was_printed));
759 kproc_suspend_check(oct->watchdog_task);
760 mask_of_crashed_or_stuck_cores =
761 (uint16_t)lio_read_csr64(oct, LIO_CN23XX_SLI_SCRATCH2);
763 if (mask_of_crashed_or_stuck_cores) {
764 struct octeon_device *other_oct;
766 oct->cores_crashed = true;
767 other_oct = lio_get_other_octeon_device(oct);
768 if (other_oct != NULL)
769 other_oct->cores_crashed = true;
771 for (core_num = 0; core_num < LIO_MAX_CORES;
773 bool core_crashed_or_got_stuck;
775 core_crashed_or_got_stuck =
776 (mask_of_crashed_or_stuck_cores >>
778 if (core_crashed_or_got_stuck &&
779 !err_msg_was_printed[core_num]) {
781 "ERROR: Octeon core %d crashed or got stuck! See oct-fwdump for details.\n",
783 err_msg_was_printed[core_num] = true;
789 /* sleep for two seconds */
790 pause("-", lio_ms_to_ticks(2000));
795 lio_chip_specific_setup(struct octeon_device *oct)
798 uint32_t dev_id, rev_id;
801 dev_id = lio_read_pci_cfg(oct, 0);
802 rev_id = pci_get_revid(oct->device);
803 oct->subdevice_id = pci_get_subdevice(oct->device);
806 case LIO_CN23XX_PF_PCIID:
807 oct->chip_id = LIO_CN23XX_PF_VID;
808 if (pci_get_function(oct->device) == 0) {
809 if (num_queues_per_pf0 < 0) {
810 lio_dev_info(oct, "Invalid num_queues_per_pf0: %d, Setting it to default\n",
812 num_queues_per_pf0 = 0;
815 oct->sriov_info.num_pf_rings = num_queues_per_pf0;
817 if (num_queues_per_pf1 < 0) {
818 lio_dev_info(oct, "Invalid num_queues_per_pf1: %d, Setting it to default\n",
820 num_queues_per_pf1 = 0;
823 oct->sriov_info.num_pf_rings = num_queues_per_pf1;
826 ret = lio_cn23xx_pf_setup_device(oct);
832 lio_dev_err(oct, "Unknown device found (dev_id: %x)\n", dev_id);
836 lio_dev_info(oct, "%s PASS%d.%d %s Version: %s\n", s,
837 OCTEON_MAJOR_REV(oct), OCTEON_MINOR_REV(oct),
838 lio_get_conf(oct)->card_name, LIO_VERSION);
843 static struct octeon_device *
844 lio_get_other_octeon_device(struct octeon_device *oct)
846 struct octeon_device *other_oct;
848 other_oct = lio_get_device(oct->octeon_id + 1);
850 if ((other_oct != NULL) && other_oct->device) {
851 int oct_busnum, other_oct_busnum;
853 oct_busnum = pci_get_bus(oct->device);
854 other_oct_busnum = pci_get_bus(other_oct->device);
856 if (oct_busnum == other_oct_busnum) {
857 int oct_slot, other_oct_slot;
859 oct_slot = pci_get_slot(oct->device);
860 other_oct_slot = pci_get_slot(other_oct->device);
862 if (oct_slot == other_oct_slot)
870 * \brief Load firmware to device
871 * @param oct octeon device
873 * Maps device to firmware filename, requests firmware, and downloads it
876 lio_load_firmware(struct octeon_device *oct)
878 const struct firmware *fw;
879 char *tmp_fw_type = NULL;
881 char fw_name[LIO_MAX_FW_FILENAME_LEN];
883 if (fw_type[0] == '\0')
884 tmp_fw_type = LIO_FW_NAME_TYPE_NIC;
886 tmp_fw_type = fw_type;
888 sprintf(fw_name, "%s%s_%s%s", LIO_FW_BASE_NAME,
889 lio_get_conf(oct)->card_name, tmp_fw_type, LIO_FW_NAME_SUFFIX);
891 fw = firmware_get(fw_name);
893 lio_dev_err(oct, "Request firmware failed. Could not find file %s.\n",
898 ret = lio_download_firmware(oct, fw->data, fw->datasize);
900 firmware_put(fw, FIRMWARE_UNLOAD);
906 lio_nic_starter(struct octeon_device *oct)
910 atomic_store_rel_int(&oct->status, LIO_DEV_RUNNING);
912 if (oct->app_mode && oct->app_mode == LIO_DRV_NIC_APP) {
913 if (lio_init_nic_module(oct)) {
914 lio_dev_err(oct, "NIC initialization failed\n");
916 #ifdef CAVIUM_ONiLY_23XX_VF
918 if (octeon_enable_sriov(oct) < 0)
924 "Unexpected application running on NIC (%d). Check firmware.\n",
933 lio_init_nic_module(struct octeon_device *oct)
935 int num_nic_ports = LIO_GET_NUM_NIC_PORTS_CFG(lio_get_conf(oct));
938 lio_dev_dbg(oct, "Initializing network interfaces\n");
941 * only default iq and oq were initialized
942 * initialize the rest as well
945 /* run port_config command for each port */
946 oct->ifcount = num_nic_ports;
948 bzero(&oct->props, sizeof(struct lio_if_props));
950 oct->props.gmxport = -1;
952 retval = lio_setup_nic_devices(oct);
954 lio_dev_err(oct, "Setup NIC devices failed\n");
955 goto lio_init_failure;
958 lio_dev_dbg(oct, "Network interfaces ready\n");
970 lio_ifmedia_update(struct ifnet *ifp)
972 struct lio *lio = if_getsoftc(ifp);
977 /* We only support Ethernet media type. */
978 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
981 switch (IFM_SUBTYPE(ifm->ifm_media)) {
989 /* We don't support changing the media type. */
990 lio_dev_err(lio->oct_dev, "Invalid media type (%d)\n",
991 IFM_SUBTYPE(ifm->ifm_media));
999 lio_get_media_subtype(struct octeon_device *oct)
1002 switch(oct->subdevice_id) {
1003 case LIO_CN2350_10G_SUBDEVICE:
1004 case LIO_CN2350_10G_SUBDEVICE1:
1005 case LIO_CN2360_10G_SUBDEVICE:
1006 return (IFM_10G_SR);
1008 case LIO_CN2350_25G_SUBDEVICE:
1009 case LIO_CN2360_25G_SUBDEVICE:
1010 return (IFM_25G_SR);
1013 return (IFM_10G_SR);
1016 static unsigned long
1017 lio_get_baudrate(struct octeon_device *oct)
1020 switch(oct->subdevice_id) {
1021 case LIO_CN2350_10G_SUBDEVICE:
1022 case LIO_CN2350_10G_SUBDEVICE1:
1023 case LIO_CN2360_10G_SUBDEVICE:
1024 return (IF_Gbps(10));
1026 case LIO_CN2350_25G_SUBDEVICE:
1027 case LIO_CN2360_25G_SUBDEVICE:
1028 return (IF_Gbps(25));
1031 return (IF_Gbps(10));
1035 lio_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr)
1037 struct lio *lio = if_getsoftc(ifp);
1039 /* Report link down if the driver isn't running. */
1040 if (!lio_ifstate_check(lio, LIO_IFSTATE_RUNNING)) {
1041 ifmr->ifm_active |= IFM_NONE;
1045 /* Setup the default interface info. */
1046 ifmr->ifm_status = IFM_AVALID;
1047 ifmr->ifm_active = IFM_ETHER;
1049 if (lio->linfo.link.s.link_up) {
1050 ifmr->ifm_status |= IFM_ACTIVE;
1052 ifmr->ifm_active |= IFM_NONE;
1056 ifmr->ifm_active |= lio_get_media_subtype(lio->oct_dev);
1058 if (lio->linfo.link.s.duplex)
1059 ifmr->ifm_active |= IFM_FDX;
1061 ifmr->ifm_active |= IFM_HDX;
1065 lio_get_counter(if_t ifp, ift_counter cnt)
1067 struct lio *lio = if_getsoftc(ifp);
1068 struct octeon_device *oct = lio->oct_dev;
1069 uint64_t counter = 0;
1073 case IFCOUNTER_IPACKETS:
1074 for (i = 0; i < oct->num_oqs; i++) {
1075 q_no = lio->linfo.rxpciq[i].s.q_no;
1076 counter += oct->droq[q_no]->stats.rx_pkts_received;
1079 case IFCOUNTER_OPACKETS:
1080 for (i = 0; i < oct->num_iqs; i++) {
1081 q_no = lio->linfo.txpciq[i].s.q_no;
1082 counter += oct->instr_queue[q_no]->stats.tx_done;
1085 case IFCOUNTER_IBYTES:
1086 for (i = 0; i < oct->num_oqs; i++) {
1087 q_no = lio->linfo.rxpciq[i].s.q_no;
1088 counter += oct->droq[q_no]->stats.rx_bytes_received;
1091 case IFCOUNTER_OBYTES:
1092 for (i = 0; i < oct->num_iqs; i++) {
1093 q_no = lio->linfo.txpciq[i].s.q_no;
1094 counter += oct->instr_queue[q_no]->stats.tx_tot_bytes;
1097 case IFCOUNTER_IQDROPS:
1098 for (i = 0; i < oct->num_oqs; i++) {
1099 q_no = lio->linfo.rxpciq[i].s.q_no;
1100 counter += oct->droq[q_no]->stats.rx_dropped;
1103 case IFCOUNTER_OQDROPS:
1104 for (i = 0; i < oct->num_iqs; i++) {
1105 q_no = lio->linfo.txpciq[i].s.q_no;
1106 counter += oct->instr_queue[q_no]->stats.tx_dropped;
1109 case IFCOUNTER_IMCASTS:
1110 counter = oct->link_stats.fromwire.total_mcst;
1112 case IFCOUNTER_OMCASTS:
1113 counter = oct->link_stats.fromhost.mcast_pkts_sent;
1115 case IFCOUNTER_COLLISIONS:
1116 counter = oct->link_stats.fromhost.total_collisions;
1118 case IFCOUNTER_IERRORS:
1119 counter = oct->link_stats.fromwire.fcs_err +
1120 oct->link_stats.fromwire.l2_err +
1121 oct->link_stats.fromwire.frame_err;
1124 return (if_get_counter_default(ifp, cnt));
1131 lio_init_ifnet(struct lio *lio)
1133 struct octeon_device *oct = lio->oct_dev;
1134 if_t ifp = lio->ifp;
1136 /* ifconfig entrypoint for media type/status reporting */
1137 ifmedia_init(&lio->ifmedia, IFM_IMASK, lio_ifmedia_update,
1138 lio_ifmedia_status);
1140 /* set the default interface values */
1141 ifmedia_add(&lio->ifmedia,
1142 (IFM_ETHER | IFM_FDX | lio_get_media_subtype(oct)),
1144 ifmedia_add(&lio->ifmedia, (IFM_ETHER | IFM_AUTO), 0, NULL);
1145 ifmedia_set(&lio->ifmedia, (IFM_ETHER | IFM_AUTO));
1147 lio->ifmedia.ifm_media = lio->ifmedia.ifm_cur->ifm_media;
1148 lio_dev_dbg(oct, "IFMEDIA flags : %x\n", lio->ifmedia.ifm_media);
1150 if_initname(ifp, device_get_name(oct->device),
1151 device_get_unit(oct->device));
1152 if_setflags(ifp, (IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST));
1153 if_setioctlfn(ifp, lio_ioctl);
1154 if_setgetcounterfn(ifp, lio_get_counter);
1155 if_settransmitfn(ifp, lio_mq_start);
1156 if_setqflushfn(ifp, lio_qflush);
1157 if_setinitfn(ifp, lio_open);
1158 if_setmtu(ifp, lio->linfo.link.s.mtu);
1159 lio->mtu = lio->linfo.link.s.mtu;
1160 if_sethwassist(ifp, (CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_TSO |
1161 CSUM_TCP_IPV6 | CSUM_UDP_IPV6));
1163 if_setcapabilitiesbit(ifp, (IFCAP_HWCSUM | IFCAP_HWCSUM_IPV6 |
1164 IFCAP_TSO | IFCAP_LRO |
1165 IFCAP_JUMBO_MTU | IFCAP_HWSTATS |
1166 IFCAP_LINKSTATE | IFCAP_VLAN_HWFILTER |
1167 IFCAP_VLAN_HWCSUM | IFCAP_VLAN_HWTAGGING |
1168 IFCAP_VLAN_HWTSO | IFCAP_VLAN_MTU), 0);
1170 if_setcapenable(ifp, if_getcapabilities(ifp));
1171 if_setbaudrate(ifp, lio_get_baudrate(oct));
1177 lio_tcp_lro_free(struct octeon_device *octeon_dev, struct ifnet *ifp)
1179 struct lio *lio = if_getsoftc(ifp);
1180 struct lio_droq *droq;
1184 for (i = 0; i < octeon_dev->num_oqs; i++) {
1185 q_no = lio->linfo.rxpciq[i].s.q_no;
1186 droq = octeon_dev->droq[q_no];
1187 if (droq->lro.ifp) {
1188 tcp_lro_free(&droq->lro);
1189 droq->lro.ifp = NULL;
1195 lio_tcp_lro_init(struct octeon_device *octeon_dev, struct ifnet *ifp)
1197 struct lio *lio = if_getsoftc(ifp);
1198 struct lio_droq *droq;
1199 struct lro_ctrl *lro;
1200 int i, q_no, ret = 0;
1202 for (i = 0; i < octeon_dev->num_oqs; i++) {
1203 q_no = lio->linfo.rxpciq[i].s.q_no;
1204 droq = octeon_dev->droq[q_no];
1206 ret = tcp_lro_init(lro);
1208 lio_dev_err(octeon_dev, "LRO Initialization failed ret %d\n",
1210 goto lro_init_failed;
1219 lio_tcp_lro_free(octeon_dev, ifp);
1225 lio_setup_nic_devices(struct octeon_device *octeon_dev)
1227 union octeon_if_cfg if_cfg;
1228 struct lio *lio = NULL;
1229 struct ifnet *ifp = NULL;
1230 struct lio_version *vdata;
1231 struct lio_soft_command *sc;
1232 struct lio_if_cfg_context *ctx;
1233 struct lio_if_cfg_resp *resp;
1234 struct lio_if_props *props;
1235 int num_iqueues, num_oqueues, retval;
1236 unsigned int base_queue;
1237 unsigned int gmx_port_id;
1238 uint32_t ctx_size, data_size;
1239 uint32_t ifidx_or_pfnum, resp_size;
1240 uint8_t mac[ETHER_HDR_LEN], i, j;
1242 /* This is to handle link status changes */
1243 lio_register_dispatch_fn(octeon_dev, LIO_OPCODE_NIC,
1244 LIO_OPCODE_NIC_INFO,
1245 lio_link_info, octeon_dev);
1247 for (i = 0; i < octeon_dev->ifcount; i++) {
1248 resp_size = sizeof(struct lio_if_cfg_resp);
1249 ctx_size = sizeof(struct lio_if_cfg_context);
1250 data_size = sizeof(struct lio_version);
1251 sc = lio_alloc_soft_command(octeon_dev, data_size, resp_size,
1256 resp = (struct lio_if_cfg_resp *)sc->virtrptr;
1257 ctx = (struct lio_if_cfg_context *)sc->ctxptr;
1258 vdata = (struct lio_version *)sc->virtdptr;
1260 *((uint64_t *)vdata) = 0;
1261 vdata->major = htobe16(LIO_BASE_MAJOR_VERSION);
1262 vdata->minor = htobe16(LIO_BASE_MINOR_VERSION);
1263 vdata->micro = htobe16(LIO_BASE_MICRO_VERSION);
1265 num_iqueues = octeon_dev->sriov_info.num_pf_rings;
1266 num_oqueues = octeon_dev->sriov_info.num_pf_rings;
1267 base_queue = octeon_dev->sriov_info.pf_srn;
1269 gmx_port_id = octeon_dev->pf_num;
1270 ifidx_or_pfnum = octeon_dev->pf_num;
1272 lio_dev_dbg(octeon_dev, "requesting config for interface %d, iqs %d, oqs %d\n",
1273 ifidx_or_pfnum, num_iqueues, num_oqueues);
1275 ctx->octeon_id = lio_get_device_id(octeon_dev);
1277 if_cfg.if_cfg64 = 0;
1278 if_cfg.s.num_iqueues = num_iqueues;
1279 if_cfg.s.num_oqueues = num_oqueues;
1280 if_cfg.s.base_queue = base_queue;
1281 if_cfg.s.gmx_port_id = gmx_port_id;
1285 lio_prepare_soft_command(octeon_dev, sc, LIO_OPCODE_NIC,
1286 LIO_OPCODE_NIC_IF_CFG, 0,
1287 if_cfg.if_cfg64, 0);
1289 sc->callback = lio_if_cfg_callback;
1290 sc->callback_arg = sc;
1291 sc->wait_time = 3000;
1293 retval = lio_send_soft_command(octeon_dev, sc);
1294 if (retval == LIO_IQ_SEND_FAILED) {
1295 lio_dev_err(octeon_dev, "iq/oq config failed status: %x\n",
1297 /* Soft instr is freed by driver in case of failure. */
1298 goto setup_nic_dev_fail;
1302 * Sleep on a wait queue till the cond flag indicates that the
1303 * response arrived or timed-out.
1305 lio_sleep_cond(octeon_dev, &ctx->cond);
1307 retval = resp->status;
1309 lio_dev_err(octeon_dev, "iq/oq config failed\n");
1310 goto setup_nic_dev_fail;
1313 lio_swap_8B_data((uint64_t *)(&resp->cfg_info),
1314 (sizeof(struct octeon_if_cfg_info)) >> 3);
1316 num_iqueues = bitcount64(resp->cfg_info.iqmask);
1317 num_oqueues = bitcount64(resp->cfg_info.oqmask);
1319 if (!(num_iqueues) || !(num_oqueues)) {
1320 lio_dev_err(octeon_dev,
1321 "Got bad iqueues (%016lX) or oqueues (%016lX) from firmware.\n",
1322 resp->cfg_info.iqmask,
1323 resp->cfg_info.oqmask);
1324 goto setup_nic_dev_fail;
1327 lio_dev_dbg(octeon_dev,
1328 "interface %d, iqmask %016lx, oqmask %016lx, numiqueues %d, numoqueues %d\n",
1329 i, resp->cfg_info.iqmask, resp->cfg_info.oqmask,
1330 num_iqueues, num_oqueues);
1332 ifp = if_alloc(IFT_ETHER);
1335 lio_dev_err(octeon_dev, "Device allocation failed\n");
1336 goto setup_nic_dev_fail;
1339 lio = malloc(sizeof(struct lio), M_DEVBUF, M_NOWAIT | M_ZERO);
1342 lio_dev_err(octeon_dev, "Lio allocation failed\n");
1343 goto setup_nic_dev_fail;
1346 if_setsoftc(ifp, lio);
1348 ifp->if_hw_tsomax = LIO_MAX_FRAME_SIZE;
1349 ifp->if_hw_tsomaxsegcount = LIO_MAX_SG;
1350 ifp->if_hw_tsomaxsegsize = PAGE_SIZE;
1352 lio->ifidx = ifidx_or_pfnum;
1354 props = &octeon_dev->props;
1355 props->gmxport = resp->cfg_info.linfo.gmxport;
1358 lio->linfo.num_rxpciq = num_oqueues;
1359 lio->linfo.num_txpciq = num_iqueues;
1360 for (j = 0; j < num_oqueues; j++) {
1361 lio->linfo.rxpciq[j].rxpciq64 =
1362 resp->cfg_info.linfo.rxpciq[j].rxpciq64;
1365 for (j = 0; j < num_iqueues; j++) {
1366 lio->linfo.txpciq[j].txpciq64 =
1367 resp->cfg_info.linfo.txpciq[j].txpciq64;
1370 lio->linfo.hw_addr = resp->cfg_info.linfo.hw_addr;
1371 lio->linfo.gmxport = resp->cfg_info.linfo.gmxport;
1372 lio->linfo.link.link_status64 =
1373 resp->cfg_info.linfo.link.link_status64;
1376 * Point to the properties for octeon device to which this
1377 * interface belongs.
1379 lio->oct_dev = octeon_dev;
1382 lio_dev_dbg(octeon_dev, "if%d gmx: %d hw_addr: 0x%llx\n", i,
1383 lio->linfo.gmxport, LIO_CAST64(lio->linfo.hw_addr));
1384 lio_init_ifnet(lio);
1385 /* 64-bit swap required on LE machines */
1386 lio_swap_8B_data(&lio->linfo.hw_addr, 1);
1387 for (j = 0; j < 6; j++)
1388 mac[j] = *((uint8_t *)(
1389 ((uint8_t *)&lio->linfo.hw_addr) + 2 + j));
1391 ether_ifattach(ifp, mac);
1394 * By default all interfaces on a single Octeon uses the same
1397 lio->txq = lio->linfo.txpciq[0].s.q_no;
1398 lio->rxq = lio->linfo.rxpciq[0].s.q_no;
1399 if (lio_setup_io_queues(octeon_dev, i, lio->linfo.num_txpciq,
1400 lio->linfo.num_rxpciq)) {
1401 lio_dev_err(octeon_dev, "I/O queues creation failed\n");
1402 goto setup_nic_dev_fail;
1405 lio_ifstate_set(lio, LIO_IFSTATE_DROQ_OPS);
1407 lio->tx_qsize = lio_get_tx_qsize(octeon_dev, lio->txq);
1408 lio->rx_qsize = lio_get_rx_qsize(octeon_dev, lio->rxq);
1410 if (lio_setup_glists(octeon_dev, lio, num_iqueues)) {
1411 lio_dev_err(octeon_dev, "Gather list allocation failed\n");
1412 goto setup_nic_dev_fail;
1415 if ((lio_hwlro == 0) && lio_tcp_lro_init(octeon_dev, ifp))
1416 goto setup_nic_dev_fail;
1419 (if_getcapenable(ifp) & IFCAP_LRO) &&
1420 (if_getcapenable(ifp) & IFCAP_RXCSUM) &&
1421 (if_getcapenable(ifp) & IFCAP_RXCSUM_IPV6))
1422 lio_set_feature(ifp, LIO_CMD_LRO_ENABLE,
1423 LIO_LROIPV4 | LIO_LROIPV6);
1425 if ((if_getcapenable(ifp) & IFCAP_VLAN_HWFILTER))
1426 lio_set_feature(ifp, LIO_CMD_VLAN_FILTER_CTL, 1);
1428 lio_set_feature(ifp, LIO_CMD_VLAN_FILTER_CTL, 0);
1430 if (lio_setup_rx_oom_poll_fn(ifp))
1431 goto setup_nic_dev_fail;
1433 lio_dev_dbg(octeon_dev, "Setup NIC ifidx:%d mac:%02x%02x%02x%02x%02x%02x\n",
1434 i, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
1435 lio->link_changes++;
1437 lio_ifstate_set(lio, LIO_IFSTATE_REGISTERED);
1440 * Sending command to firmware to enable Rx checksum offload
1441 * by default at the time of setup of Liquidio driver for
1444 lio_set_rxcsum_command(ifp, LIO_CMD_TNL_RX_CSUM_CTL,
1445 LIO_CMD_RXCSUM_ENABLE);
1446 lio_set_feature(ifp, LIO_CMD_TNL_TX_CSUM_CTL,
1447 LIO_CMD_TXCSUM_ENABLE);
1451 if (lio_send_rss_param(lio))
1452 goto setup_nic_dev_fail;
1456 lio_set_feature(ifp, LIO_CMD_SET_FNV,
1457 LIO_CMD_FNV_ENABLE);
1459 lio_dev_dbg(octeon_dev, "NIC ifidx:%d Setup successful\n", i);
1461 lio_free_soft_command(octeon_dev, sc);
1463 EVENTHANDLER_REGISTER(vlan_config,
1464 lio_vlan_rx_add_vid, lio,
1465 EVENTHANDLER_PRI_FIRST);
1467 EVENTHANDLER_REGISTER(vlan_unconfig,
1468 lio_vlan_rx_kill_vid, lio,
1469 EVENTHANDLER_PRI_FIRST);
1471 /* Update stats periodically */
1472 callout_init(&lio->stats_timer, 0);
1473 lio->stats_interval = LIO_DEFAULT_STATS_INTERVAL;
1475 lio_add_hw_stats(lio);
1482 lio_free_soft_command(octeon_dev, sc);
1485 lio_dev_err(octeon_dev, "NIC ifidx:%d Setup failed\n", i);
1486 lio_destroy_nic_device(octeon_dev, i);
1493 lio_link_info(struct lio_recv_info *recv_info, void *ptr)
1495 struct octeon_device *oct = (struct octeon_device *)ptr;
1496 struct lio_recv_pkt *recv_pkt = recv_info->recv_pkt;
1497 union octeon_link_status *ls;
1500 lio_dev_dbg(oct, "%s Called\n", __func__);
1501 if (recv_pkt->buffer_size[0] != (sizeof(*ls) + LIO_DROQ_INFO_SIZE)) {
1502 lio_dev_err(oct, "Malformed NIC_INFO, len=%d, ifidx=%d\n",
1503 recv_pkt->buffer_size[0],
1504 recv_pkt->rh.r_nic_info.gmxport);
1507 gmxport = recv_pkt->rh.r_nic_info.gmxport;
1508 ls = (union octeon_link_status *)(recv_pkt->buffer_ptr[0]->m_data +
1509 LIO_DROQ_INFO_SIZE);
1510 lio_swap_8B_data((uint64_t *)ls,
1511 (sizeof(union octeon_link_status)) >> 3);
1513 if (oct->props.gmxport == gmxport)
1514 lio_update_link_status(oct->props.ifp, ls);
1517 for (i = 0; i < recv_pkt->buffer_count; i++)
1518 lio_recv_buffer_free(recv_pkt->buffer_ptr[i]);
1520 lio_free_recv_info(recv_info);
1525 lio_free_mbuf(struct lio_instr_queue *iq, struct lio_mbuf_free_info *finfo)
1528 bus_dmamap_sync(iq->txtag, finfo->map, BUS_DMASYNC_POSTWRITE);
1529 bus_dmamap_unload(iq->txtag, finfo->map);
1534 lio_free_sgmbuf(struct lio_instr_queue *iq, struct lio_mbuf_free_info *finfo)
1536 struct lio_gather *g;
1537 struct octeon_device *oct;
1542 iq_no = iq->txpciq.s.q_no;
1544 lio = if_getsoftc(oct->props.ifp);
1546 mtx_lock(&lio->glist_lock[iq_no]);
1547 STAILQ_INSERT_TAIL(&lio->ghead[iq_no], &g->node, entries);
1548 mtx_unlock(&lio->glist_lock[iq_no]);
1550 bus_dmamap_sync(iq->txtag, finfo->map, BUS_DMASYNC_POSTWRITE);
1551 bus_dmamap_unload(iq->txtag, finfo->map);
1556 lio_if_cfg_callback(struct octeon_device *oct, uint32_t status, void *buf)
1558 struct lio_soft_command *sc = (struct lio_soft_command *)buf;
1559 struct lio_if_cfg_resp *resp;
1560 struct lio_if_cfg_context *ctx;
1562 resp = (struct lio_if_cfg_resp *)sc->virtrptr;
1563 ctx = (struct lio_if_cfg_context *)sc->ctxptr;
1565 oct = lio_get_device(ctx->octeon_id);
1567 lio_dev_err(oct, "nic if cfg instruction failed. Status: %llx (0x%08x)\n",
1568 LIO_CAST64(resp->status), status);
1571 snprintf(oct->fw_info.lio_firmware_version, 32, "%s",
1572 resp->cfg_info.lio_firmware_version);
1575 * This barrier is required to be sure that the response has been
1576 * written fully before waking up the handler
1582 lio_is_mac_changed(uint8_t *new, uint8_t *old)
1585 return ((new[0] != old[0]) || (new[1] != old[1]) ||
1586 (new[2] != old[2]) || (new[3] != old[3]) ||
1587 (new[4] != old[4]) || (new[5] != old[5]));
1593 struct lio *lio = arg;
1594 struct ifnet *ifp = lio->ifp;
1595 struct octeon_device *oct = lio->oct_dev;
1596 uint8_t *mac_new, mac_old[ETHER_HDR_LEN];
1599 lio_ifstate_set(lio, LIO_IFSTATE_RUNNING);
1601 /* Ready for link status updates */
1604 lio_dev_info(oct, "Interface Open, ready for traffic\n");
1606 /* tell Octeon to start forwarding packets to host */
1607 lio_send_rx_ctrl_cmd(lio, 1);
1609 mac_new = IF_LLADDR(ifp);
1610 memcpy(mac_old, ((uint8_t *)&lio->linfo.hw_addr) + 2, ETHER_HDR_LEN);
1612 if (lio_is_mac_changed(mac_new, mac_old)) {
1613 ret = lio_set_mac(ifp, mac_new);
1615 lio_dev_err(oct, "MAC change failed, error: %d\n", ret);
1618 /* Now inform the stack we're ready */
1619 if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
1621 lio_dev_info(oct, "Interface is opened\n");
1625 lio_set_rxcsum_command(struct ifnet *ifp, int command, uint8_t rx_cmd)
1627 struct lio_ctrl_pkt nctrl;
1628 struct lio *lio = if_getsoftc(ifp);
1629 struct octeon_device *oct = lio->oct_dev;
1632 nctrl.ncmd.cmd64 = 0;
1633 nctrl.ncmd.s.cmd = command;
1634 nctrl.ncmd.s.param1 = rx_cmd;
1635 nctrl.iq_no = lio->linfo.txpciq[0].s.q_no;
1636 nctrl.wait_time = 100;
1638 nctrl.cb_fn = lio_ctrl_cmd_completion;
1640 ret = lio_send_ctrl_pkt(lio->oct_dev, &nctrl);
1642 lio_dev_err(oct, "DEVFLAGS RXCSUM change failed in core(ret:0x%x)\n",
1650 lio_stop_nic_module(struct octeon_device *oct)
1655 lio_dev_dbg(oct, "Stopping network interfaces\n");
1656 if (!oct->ifcount) {
1657 lio_dev_err(oct, "Init for Octeon was not completed\n");
1661 mtx_lock(&oct->cmd_resp_wqlock);
1662 oct->cmd_resp_state = LIO_DRV_OFFLINE;
1663 mtx_unlock(&oct->cmd_resp_wqlock);
1665 for (i = 0; i < oct->ifcount; i++) {
1666 lio = if_getsoftc(oct->props.ifp);
1667 for (j = 0; j < oct->num_oqs; j++)
1668 lio_unregister_droq_ops(oct,
1669 lio->linfo.rxpciq[j].s.q_no);
1672 callout_drain(&lio->stats_timer);
1674 for (i = 0; i < oct->ifcount; i++)
1675 lio_destroy_nic_device(oct, i);
1677 lio_dev_dbg(oct, "Network interface stopped\n");
1683 lio_delete_glists(struct octeon_device *oct, struct lio *lio)
1685 struct lio_gather *g;
1688 if (lio->glist_lock != NULL) {
1689 free((void *)lio->glist_lock, M_DEVBUF);
1690 lio->glist_lock = NULL;
1693 if (lio->ghead == NULL)
1696 for (i = 0; i < lio->linfo.num_txpciq; i++) {
1698 g = (struct lio_gather *)
1699 lio_delete_first_node(&lio->ghead[i]);
1703 if ((lio->glists_virt_base != NULL) &&
1704 (lio->glists_virt_base[i] != NULL)) {
1705 lio_dma_free(lio->glist_entry_size * lio->tx_qsize,
1706 lio->glists_virt_base[i]);
1710 free(lio->glists_virt_base, M_DEVBUF);
1711 lio->glists_virt_base = NULL;
1713 free(lio->glists_dma_base, M_DEVBUF);
1714 lio->glists_dma_base = NULL;
1716 free(lio->ghead, M_DEVBUF);
1721 lio_setup_glists(struct octeon_device *oct, struct lio *lio, int num_iqs)
1723 struct lio_gather *g;
1726 lio->glist_lock = malloc(num_iqs * sizeof(*lio->glist_lock), M_DEVBUF,
1728 if (lio->glist_lock == NULL)
1731 lio->ghead = malloc(num_iqs * sizeof(*lio->ghead), M_DEVBUF,
1733 if (lio->ghead == NULL) {
1734 free((void *)lio->glist_lock, M_DEVBUF);
1735 lio->glist_lock = NULL;
1739 lio->glist_entry_size = ROUNDUP8((ROUNDUP4(LIO_MAX_SG) >> 2) *
1742 * allocate memory to store virtual and dma base address of
1743 * per glist consistent memory
1745 lio->glists_virt_base = malloc(num_iqs * sizeof(void *), M_DEVBUF,
1747 lio->glists_dma_base = malloc(num_iqs * sizeof(vm_paddr_t), M_DEVBUF,
1749 if ((lio->glists_virt_base == NULL) || (lio->glists_dma_base == NULL)) {
1750 lio_delete_glists(oct, lio);
1754 for (i = 0; i < num_iqs; i++) {
1755 mtx_init(&lio->glist_lock[i], "glist_lock", NULL, MTX_DEF);
1757 STAILQ_INIT(&lio->ghead[i]);
1759 lio->glists_virt_base[i] =
1760 lio_dma_alloc(lio->glist_entry_size * lio->tx_qsize,
1761 (vm_paddr_t *)&lio->glists_dma_base[i]);
1762 if (lio->glists_virt_base[i] == NULL) {
1763 lio_delete_glists(oct, lio);
1767 for (j = 0; j < lio->tx_qsize; j++) {
1768 g = malloc(sizeof(*g), M_DEVBUF, M_NOWAIT | M_ZERO);
1772 g->sg = (struct lio_sg_entry *)
1773 ((uint64_t)lio->glists_virt_base[i] +
1774 (j * lio->glist_entry_size));
1775 g->sg_dma_ptr = (uint64_t)lio->glists_dma_base[i] +
1776 (j * lio->glist_entry_size);
1777 STAILQ_INSERT_TAIL(&lio->ghead[i], &g->node, entries);
1780 if (j != lio->tx_qsize) {
1781 lio_delete_glists(oct, lio);
1790 lio_stop(struct ifnet *ifp)
1792 struct lio *lio = if_getsoftc(ifp);
1793 struct octeon_device *oct = lio->oct_dev;
1795 lio_ifstate_reset(lio, LIO_IFSTATE_RUNNING);
1796 if_link_state_change(ifp, LINK_STATE_DOWN);
1799 lio->linfo.link.s.link_up = 0;
1800 lio->link_changes++;
1802 lio_send_rx_ctrl_cmd(lio, 0);
1804 /* Tell the stack that the interface is no longer active */
1805 if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING);
1807 lio_dev_info(oct, "Interface is stopped\n");
1811 lio_check_rx_oom_status(struct lio *lio)
1813 struct lio_droq *droq;
1814 struct octeon_device *oct = lio->oct_dev;
1818 for (q = 0; q < oct->num_oqs; q++) {
1819 q_no = lio->linfo.rxpciq[q].s.q_no;
1820 droq = oct->droq[q_no];
1823 if (lio_read_csr32(oct, droq->pkts_credit_reg) <= 0x40) {
1824 mtx_lock(&droq->lock);
1825 desc_refilled = lio_droq_refill(oct, droq);
1827 * Flush the droq descriptor data to memory to be sure
1828 * that when we update the credits the data in memory
1832 lio_write_csr32(oct, droq->pkts_credit_reg,
1834 /* make sure mmio write completes */
1835 __compiler_membar();
1836 mtx_unlock(&droq->lock);
1842 lio_poll_check_rx_oom_status(void *arg, int pending __unused)
1844 struct lio_tq *rx_status_tq = arg;
1845 struct lio *lio = rx_status_tq->ctxptr;
1847 if (lio_ifstate_check(lio, LIO_IFSTATE_RUNNING))
1848 lio_check_rx_oom_status(lio);
1850 taskqueue_enqueue_timeout(rx_status_tq->tq, &rx_status_tq->work,
1851 lio_ms_to_ticks(50));
1855 lio_setup_rx_oom_poll_fn(struct ifnet *ifp)
1857 struct lio *lio = if_getsoftc(ifp);
1858 struct octeon_device *oct = lio->oct_dev;
1859 struct lio_tq *rx_status_tq;
1861 rx_status_tq = &lio->rx_status_tq;
1863 rx_status_tq->tq = taskqueue_create("lio_rx_oom_status", M_WAITOK,
1864 taskqueue_thread_enqueue,
1866 if (rx_status_tq->tq == NULL) {
1867 lio_dev_err(oct, "unable to create lio rx oom status tq\n");
1871 TIMEOUT_TASK_INIT(rx_status_tq->tq, &rx_status_tq->work, 0,
1872 lio_poll_check_rx_oom_status, (void *)rx_status_tq);
1874 rx_status_tq->ctxptr = lio;
1876 taskqueue_start_threads(&rx_status_tq->tq, 1, PI_NET,
1877 "lio%d_rx_oom_status",
1880 taskqueue_enqueue_timeout(rx_status_tq->tq, &rx_status_tq->work,
1881 lio_ms_to_ticks(50));
1887 lio_cleanup_rx_oom_poll_fn(struct ifnet *ifp)
1889 struct lio *lio = if_getsoftc(ifp);
1891 if (lio->rx_status_tq.tq != NULL) {
1892 while (taskqueue_cancel_timeout(lio->rx_status_tq.tq,
1893 &lio->rx_status_tq.work, NULL))
1894 taskqueue_drain_timeout(lio->rx_status_tq.tq,
1895 &lio->rx_status_tq.work);
1897 taskqueue_free(lio->rx_status_tq.tq);
1899 lio->rx_status_tq.tq = NULL;
1904 lio_destroy_nic_device(struct octeon_device *oct, int ifidx)
1906 struct ifnet *ifp = oct->props.ifp;
1910 lio_dev_err(oct, "%s No ifp ptr for index %d\n",
1915 lio = if_getsoftc(ifp);
1917 lio_ifstate_set(lio, LIO_IFSTATE_DETACH);
1919 lio_dev_dbg(oct, "NIC device cleanup\n");
1921 if (atomic_load_acq_int(&lio->ifstate) & LIO_IFSTATE_RUNNING)
1924 if (lio_wait_for_pending_requests(oct))
1925 lio_dev_err(oct, "There were pending requests\n");
1927 if (lio_wait_for_instr_fetch(oct))
1928 lio_dev_err(oct, "IQ had pending instructions\n");
1930 if (lio_wait_for_oq_pkts(oct))
1931 lio_dev_err(oct, "OQ had pending packets\n");
1933 if (atomic_load_acq_int(&lio->ifstate) & LIO_IFSTATE_REGISTERED)
1934 ether_ifdetach(ifp);
1936 lio_tcp_lro_free(oct, ifp);
1938 lio_cleanup_rx_oom_poll_fn(ifp);
1940 lio_delete_glists(oct, lio);
1942 EVENTHANDLER_DEREGISTER(vlan_config, lio->vlan_attach);
1943 EVENTHANDLER_DEREGISTER(vlan_unconfig, lio->vlan_detach);
1945 free(lio, M_DEVBUF);
1949 oct->props.gmxport = -1;
1951 oct->props.ifp = NULL;
1955 print_link_info(struct ifnet *ifp)
1957 struct lio *lio = if_getsoftc(ifp);
1959 if (!lio_ifstate_check(lio, LIO_IFSTATE_RESETTING) &&
1960 lio_ifstate_check(lio, LIO_IFSTATE_REGISTERED)) {
1961 struct octeon_link_info *linfo = &lio->linfo;
1963 if (linfo->link.s.link_up) {
1964 lio_dev_info(lio->oct_dev, "%d Mbps %s Duplex UP\n",
1965 linfo->link.s.speed,
1966 (linfo->link.s.duplex) ? "Full" : "Half");
1968 lio_dev_info(lio->oct_dev, "Link Down\n");
1974 lio_update_link_status(struct ifnet *ifp, union octeon_link_status *ls)
1976 struct lio *lio = if_getsoftc(ifp);
1977 int changed = (lio->linfo.link.link_status64 != ls->link_status64);
1979 lio->linfo.link.link_status64 = ls->link_status64;
1981 if ((lio->intf_open) && (changed)) {
1982 print_link_info(ifp);
1983 lio->link_changes++;
1984 if (lio->linfo.link.s.link_up)
1985 if_link_state_change(ifp, LINK_STATE_UP);
1987 if_link_state_change(ifp, LINK_STATE_DOWN);
1992 * \brief Callback for rx ctrl
1993 * @param status status of request
1994 * @param buf pointer to resp structure
1997 lio_rx_ctl_callback(struct octeon_device *oct, uint32_t status, void *buf)
1999 struct lio_soft_command *sc = (struct lio_soft_command *)buf;
2000 struct lio_rx_ctl_context *ctx;
2002 ctx = (struct lio_rx_ctl_context *)sc->ctxptr;
2004 oct = lio_get_device(ctx->octeon_id);
2006 lio_dev_err(oct, "rx ctl instruction failed. Status: %llx\n",
2007 LIO_CAST64(status));
2011 * This barrier is required to be sure that the response has been
2012 * written fully before waking up the handler
2018 lio_send_rx_ctrl_cmd(struct lio *lio, int start_stop)
2020 struct lio_soft_command *sc;
2021 struct lio_rx_ctl_context *ctx;
2022 union octeon_cmd *ncmd;
2023 struct octeon_device *oct = (struct octeon_device *)lio->oct_dev;
2024 int ctx_size = sizeof(struct lio_rx_ctl_context);
2027 if (oct->props.rx_on == start_stop)
2030 sc = lio_alloc_soft_command(oct, OCTEON_CMD_SIZE, 16, ctx_size);
2034 ncmd = (union octeon_cmd *)sc->virtdptr;
2035 ctx = (struct lio_rx_ctl_context *)sc->ctxptr;
2038 ctx->octeon_id = lio_get_device_id(oct);
2040 ncmd->s.cmd = LIO_CMD_RX_CTL;
2041 ncmd->s.param1 = start_stop;
2043 lio_swap_8B_data((uint64_t *)ncmd, (OCTEON_CMD_SIZE >> 3));
2045 sc->iq_no = lio->linfo.txpciq[0].s.q_no;
2047 lio_prepare_soft_command(oct, sc, LIO_OPCODE_NIC, LIO_OPCODE_NIC_CMD, 0,
2050 sc->callback = lio_rx_ctl_callback;
2051 sc->callback_arg = sc;
2052 sc->wait_time = 5000;
2054 retval = lio_send_soft_command(oct, sc);
2055 if (retval == LIO_IQ_SEND_FAILED) {
2056 lio_dev_err(oct, "Failed to send RX Control message\n");
2059 * Sleep on a wait queue till the cond flag indicates that the
2060 * response arrived or timed-out.
2062 lio_sleep_cond(oct, &ctx->cond);
2063 oct->props.rx_on = start_stop;
2066 lio_free_soft_command(oct, sc);
2070 lio_vlan_rx_add_vid(void *arg, struct ifnet *ifp, uint16_t vid)
2072 struct lio_ctrl_pkt nctrl;
2073 struct lio *lio = if_getsoftc(ifp);
2074 struct octeon_device *oct = lio->oct_dev;
2077 if (if_getsoftc(ifp) != arg) /* Not our event */
2080 if ((vid == 0) || (vid > 4095)) /* Invalid */
2083 bzero(&nctrl, sizeof(struct lio_ctrl_pkt));
2085 nctrl.ncmd.cmd64 = 0;
2086 nctrl.ncmd.s.cmd = LIO_CMD_ADD_VLAN_FILTER;
2087 nctrl.ncmd.s.param1 = vid;
2088 nctrl.iq_no = lio->linfo.txpciq[0].s.q_no;
2089 nctrl.wait_time = 100;
2091 nctrl.cb_fn = lio_ctrl_cmd_completion;
2093 ret = lio_send_ctrl_pkt(lio->oct_dev, &nctrl);
2095 lio_dev_err(oct, "Add VLAN filter failed in core (ret: 0x%x)\n",
2101 lio_vlan_rx_kill_vid(void *arg, struct ifnet *ifp, uint16_t vid)
2103 struct lio_ctrl_pkt nctrl;
2104 struct lio *lio = if_getsoftc(ifp);
2105 struct octeon_device *oct = lio->oct_dev;
2108 if (if_getsoftc(ifp) != arg) /* Not our event */
2111 if ((vid == 0) || (vid > 4095)) /* Invalid */
2114 bzero(&nctrl, sizeof(struct lio_ctrl_pkt));
2116 nctrl.ncmd.cmd64 = 0;
2117 nctrl.ncmd.s.cmd = LIO_CMD_DEL_VLAN_FILTER;
2118 nctrl.ncmd.s.param1 = vid;
2119 nctrl.iq_no = lio->linfo.txpciq[0].s.q_no;
2120 nctrl.wait_time = 100;
2122 nctrl.cb_fn = lio_ctrl_cmd_completion;
2124 ret = lio_send_ctrl_pkt(lio->oct_dev, &nctrl);
2127 "Kill VLAN filter failed in core (ret: 0x%x)\n",
2133 lio_wait_for_oq_pkts(struct octeon_device *oct)
2135 int i, pending_pkts, pkt_cnt = 0, retry = 100;
2140 for (i = 0; i < LIO_MAX_OUTPUT_QUEUES(oct); i++) {
2141 if (!(oct->io_qmask.oq & BIT_ULL(i)))
2144 pkt_cnt = lio_droq_check_hw_for_pkts(oct->droq[i]);
2146 pending_pkts += pkt_cnt;
2147 taskqueue_enqueue(oct->droq[i]->droq_taskqueue,
2148 &oct->droq[i]->droq_task);
2153 lio_sleep_timeout(1);
2154 } while (retry-- && pending_pkts);
2160 lio_destroy_resources(struct octeon_device *oct)
2164 switch (atomic_load_acq_int(&oct->status)) {
2165 case LIO_DEV_RUNNING:
2166 case LIO_DEV_CORE_OK:
2167 /* No more instructions will be forwarded. */
2168 atomic_store_rel_int(&oct->status, LIO_DEV_IN_RESET);
2170 oct->app_mode = LIO_DRV_INVALID_APP;
2171 lio_dev_dbg(oct, "Device state is now %s\n",
2172 lio_get_state_string(&oct->status));
2174 lio_sleep_timeout(100);
2177 case LIO_DEV_HOST_OK:
2180 case LIO_DEV_CONSOLE_INIT_DONE:
2181 /* Remove any consoles */
2182 lio_remove_consoles(oct);
2185 case LIO_DEV_IO_QUEUES_DONE:
2186 if (lio_wait_for_pending_requests(oct))
2187 lio_dev_err(oct, "There were pending requests\n");
2189 if (lio_wait_for_instr_fetch(oct))
2190 lio_dev_err(oct, "IQ had pending instructions\n");
2193 * Disable the input and output queues now. No more packets will
2194 * arrive from Octeon, but we should wait for all packet
2195 * processing to finish.
2197 oct->fn_list.disable_io_queues(oct);
2199 if (lio_wait_for_oq_pkts(oct))
2200 lio_dev_err(oct, "OQ had pending packets\n");
2203 case LIO_DEV_INTR_SET_DONE:
2204 /* Disable interrupts */
2205 oct->fn_list.disable_interrupt(oct, OCTEON_ALL_INTR);
2208 for (i = 0; i < oct->num_msix_irqs - 1; i++) {
2209 if (oct->ioq_vector[i].tag != NULL) {
2210 bus_teardown_intr(oct->device,
2211 oct->ioq_vector[i].msix_res,
2212 oct->ioq_vector[i].tag);
2213 oct->ioq_vector[i].tag = NULL;
2215 if (oct->ioq_vector[i].msix_res != NULL) {
2216 bus_release_resource(oct->device,
2218 oct->ioq_vector[i].vector,
2219 oct->ioq_vector[i].msix_res);
2220 oct->ioq_vector[i].msix_res = NULL;
2223 /* non-iov vector's argument is oct struct */
2224 if (oct->tag != NULL) {
2225 bus_teardown_intr(oct->device, oct->msix_res,
2230 if (oct->msix_res != NULL) {
2231 bus_release_resource(oct->device, SYS_RES_IRQ,
2234 oct->msix_res = NULL;
2237 pci_release_msi(oct->device);
2240 case LIO_DEV_IN_RESET:
2241 case LIO_DEV_DROQ_INIT_DONE:
2242 /* Wait for any pending operations */
2244 for (i = 0; i < LIO_MAX_OUTPUT_QUEUES(oct); i++) {
2245 if (!(oct->io_qmask.oq & BIT_ULL(i)))
2247 lio_delete_droq(oct, i);
2251 case LIO_DEV_RESP_LIST_INIT_DONE:
2252 for (i = 0; i < LIO_MAX_POSSIBLE_OUTPUT_QUEUES; i++) {
2253 if (oct->droq[i] != NULL) {
2254 free(oct->droq[i], M_DEVBUF);
2255 oct->droq[i] = NULL;
2258 lio_delete_response_list(oct);
2261 case LIO_DEV_INSTR_QUEUE_INIT_DONE:
2262 for (i = 0; i < LIO_MAX_INSTR_QUEUES(oct); i++) {
2263 if (!(oct->io_qmask.iq & BIT_ULL(i)))
2266 lio_delete_instr_queue(oct, i);
2270 case LIO_DEV_MSIX_ALLOC_VECTOR_DONE:
2271 for (i = 0; i < LIO_MAX_POSSIBLE_INSTR_QUEUES; i++) {
2272 if (oct->instr_queue[i] != NULL) {
2273 free(oct->instr_queue[i], M_DEVBUF);
2274 oct->instr_queue[i] = NULL;
2277 lio_free_ioq_vector(oct);
2280 case LIO_DEV_SC_BUFF_POOL_INIT_DONE:
2281 lio_free_sc_buffer_pool(oct);
2284 case LIO_DEV_DISPATCH_INIT_DONE:
2285 lio_delete_dispatch_list(oct);
2288 case LIO_DEV_PCI_MAP_DONE:
2289 refcount = lio_deregister_device(oct);
2291 if (fw_type_is_none())
2295 oct->fn_list.soft_reset(oct);
2297 lio_unmap_pci_barx(oct, 0);
2298 lio_unmap_pci_barx(oct, 1);
2301 case LIO_DEV_PCI_ENABLE_DONE:
2302 /* Disable the device, releasing the PCI INT */
2303 pci_disable_busmaster(oct->device);
2306 case LIO_DEV_BEGIN_STATE:
2308 } /* end switch (oct->status) */