1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2010 QLogic Corporation. All rights reserved.
24 */
25
26 #include <qlge.h>
27 #include <sys/atomic.h>
28 #include <sys/strsubr.h>
29 #include <sys/pattr.h>
30 #include <netinet/in.h>
31 #include <netinet/ip.h>
32 #include <netinet/ip6.h>
33 #include <netinet/tcp.h>
34 #include <netinet/udp.h>
35 #include <inet/ip.h>
36
37
38
39 /*
40 * Local variables
41 */
42 static struct ether_addr ql_ether_broadcast_addr =
43 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
44 static char version[] = "GLDv3 QLogic 81XX " VERSIONSTR;
45
46 /*
47 * Local function prototypes
48 */
49 static void ql_free_resources(qlge_t *);
50 static void ql_fini_kstats(qlge_t *);
51 static uint32_t ql_get_link_state(qlge_t *);
52 static void ql_read_conf(qlge_t *);
53 static int ql_alloc_phys(dev_info_t *, ddi_dma_handle_t *,
54 ddi_device_acc_attr_t *, uint_t, ddi_acc_handle_t *,
55 size_t, size_t, caddr_t *, ddi_dma_cookie_t *);
56 static int ql_alloc_phys_rbuf(dev_info_t *, ddi_dma_handle_t *,
57 ddi_device_acc_attr_t *, uint_t, ddi_acc_handle_t *,
58 size_t, size_t, caddr_t *, ddi_dma_cookie_t *);
59 static void ql_free_phys(ddi_dma_handle_t *, ddi_acc_handle_t *);
60 static int ql_set_routing_reg(qlge_t *, uint32_t, uint32_t, int);
61 static int ql_attach(dev_info_t *, ddi_attach_cmd_t);
62 static int ql_detach(dev_info_t *, ddi_detach_cmd_t);
63 static int ql_bringdown_adapter(qlge_t *);
64 static int ql_bringup_adapter(qlge_t *);
65 static int ql_asic_reset(qlge_t *);
66 static void ql_wake_mpi_reset_soft_intr(qlge_t *);
67 static void ql_stop_timer(qlge_t *qlge);
68 static void ql_fm_fini(qlge_t *qlge);
69 int ql_clean_outbound_rx_ring(struct rx_ring *rx_ring);
70
71 /*
72 * TX dma maping handlers allow multiple sscatter-gather lists
73 */
74 ddi_dma_attr_t tx_mapping_dma_attr = {
75 DMA_ATTR_V0, /* dma_attr_version */
76 QL_DMA_LOW_ADDRESS, /* low DMA address range */
77 QL_DMA_HIGH_64BIT_ADDRESS, /* high DMA address range */
78 QL_DMA_XFER_COUNTER, /* DMA counter register */
79 QL_DMA_ADDRESS_ALIGNMENT, /* DMA address alignment, default - 8 */
80 QL_DMA_BURSTSIZES, /* DMA burstsizes */
81 QL_DMA_MIN_XFER_SIZE, /* min effective DMA size */
82 QL_DMA_MAX_XFER_SIZE, /* max DMA xfer size */
83 QL_DMA_SEGMENT_BOUNDARY, /* segment boundary */
84 QL_MAX_TX_DMA_HANDLES, /* s/g list length */
85 QL_DMA_GRANULARITY, /* granularity of device */
86 DDI_DMA_RELAXED_ORDERING /* DMA transfer flags */
87 };
88
89 /*
90 * Receive buffers and Request/Response queues do not allow scatter-gather lists
91 */
92 ddi_dma_attr_t dma_attr = {
93 DMA_ATTR_V0, /* dma_attr_version */
94 QL_DMA_LOW_ADDRESS, /* low DMA address range */
95 QL_DMA_HIGH_64BIT_ADDRESS, /* high DMA address range */
96 QL_DMA_XFER_COUNTER, /* DMA counter register */
97 QL_DMA_ADDRESS_ALIGNMENT, /* DMA address alignment, default - 8 */
98 QL_DMA_BURSTSIZES, /* DMA burstsizes */
99 QL_DMA_MIN_XFER_SIZE, /* min effective DMA size */
100 QL_DMA_MAX_XFER_SIZE, /* max DMA xfer size */
101 QL_DMA_SEGMENT_BOUNDARY, /* segment boundary */
102 1, /* s/g list length, i.e no sg list */
103 QL_DMA_GRANULARITY, /* granularity of device */
104 QL_DMA_XFER_FLAGS /* DMA transfer flags */
105 };
106 /*
107 * Receive buffers do not allow scatter-gather lists
108 */
109 ddi_dma_attr_t dma_attr_rbuf = {
110 DMA_ATTR_V0, /* dma_attr_version */
111 QL_DMA_LOW_ADDRESS, /* low DMA address range */
112 QL_DMA_HIGH_64BIT_ADDRESS, /* high DMA address range */
113 QL_DMA_XFER_COUNTER, /* DMA counter register */
114 0x1, /* DMA address alignment, default - 8 */
115 QL_DMA_BURSTSIZES, /* DMA burstsizes */
116 QL_DMA_MIN_XFER_SIZE, /* min effective DMA size */
117 QL_DMA_MAX_XFER_SIZE, /* max DMA xfer size */
118 QL_DMA_SEGMENT_BOUNDARY, /* segment boundary */
119 1, /* s/g list length, i.e no sg list */
120 QL_DMA_GRANULARITY, /* granularity of device */
121 DDI_DMA_RELAXED_ORDERING /* DMA transfer flags */
122 };
123 /*
124 * DMA access attribute structure.
125 */
126 /* device register access from host */
127 ddi_device_acc_attr_t ql_dev_acc_attr = {
128 DDI_DEVICE_ATTR_V0,
129 DDI_STRUCTURE_LE_ACC,
130 DDI_STRICTORDER_ACC
131 };
132
133 /* host ring descriptors */
134 ddi_device_acc_attr_t ql_desc_acc_attr = {
135 DDI_DEVICE_ATTR_V0,
136 DDI_NEVERSWAP_ACC,
137 DDI_STRICTORDER_ACC
138 };
139
140 /* host ring buffer */
141 ddi_device_acc_attr_t ql_buf_acc_attr = {
142 DDI_DEVICE_ATTR_V0,
143 DDI_NEVERSWAP_ACC,
144 DDI_STRICTORDER_ACC
145 };
146
147 /*
148 * Hash key table for Receive Side Scaling (RSS) support
149 */
150 const uint8_t key_data[] = {
151 0x23, 0x64, 0xa1, 0xaa, 0x37, 0xc0, 0xed, 0x05, 0x2b, 0x36,
152 0x50, 0x5c, 0x45, 0x1e, 0x7e, 0xc8, 0x5d, 0x2a, 0x54, 0x2f,
153 0xe4, 0x3d, 0x0f, 0xbb, 0x91, 0xd9, 0x25, 0x60, 0xd4, 0xf8,
154 0x12, 0xa0, 0x59, 0x4b, 0x9e, 0x8a, 0x51, 0xda, 0xcd, 0x49};
155
156 /*
157 * Shadow Registers:
158 * Outbound queues have a consumer index that is maintained by the chip.
159 * Inbound queues have a producer index that is maintained by the chip.
160 * For lower overhead, these registers are "shadowed" to host memory
161 * which allows the device driver to track the queue progress without
162 * PCI reads. When an entry is placed on an inbound queue, the chip will
163 * update the relevant index register and then copy the value to the
164 * shadow register in host memory.
165 * Currently, ql_read_sh_reg only read Inbound queues'producer index.
166 */
167
168 static inline unsigned int
169 ql_read_sh_reg(qlge_t *qlge, struct rx_ring *rx_ring)
170 {
171 uint32_t rtn;
172
173 /* re-synchronize shadow prod index dma buffer before reading */
174 (void) ddi_dma_sync(qlge->host_copy_shadow_dma_attr.dma_handle,
175 rx_ring->prod_idx_sh_reg_offset,
176 sizeof (uint32_t), DDI_DMA_SYNC_FORKERNEL);
177
178 rtn = ddi_get32(qlge->host_copy_shadow_dma_attr.acc_handle,
179 (uint32_t *)rx_ring->prod_idx_sh_reg);
180
181 return (rtn);
182 }
183
184 /*
185 * Read 32 bit atomically
186 */
187 uint32_t
188 ql_atomic_read_32(volatile uint32_t *target)
189 {
190 /*
191 * atomic_add_32_nv returns the new value after the add,
192 * we are adding 0 so we should get the original value
193 */
194 return (atomic_add_32_nv(target, 0));
195 }
196
197 /*
198 * Set 32 bit atomically
199 */
200 void
201 ql_atomic_set_32(volatile uint32_t *target, uint32_t newval)
202 {
203 (void) atomic_swap_32(target, newval);
204 }
205
206
207 /*
208 * Setup device PCI configuration registers.
209 * Kernel context.
210 */
211 static void
212 ql_pci_config(qlge_t *qlge)
213 {
214 uint16_t w;
215
216 qlge->vendor_id = (uint16_t)pci_config_get16(qlge->pci_handle,
217 PCI_CONF_VENID);
218 qlge->device_id = (uint16_t)pci_config_get16(qlge->pci_handle,
219 PCI_CONF_DEVID);
220
221 /*
222 * we want to respect framework's setting of PCI
223 * configuration space command register and also
224 * want to make sure that all bits of interest to us
225 * are properly set in PCI Command register(0x04).
226 * PCI_COMM_IO 0x1 I/O access enable
227 * PCI_COMM_MAE 0x2 Memory access enable
228 * PCI_COMM_ME 0x4 bus master enable
229 * PCI_COMM_MEMWR_INVAL 0x10 memory write and invalidate enable.
230 */
231 w = (uint16_t)pci_config_get16(qlge->pci_handle, PCI_CONF_COMM);
232 w = (uint16_t)(w & (~PCI_COMM_IO));
233 w = (uint16_t)(w | PCI_COMM_MAE | PCI_COMM_ME |
234 /* PCI_COMM_MEMWR_INVAL | */
235 PCI_COMM_PARITY_DETECT | PCI_COMM_SERR_ENABLE);
236
237 pci_config_put16(qlge->pci_handle, PCI_CONF_COMM, w);
238
239 w = pci_config_get16(qlge->pci_handle, 0x54);
240 w = (uint16_t)(w & (~0x7000));
241 w = (uint16_t)(w | 0x5000);
242 pci_config_put16(qlge->pci_handle, 0x54, w);
243
244 ql_dump_pci_config(qlge);
245 }
246
247 /*
248 * This routine parforms the neccessary steps to set GLD mac information
249 * such as Function number, xgmac mask and shift bits
250 */
251 static int
252 ql_set_mac_info(qlge_t *qlge)
253 {
254 uint32_t value;
255 int rval = DDI_FAILURE;
256 uint32_t fn0_net, fn1_net;
257
258 /* set default value */
259 qlge->fn0_net = FN0_NET;
260 qlge->fn1_net = FN1_NET;
261
262 if (ql_read_processor_data(qlge, MPI_REG, &value) != DDI_SUCCESS) {
263 cmn_err(CE_WARN, "%s(%d) read MPI register failed",
264 __func__, qlge->instance);
265 goto exit;
266 } else {
267 fn0_net = (value >> 1) & 0x07;
268 fn1_net = (value >> 5) & 0x07;
269 if ((fn0_net > 4) || (fn1_net > 4) || (fn0_net == fn1_net)) {
270 cmn_err(CE_WARN, "%s(%d) bad mpi register value %x, \n"
271 "nic0 function number %d,"
272 "nic1 function number %d "
273 "use default\n",
274 __func__, qlge->instance, value, fn0_net, fn1_net);
275 goto exit;
276 } else {
277 qlge->fn0_net = fn0_net;
278 qlge->fn1_net = fn1_net;
279 }
280 }
281
282 /* Get the function number that the driver is associated with */
283 value = ql_read_reg(qlge, REG_STATUS);
284 qlge->func_number = (uint8_t)((value >> 6) & 0x03);
285 QL_PRINT(DBG_INIT, ("status register is:%x, func_number: %d\n",
286 value, qlge->func_number));
287
288 /* The driver is loaded on a non-NIC function? */
289 if ((qlge->func_number != qlge->fn0_net) &&
290 (qlge->func_number != qlge->fn1_net)) {
291 cmn_err(CE_WARN,
292 "Invalid function number = 0x%x\n", qlge->func_number);
293 goto exit;
294 }
295 /* network port 0? */
296 if (qlge->func_number == qlge->fn0_net) {
297 qlge->xgmac_sem_mask = QL_PORT0_XGMAC_SEM_MASK;
298 qlge->xgmac_sem_bits = QL_PORT0_XGMAC_SEM_BITS;
299 } else {
300 qlge->xgmac_sem_mask = QL_PORT1_XGMAC_SEM_MASK;
301 qlge->xgmac_sem_bits = QL_PORT1_XGMAC_SEM_BITS;
302 }
303 rval = DDI_SUCCESS;
304 exit:
305 return (rval);
306
307 }
308
309 /*
310 * write to doorbell register
311 */
312 void
313 ql_write_doorbell_reg(qlge_t *qlge, uint32_t *addr, uint32_t data)
314 {
315 ddi_put32(qlge->dev_doorbell_reg_handle, addr, data);
316 }
317
318 /*
319 * read from doorbell register
320 */
321 uint32_t
322 ql_read_doorbell_reg(qlge_t *qlge, uint32_t *addr)
323 {
324 uint32_t ret;
325
326 ret = ddi_get32(qlge->dev_doorbell_reg_handle, addr);
327
328 return (ret);
329 }
330
331 /*
332 * This function waits for a specific bit to come ready
333 * in a given register. It is used mostly by the initialize
334 * process, but is also used in kernel thread API such as
335 * netdev->set_multi, netdev->set_mac_address, netdev->vlan_rx_add_vid.
336 */
337 static int
338 ql_wait_reg_rdy(qlge_t *qlge, uint32_t reg, uint32_t bit, uint32_t err_bit)
339 {
340 uint32_t temp;
341 int count = UDELAY_COUNT;
342
343 while (count) {
344 temp = ql_read_reg(qlge, reg);
345
346 /* check for errors */
347 if ((temp & err_bit) != 0) {
348 break;
349 } else if ((temp & bit) != 0)
350 return (DDI_SUCCESS);
351 qlge_delay(UDELAY_DELAY);
352 count--;
353 }
354 cmn_err(CE_WARN,
355 "Waiting for reg %x to come ready failed.", reg);
356 if (qlge->fm_enable) {
357 ql_fm_ereport(qlge, DDI_FM_DEVICE_NO_RESPONSE);
358 atomic_or_32(&qlge->flags, ADAPTER_ERROR);
359 }
360 return (DDI_FAILURE);
361 }
362
363 /*
364 * The CFG register is used to download TX and RX control blocks
365 * to the chip. This function waits for an operation to complete.
366 */
367 static int
368 ql_wait_cfg(qlge_t *qlge, uint32_t bit)
369 {
370 return (ql_wait_reg_bit(qlge, REG_CONFIGURATION, bit, BIT_RESET, 0));
371 }
372
373
374 /*
375 * Used to issue init control blocks to hw. Maps control block,
376 * sets address, triggers download, waits for completion.
377 */
378 static int
379 ql_write_cfg(qlge_t *qlge, uint32_t bit, uint64_t phy_addr, uint16_t q_id)
380 {
381 int status = DDI_SUCCESS;
382 uint32_t mask;
383 uint32_t value;
384
385 status = ql_sem_spinlock(qlge, SEM_ICB_MASK);
386 if (status != DDI_SUCCESS) {
387 goto exit;
388 }
389 status = ql_wait_cfg(qlge, bit);
390 if (status != DDI_SUCCESS) {
391 goto exit;
392 }
393
394 ql_write_reg(qlge, REG_ICB_ACCESS_ADDRESS_LOWER, LS_64BITS(phy_addr));
395 ql_write_reg(qlge, REG_ICB_ACCESS_ADDRESS_UPPER, MS_64BITS(phy_addr));
396
397 mask = CFG_Q_MASK | (bit << 16);
398 value = bit | (q_id << CFG_Q_SHIFT);
399 ql_write_reg(qlge, REG_CONFIGURATION, (mask | value));
400
401 /*
402 * Wait for the bit to clear after signaling hw.
403 */
404 status = ql_wait_cfg(qlge, bit);
405 ql_sem_unlock(qlge, SEM_ICB_MASK); /* does flush too */
406
407 exit:
408 return (status);
409 }
410
411 /*
412 * Initialize adapter instance
413 */
414 static int
415 ql_init_instance(qlge_t *qlge)
416 {
417 int i;
418
419 /* Default value */
420 qlge->mac_flags = QL_MAC_INIT;
421 qlge->mtu = ETHERMTU; /* set normal size as default */
422 qlge->page_size = VM_PAGE_SIZE; /* default page size */
423
424 for (i = 0; i < MAX_RX_RINGS; i++) {
425 qlge->rx_polls[i] = 0;
426 qlge->rx_interrupts[i] = 0;
427 }
428
429 /*
430 * Set up the operating parameters.
431 */
432 qlge->multicast_list_count = 0;
433
434 /*
435 * Set up the max number of unicast list
436 */
437 qlge->unicst_total = MAX_UNICAST_LIST_SIZE;
438 qlge->unicst_avail = MAX_UNICAST_LIST_SIZE;
439
440 /*
441 * read user defined properties in .conf file
442 */
443 ql_read_conf(qlge); /* mtu, pause, LSO etc */
444 qlge->rx_ring_count = qlge->tx_ring_count + qlge->rss_ring_count;
445
446 QL_PRINT(DBG_INIT, ("mtu is %d \n", qlge->mtu));
447
448 /* choose Memory Space mapping and get Vendor Id, Device ID etc */
449 ql_pci_config(qlge);
450 qlge->ip_hdr_offset = 0;
451
452 if (qlge->device_id == 0x8000) {
453 /* Schultz card */
454 qlge->cfg_flags |= CFG_CHIP_8100;
455 /* enable just ipv4 chksum offload for Schultz */
456 qlge->cfg_flags |= CFG_CKSUM_FULL_IPv4;
457 /*
458 * Schultz firmware does not do pseduo IP header checksum
459 * calculation, needed to be done by driver
460 */
461 qlge->cfg_flags |= CFG_HW_UNABLE_PSEUDO_HDR_CKSUM;
462 if (qlge->lso_enable)
463 qlge->cfg_flags |= CFG_LSO;
464 qlge->cfg_flags |= CFG_SUPPORT_SCATTER_GATHER;
465 /* Schultz must split packet header */
466 qlge->cfg_flags |= CFG_ENABLE_SPLIT_HEADER;
467 qlge->max_read_mbx = 5;
468 qlge->ip_hdr_offset = 2;
469 }
470
471 /* Set Function Number and some of the iocb mac information */
472 if (ql_set_mac_info(qlge) != DDI_SUCCESS)
473 return (DDI_FAILURE);
474
475 /* Read network settings from NVRAM */
476 /* After nvram is read successfully, update dev_addr */
477 if (ql_get_flash_params(qlge) == DDI_SUCCESS) {
478 QL_PRINT(DBG_INIT, ("mac%d address is \n", qlge->func_number));
479 for (i = 0; i < ETHERADDRL; i++) {
480 qlge->dev_addr.ether_addr_octet[i] =
481 qlge->nic_config.factory_MAC[i];
482 }
483 } else {
484 cmn_err(CE_WARN, "%s(%d): Failed to read flash memory",
485 __func__, qlge->instance);
486 return (DDI_FAILURE);
487 }
488
489 bcopy(qlge->dev_addr.ether_addr_octet,
490 qlge->unicst_addr[0].addr.ether_addr_octet,
491 ETHERADDRL);
492 QL_DUMP(DBG_INIT, "\t flash mac address dump:\n",
493 &qlge->dev_addr.ether_addr_octet[0], 8, ETHERADDRL);
494
495 qlge->port_link_state = LS_DOWN;
496
497 return (DDI_SUCCESS);
498 }
499
500
501 /*
502 * This hardware semaphore provides the mechanism for exclusive access to
503 * resources shared between the NIC driver, MPI firmware,
504 * FCOE firmware and the FC driver.
505 */
506 static int
507 ql_sem_trylock(qlge_t *qlge, uint32_t sem_mask)
508 {
509 uint32_t sem_bits = 0;
510
511 switch (sem_mask) {
512 case SEM_XGMAC0_MASK:
513 sem_bits = SEM_SET << SEM_XGMAC0_SHIFT;
514 break;
515 case SEM_XGMAC1_MASK:
516 sem_bits = SEM_SET << SEM_XGMAC1_SHIFT;
517 break;
518 case SEM_ICB_MASK:
519 sem_bits = SEM_SET << SEM_ICB_SHIFT;
520 break;
521 case SEM_MAC_ADDR_MASK:
522 sem_bits = SEM_SET << SEM_MAC_ADDR_SHIFT;
523 break;
524 case SEM_FLASH_MASK:
525 sem_bits = SEM_SET << SEM_FLASH_SHIFT;
526 break;
527 case SEM_PROBE_MASK:
528 sem_bits = SEM_SET << SEM_PROBE_SHIFT;
529 break;
530 case SEM_RT_IDX_MASK:
531 sem_bits = SEM_SET << SEM_RT_IDX_SHIFT;
532 break;
533 case SEM_PROC_REG_MASK:
534 sem_bits = SEM_SET << SEM_PROC_REG_SHIFT;
535 break;
536 default:
537 cmn_err(CE_WARN, "Bad Semaphore mask!.");
538 return (DDI_FAILURE);
539 }
540
541 ql_write_reg(qlge, REG_SEMAPHORE, sem_bits | sem_mask);
542 return (!(ql_read_reg(qlge, REG_SEMAPHORE) & sem_bits));
543 }
544
545 /*
546 * Lock a specific bit of Semaphore register to gain
547 * access to a particular shared register
548 */
549 int
550 ql_sem_spinlock(qlge_t *qlge, uint32_t sem_mask)
551 {
552 unsigned int wait_count = 30;
553
554 while (wait_count) {
555 if (!ql_sem_trylock(qlge, sem_mask))
556 return (DDI_SUCCESS);
557 qlge_delay(100);
558 wait_count--;
559 }
560 cmn_err(CE_WARN, "%s(%d) sem_mask 0x%x lock timeout ",
561 __func__, qlge->instance, sem_mask);
562 return (DDI_FAILURE);
563 }
564
565 /*
566 * Unock a specific bit of Semaphore register to release
567 * access to a particular shared register
568 */
569 void
570 ql_sem_unlock(qlge_t *qlge, uint32_t sem_mask)
571 {
572 ql_write_reg(qlge, REG_SEMAPHORE, sem_mask);
573 (void) ql_read_reg(qlge, REG_SEMAPHORE); /* flush */
574 }
575
576 /*
577 * Get property value from configuration file.
578 *
579 * string = property string pointer.
580 *
581 * Returns:
582 * 0xFFFFFFFF = no property else property value.
583 */
584 static uint32_t
585 ql_get_prop(qlge_t *qlge, char *string)
586 {
587 char buf[256];
588 uint32_t data;
589
590 /* Get adapter instance parameter. */
591 (void) sprintf(buf, "hba%d-%s", qlge->instance, string);
592 data = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, qlge->dip, 0, buf,
593 (int)0xffffffff);
594
595 /* Adapter instance parameter found? */
596 if (data == 0xffffffff) {
597 /* No, get default parameter. */
598 data = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, qlge->dip, 0,
599 string, (int)0xffffffff);
600 }
601
602 return (data);
603 }
604
605 /*
606 * Read user setting from configuration file.
607 */
608 static void
609 ql_read_conf(qlge_t *qlge)
610 {
611 uint32_t data;
612
613 /* clear configuration flags */
614 qlge->cfg_flags = 0;
615
616 /* Set up the default ring sizes. */
617 qlge->tx_ring_size = NUM_TX_RING_ENTRIES;
618 data = ql_get_prop(qlge, "tx_ring_size");
619 /* if data is valid */
620 if ((data != 0xffffffff) && data) {
621 if (qlge->tx_ring_size != data) {
622 qlge->tx_ring_size = (uint16_t)data;
623 }
624 }
625
626 qlge->rx_ring_size = NUM_RX_RING_ENTRIES;
627 data = ql_get_prop(qlge, "rx_ring_size");
628 /* if data is valid */
629 if ((data != 0xffffffff) && data) {
630 if (qlge->rx_ring_size != data) {
631 qlge->rx_ring_size = (uint16_t)data;
632 }
633 }
634
635 qlge->tx_ring_count = 8;
636 data = ql_get_prop(qlge, "tx_ring_count");
637 /* if data is valid */
638 if ((data != 0xffffffff) && data) {
639 if (qlge->tx_ring_count != data) {
640 qlge->tx_ring_count = (uint16_t)data;
641 }
642 }
643
644 qlge->rss_ring_count = 8;
645 data = ql_get_prop(qlge, "rss_ring_count");
646 /* if data is valid */
647 if ((data != 0xffffffff) && data) {
648 if (qlge->rss_ring_count != data) {
649 qlge->rss_ring_count = (uint16_t)data;
650 }
651 }
652
653 /* Get default rx_copy enable/disable. */
654 if ((data = ql_get_prop(qlge, "force-rx-copy")) == 0xffffffff ||
655 data == 0) {
656 qlge->rx_copy = B_FALSE;
657 QL_PRINT(DBG_INIT, ("rx copy mode disabled\n"));
658 } else if (data == 1) {
659 qlge->rx_copy = B_TRUE;
660 QL_PRINT(DBG_INIT, ("rx copy mode enabled\n"));
661 }
662
663 qlge->rx_copy_threshold = qlge->rx_ring_size / 4;
664 data = ql_get_prop(qlge, "rx_copy_threshold");
665 if ((data != 0xffffffff) && (data != 0)) {
666 qlge->rx_copy_threshold = data;
667 cmn_err(CE_NOTE, "!new rx_copy_threshold %d \n",
668 qlge->rx_copy_threshold);
669 }
670
671 /* Get mtu packet size. */
672 data = ql_get_prop(qlge, "mtu");
673 if ((data == ETHERMTU) || (data == JUMBO_MTU)) {
674 if (qlge->mtu != data) {
675 qlge->mtu = data;
676 cmn_err(CE_NOTE, "new mtu is %d\n", qlge->mtu);
677 }
678 }
679
680 if (qlge->mtu == JUMBO_MTU) {
681 qlge->rx_coalesce_usecs = DFLT_RX_COALESCE_WAIT_JUMBO;
682 qlge->tx_coalesce_usecs = DFLT_TX_COALESCE_WAIT_JUMBO;
683 qlge->rx_max_coalesced_frames = DFLT_RX_INTER_FRAME_WAIT_JUMBO;
684 qlge->tx_max_coalesced_frames = DFLT_TX_INTER_FRAME_WAIT_JUMBO;
685 }
686
687
688 /* Get pause mode, default is Per Priority mode. */
689 qlge->pause = PAUSE_MODE_PER_PRIORITY;
690 data = ql_get_prop(qlge, "pause");
691 if (data <= PAUSE_MODE_PER_PRIORITY) {
692 if (qlge->pause != data) {
693 qlge->pause = data;
694 cmn_err(CE_NOTE, "new pause mode %d\n", qlge->pause);
695 }
696 }
697 /* Receive interrupt delay */
698 qlge->rx_coalesce_usecs = DFLT_RX_COALESCE_WAIT;
699 data = ql_get_prop(qlge, "rx_intr_delay");
700 /* if data is valid */
701 if ((data != 0xffffffff) && data) {
702 if (qlge->rx_coalesce_usecs != data) {
703 qlge->rx_coalesce_usecs = (uint16_t)data;
704 }
705 }
706 /* Rx inter-packet delay. */
707 qlge->rx_max_coalesced_frames = DFLT_RX_INTER_FRAME_WAIT;
708 data = ql_get_prop(qlge, "rx_ipkt_delay");
709 /* if data is valid */
710 if ((data != 0xffffffff) && data) {
711 if (qlge->rx_max_coalesced_frames != data) {
712 qlge->rx_max_coalesced_frames = (uint16_t)data;
713 }
714 }
715 /* Transmit interrupt delay */
716 qlge->tx_coalesce_usecs = DFLT_TX_COALESCE_WAIT;
717 data = ql_get_prop(qlge, "tx_intr_delay");
718 /* if data is valid */
719 if ((data != 0xffffffff) && data) {
720 if (qlge->tx_coalesce_usecs != data) {
721 qlge->tx_coalesce_usecs = (uint16_t)data;
722 }
723 }
724 /* Tx inter-packet delay. */
725 qlge->tx_max_coalesced_frames = DFLT_TX_INTER_FRAME_WAIT;
726 data = ql_get_prop(qlge, "tx_ipkt_delay");
727 /* if data is valid */
728 if ((data != 0xffffffff) && data) {
729 if (qlge->tx_max_coalesced_frames != data) {
730 qlge->tx_max_coalesced_frames = (uint16_t)data;
731 }
732 }
733
734 /* Get split header payload_copy_thresh. */
735 qlge->payload_copy_thresh = DFLT_PAYLOAD_COPY_THRESH;
736 data = ql_get_prop(qlge, "payload_copy_thresh");
737 /* if data is valid */
738 if ((data != 0xffffffff) && (data != 0)) {
739 if (qlge->payload_copy_thresh != data) {
740 qlge->payload_copy_thresh = data;
741 }
742 }
743
744 /* large send offload (LSO) capability. */
745 qlge->lso_enable = 1;
746 data = ql_get_prop(qlge, "lso_enable");
747 /* if data is valid */
748 if ((data == 0) || (data == 1)) {
749 if (qlge->lso_enable != data) {
750 qlge->lso_enable = (uint16_t)data;
751 }
752 }
753
754 /* dcbx capability. */
755 qlge->dcbx_enable = 1;
756 data = ql_get_prop(qlge, "dcbx_enable");
757 /* if data is valid */
758 if ((data == 0) || (data == 1)) {
759 if (qlge->dcbx_enable != data) {
760 qlge->dcbx_enable = (uint16_t)data;
761 }
762 }
763 /* fault management enable */
764 qlge->fm_enable = B_TRUE;
765 data = ql_get_prop(qlge, "fm-enable");
766 if ((data == 0x1) || (data == 0)) {
767 qlge->fm_enable = (boolean_t)data;
768 }
769
770 }
771
772 /*
773 * Enable global interrupt
774 */
775 static void
776 ql_enable_global_interrupt(qlge_t *qlge)
777 {
778 ql_write_reg(qlge, REG_INTERRUPT_ENABLE,
779 (INTR_EN_EI << 16) | INTR_EN_EI);
780 qlge->flags |= INTERRUPTS_ENABLED;
781 }
782
783 /*
784 * Disable global interrupt
785 */
786 static void
787 ql_disable_global_interrupt(qlge_t *qlge)
788 {
789 ql_write_reg(qlge, REG_INTERRUPT_ENABLE, (INTR_EN_EI << 16));
790 qlge->flags &= ~INTERRUPTS_ENABLED;
791 }
792
793 /*
794 * Enable one ring interrupt
795 */
796 void
797 ql_enable_completion_interrupt(qlge_t *qlge, uint32_t intr)
798 {
799 struct intr_ctx *ctx = qlge->intr_ctx + intr;
800
801 QL_PRINT(DBG_INTR, ("%s(%d): To enable intr %d, irq_cnt %d \n",
802 __func__, qlge->instance, intr, ctx->irq_cnt));
803
804 if ((qlge->intr_type == DDI_INTR_TYPE_MSIX) && intr) {
805 /*
806 * Always enable if we're MSIX multi interrupts and
807 * it's not the default (zeroeth) interrupt.
808 */
809 ql_write_reg(qlge, REG_INTERRUPT_ENABLE, ctx->intr_en_mask);
810 return;
811 }
812
813 if (!atomic_dec_32_nv(&ctx->irq_cnt)) {
814 mutex_enter(&qlge->hw_mutex);
815 ql_write_reg(qlge, REG_INTERRUPT_ENABLE, ctx->intr_en_mask);
816 mutex_exit(&qlge->hw_mutex);
817 QL_PRINT(DBG_INTR,
818 ("%s(%d): write %x to intr enable register \n",
819 __func__, qlge->instance, ctx->intr_en_mask));
820 }
821 }
822
823 /*
824 * ql_forced_disable_completion_interrupt
825 * Used by call from OS, may be called without
826 * a pending interrupt so force the disable
827 */
828 uint32_t
829 ql_forced_disable_completion_interrupt(qlge_t *qlge, uint32_t intr)
830 {
831 uint32_t var = 0;
832 struct intr_ctx *ctx = qlge->intr_ctx + intr;
833
834 QL_PRINT(DBG_INTR, ("%s(%d): To disable intr %d, irq_cnt %d \n",
835 __func__, qlge->instance, intr, ctx->irq_cnt));
836
837 if ((qlge->intr_type == DDI_INTR_TYPE_MSIX) && intr) {
838 ql_write_reg(qlge, REG_INTERRUPT_ENABLE, ctx->intr_dis_mask);
839 var = ql_read_reg(qlge, REG_STATUS);
840 return (var);
841 }
842
843 mutex_enter(&qlge->hw_mutex);
844 ql_write_reg(qlge, REG_INTERRUPT_ENABLE, ctx->intr_dis_mask);
845 var = ql_read_reg(qlge, REG_STATUS);
846 mutex_exit(&qlge->hw_mutex);
847
848 return (var);
849 }
850
851 /*
852 * Disable a completion interrupt
853 */
854 void
855 ql_disable_completion_interrupt(qlge_t *qlge, uint32_t intr)
856 {
857 struct intr_ctx *ctx;
858
859 ctx = qlge->intr_ctx + intr;
860 QL_PRINT(DBG_INTR, ("%s(%d): To disable intr %d, irq_cnt %d \n",
861 __func__, qlge->instance, intr, ctx->irq_cnt));
862 /*
863 * HW disables for us if we're MSIX multi interrupts and
864 * it's not the default (zeroeth) interrupt.
865 */
866 if ((qlge->intr_type == DDI_INTR_TYPE_MSIX) && (intr != 0))
867 return;
868
869 if (ql_atomic_read_32(&ctx->irq_cnt) == 0) {
870 mutex_enter(&qlge->hw_mutex);
871 ql_write_reg(qlge, REG_INTERRUPT_ENABLE, ctx->intr_dis_mask);
872 mutex_exit(&qlge->hw_mutex);
873 }
874 atomic_inc_32(&ctx->irq_cnt);
875 }
876
877 /*
878 * Enable all completion interrupts
879 */
880 static void
881 ql_enable_all_completion_interrupts(qlge_t *qlge)
882 {
883 int i;
884 uint32_t value = 1;
885
886 for (i = 0; i < qlge->intr_cnt; i++) {
887 /*
888 * Set the count to 1 for Legacy / MSI interrupts or for the
889 * default interrupt (0)
890 */
891 if ((qlge->intr_type != DDI_INTR_TYPE_MSIX) || i == 0) {
892 ql_atomic_set_32(&qlge->intr_ctx[i].irq_cnt, value);
893 }
894 ql_enable_completion_interrupt(qlge, i);
895 }
896 }
897
898 /*
899 * Disable all completion interrupts
900 */
901 static void
902 ql_disable_all_completion_interrupts(qlge_t *qlge)
903 {
904 int i;
905 uint32_t value = 0;
906
907 for (i = 0; i < qlge->intr_cnt; i++) {
908
909 /*
910 * Set the count to 0 for Legacy / MSI interrupts or for the
911 * default interrupt (0)
912 */
913 if ((qlge->intr_type != DDI_INTR_TYPE_MSIX) || i == 0)
914 ql_atomic_set_32(&qlge->intr_ctx[i].irq_cnt, value);
915
916 ql_disable_completion_interrupt(qlge, i);
917 }
918 }
919
920 /*
921 * Update small buffer queue producer index
922 */
923 static void
924 ql_update_sbq_prod_idx(qlge_t *qlge, struct rx_ring *rx_ring)
925 {
926 /* Update the buffer producer index */
927 QL_PRINT(DBG_RX, ("sbq: updating prod idx = %d.\n",
928 rx_ring->sbq_prod_idx));
929 ql_write_doorbell_reg(qlge, rx_ring->sbq_prod_idx_db_reg,
930 rx_ring->sbq_prod_idx);
931 }
932
933 /*
934 * Update large buffer queue producer index
935 */
936 static void
937 ql_update_lbq_prod_idx(qlge_t *qlge, struct rx_ring *rx_ring)
938 {
939 /* Update the buffer producer index */
940 QL_PRINT(DBG_RX, ("lbq: updating prod idx = %d.\n",
941 rx_ring->lbq_prod_idx));
942 ql_write_doorbell_reg(qlge, rx_ring->lbq_prod_idx_db_reg,
943 rx_ring->lbq_prod_idx);
944 }
945
946 /*
947 * Adds a small buffer descriptor to end of its in use list,
948 * assumes sbq_lock is already taken
949 */
950 static void
951 ql_add_sbuf_to_in_use_list(struct rx_ring *rx_ring,
952 struct bq_desc *sbq_desc)
953 {
954 uint32_t inuse_idx = rx_ring->sbq_use_tail;
955
956 rx_ring->sbuf_in_use[inuse_idx] = sbq_desc;
957 inuse_idx++;
958 if (inuse_idx >= rx_ring->sbq_len)
959 inuse_idx = 0;
960 rx_ring->sbq_use_tail = inuse_idx;
961 atomic_inc_32(&rx_ring->sbuf_in_use_count);
962 ASSERT(rx_ring->sbuf_in_use_count <= rx_ring->sbq_len);
963 }
964
965 /*
966 * Get a small buffer descriptor from its in use list
967 */
968 static struct bq_desc *
969 ql_get_sbuf_from_in_use_list(struct rx_ring *rx_ring)
970 {
971 struct bq_desc *sbq_desc = NULL;
972 uint32_t inuse_idx;
973
974 /* Pick from head of in use list */
975 inuse_idx = rx_ring->sbq_use_head;
976 sbq_desc = rx_ring->sbuf_in_use[inuse_idx];
977 rx_ring->sbuf_in_use[inuse_idx] = NULL;
978
979 if (sbq_desc != NULL) {
980 inuse_idx++;
981 if (inuse_idx >= rx_ring->sbq_len)
982 inuse_idx = 0;
983 rx_ring->sbq_use_head = inuse_idx;
984 atomic_dec_32(&rx_ring->sbuf_in_use_count);
985 atomic_inc_32(&rx_ring->rx_indicate);
986 sbq_desc->upl_inuse = 1;
987 /* if mp is NULL */
988 if (sbq_desc->mp == NULL) {
989 /* try to remap mp again */
990 sbq_desc->mp =
991 desballoc((unsigned char *)(sbq_desc->bd_dma.vaddr),
992 rx_ring->sbq_buf_size, 0, &sbq_desc->rx_recycle);
993 }
994 }
995
996 return (sbq_desc);
997 }
998
999 /*
1000 * Add a small buffer descriptor to its free list
1001 */
1002 static void
1003 ql_add_sbuf_to_free_list(struct rx_ring *rx_ring,
1004 struct bq_desc *sbq_desc)
1005 {
1006 uint32_t free_idx;
1007
1008 /* Add to the end of free list */
1009 free_idx = rx_ring->sbq_free_tail;
1010 rx_ring->sbuf_free[free_idx] = sbq_desc;
1011 ASSERT(rx_ring->sbuf_free_count <= rx_ring->sbq_len);
1012 free_idx++;
1013 if (free_idx >= rx_ring->sbq_len)
1014 free_idx = 0;
1015 rx_ring->sbq_free_tail = free_idx;
1016 atomic_inc_32(&rx_ring->sbuf_free_count);
1017 }
1018
1019 /*
1020 * Get a small buffer descriptor from its free list
1021 */
1022 static struct bq_desc *
1023 ql_get_sbuf_from_free_list(struct rx_ring *rx_ring)
1024 {
1025 struct bq_desc *sbq_desc;
1026 uint32_t free_idx;
1027
1028 free_idx = rx_ring->sbq_free_head;
1029 /* Pick from top of free list */
1030 sbq_desc = rx_ring->sbuf_free[free_idx];
1031 rx_ring->sbuf_free[free_idx] = NULL;
1032 if (sbq_desc != NULL) {
1033 free_idx++;
1034 if (free_idx >= rx_ring->sbq_len)
1035 free_idx = 0;
1036 rx_ring->sbq_free_head = free_idx;
1037 atomic_dec_32(&rx_ring->sbuf_free_count);
1038 }
1039 return (sbq_desc);
1040 }
1041
1042 /*
1043 * Add a large buffer descriptor to its in use list
1044 */
1045 static void
1046 ql_add_lbuf_to_in_use_list(struct rx_ring *rx_ring,
1047 struct bq_desc *lbq_desc)
1048 {
1049 uint32_t inuse_idx;
1050
1051 inuse_idx = rx_ring->lbq_use_tail;
1052
1053 rx_ring->lbuf_in_use[inuse_idx] = lbq_desc;
1054 inuse_idx++;
1055 if (inuse_idx >= rx_ring->lbq_len)
1056 inuse_idx = 0;
1057 rx_ring->lbq_use_tail = inuse_idx;
1058 atomic_inc_32(&rx_ring->lbuf_in_use_count);
1059 }
1060
1061 /*
1062 * Get a large buffer descriptor from in use list
1063 */
1064 static struct bq_desc *
1065 ql_get_lbuf_from_in_use_list(struct rx_ring *rx_ring)
1066 {
1067 struct bq_desc *lbq_desc;
1068 uint32_t inuse_idx;
1069
1070 /* Pick from head of in use list */
1071 inuse_idx = rx_ring->lbq_use_head;
1072 lbq_desc = rx_ring->lbuf_in_use[inuse_idx];
1073 rx_ring->lbuf_in_use[inuse_idx] = NULL;
1074
1075 if (lbq_desc != NULL) {
1076 inuse_idx++;
1077 if (inuse_idx >= rx_ring->lbq_len)
1078 inuse_idx = 0;
1079 rx_ring->lbq_use_head = inuse_idx;
1080 atomic_dec_32(&rx_ring->lbuf_in_use_count);
1081 atomic_inc_32(&rx_ring->rx_indicate);
1082 lbq_desc->upl_inuse = 1;
1083
1084 /* if mp is NULL */
1085 if (lbq_desc->mp == NULL) {
1086 /* try to remap mp again */
1087 lbq_desc->mp =
1088 desballoc((unsigned char *)(lbq_desc->bd_dma.vaddr),
1089 rx_ring->lbq_buf_size, 0, &lbq_desc->rx_recycle);
1090 }
1091 }
1092 return (lbq_desc);
1093 }
1094
1095 /*
1096 * Add a large buffer descriptor to free list
1097 */
1098 static void
1099 ql_add_lbuf_to_free_list(struct rx_ring *rx_ring,
1100 struct bq_desc *lbq_desc)
1101 {
1102 uint32_t free_idx;
1103
1104 /* Add to the end of free list */
1105 free_idx = rx_ring->lbq_free_tail;
1106 rx_ring->lbuf_free[free_idx] = lbq_desc;
1107 free_idx++;
1108 if (free_idx >= rx_ring->lbq_len)
1109 free_idx = 0;
1110 rx_ring->lbq_free_tail = free_idx;
1111 atomic_inc_32(&rx_ring->lbuf_free_count);
1112 ASSERT(rx_ring->lbuf_free_count <= rx_ring->lbq_len);
1113 }
1114
1115 /*
1116 * Get a large buffer descriptor from its free list
1117 */
1118 static struct bq_desc *
1119 ql_get_lbuf_from_free_list(struct rx_ring *rx_ring)
1120 {
1121 struct bq_desc *lbq_desc;
1122 uint32_t free_idx;
1123
1124 free_idx = rx_ring->lbq_free_head;
1125 /* Pick from head of free list */
1126 lbq_desc = rx_ring->lbuf_free[free_idx];
1127 rx_ring->lbuf_free[free_idx] = NULL;
1128
1129 if (lbq_desc != NULL) {
1130 free_idx++;
1131 if (free_idx >= rx_ring->lbq_len)
1132 free_idx = 0;
1133 rx_ring->lbq_free_head = free_idx;
1134 atomic_dec_32(&rx_ring->lbuf_free_count);
1135 }
1136 return (lbq_desc);
1137 }
1138
1139 /*
1140 * Add a small buffer descriptor to free list
1141 */
1142 static void
1143 ql_refill_sbuf_free_list(struct bq_desc *sbq_desc, boolean_t alloc_memory)
1144 {
1145 struct rx_ring *rx_ring = sbq_desc->rx_ring;
1146 uint64_t *sbq_entry;
1147 qlge_t *qlge = (qlge_t *)rx_ring->qlge;
1148 /*
1149 * Sync access
1150 */
1151 mutex_enter(&rx_ring->sbq_lock);
1152
1153 sbq_desc->upl_inuse = 0;
1154
1155 /*
1156 * If we are freeing the buffers as a result of adapter unload, get out
1157 */
1158 if ((sbq_desc->free_buf != NULL) ||
1159 (qlge->mac_flags == QL_MAC_DETACH)) {
1160 if (sbq_desc->free_buf == NULL)
1161 atomic_dec_32(&rx_ring->rx_indicate);
1162 mutex_exit(&rx_ring->sbq_lock);
1163 return;
1164 }
1165 #ifdef QLGE_LOAD_UNLOAD
1166 if (rx_ring->rx_indicate == 0)
1167 cmn_err(CE_WARN, "sbq: indicate wrong");
1168 #endif
1169 #ifdef QLGE_TRACK_BUFFER_USAGE
1170 uint32_t sb_consumer_idx;
1171 uint32_t sb_producer_idx;
1172 uint32_t num_free_buffers;
1173 uint32_t temp;
1174
1175 temp = ql_read_doorbell_reg(qlge, rx_ring->sbq_prod_idx_db_reg);
1176 sb_producer_idx = temp & 0x0000ffff;
1177 sb_consumer_idx = (temp >> 16);
1178
1179 if (sb_consumer_idx > sb_producer_idx)
1180 num_free_buffers = NUM_SMALL_BUFFERS -
1181 (sb_consumer_idx - sb_producer_idx);
1182 else
1183 num_free_buffers = sb_producer_idx - sb_consumer_idx;
1184
1185 if (num_free_buffers < qlge->rx_sb_low_count[rx_ring->cq_id])
1186 qlge->rx_sb_low_count[rx_ring->cq_id] = num_free_buffers;
1187
1188 #endif
1189
1190 #ifdef QLGE_LOAD_UNLOAD
1191 if (rx_ring->rx_indicate > 0xFF000000)
1192 cmn_err(CE_WARN, "sbq: indicate(%d) wrong: %d mac_flags %d,"
1193 " sbq_desc index %d.",
1194 rx_ring->cq_id, rx_ring->rx_indicate, rx_ring->mac_flags,
1195 sbq_desc->index);
1196 #endif
1197 if (alloc_memory) {
1198 sbq_desc->mp =
1199 desballoc((unsigned char *)(sbq_desc->bd_dma.vaddr),
1200 rx_ring->sbq_buf_size, 0, &sbq_desc->rx_recycle);
1201 if (sbq_desc->mp == NULL) {
1202 rx_ring->rx_failed_sbq_allocs++;
1203 }
1204 }
1205
1206 /* Got the packet from the stack decrement rx_indicate count */
1207 atomic_dec_32(&rx_ring->rx_indicate);
1208
1209 ql_add_sbuf_to_free_list(rx_ring, sbq_desc);
1210
1211 /* Rearm if possible */
1212 if ((rx_ring->sbuf_free_count >= MIN_BUFFERS_FREE_COUNT) &&
1213 (qlge->mac_flags == QL_MAC_STARTED)) {
1214 sbq_entry = rx_ring->sbq_dma.vaddr;
1215 sbq_entry += rx_ring->sbq_prod_idx;
1216
1217 while (rx_ring->sbuf_free_count > MIN_BUFFERS_ARM_COUNT) {
1218 /* Get first one from free list */
1219 sbq_desc = ql_get_sbuf_from_free_list(rx_ring);
1220
1221 *sbq_entry = cpu_to_le64(sbq_desc->bd_dma.dma_addr);
1222 sbq_entry++;
1223 rx_ring->sbq_prod_idx++;
1224 if (rx_ring->sbq_prod_idx >= rx_ring->sbq_len) {
1225 rx_ring->sbq_prod_idx = 0;
1226 sbq_entry = rx_ring->sbq_dma.vaddr;
1227 }
1228 /* Add to end of in use list */
1229 ql_add_sbuf_to_in_use_list(rx_ring, sbq_desc);
1230 }
1231
1232 /* Update small buffer queue producer index */
1233 ql_update_sbq_prod_idx(qlge, rx_ring);
1234 }
1235
1236 mutex_exit(&rx_ring->sbq_lock);
1237 QL_PRINT(DBG_RX_RING, ("%s(%d) exited, sbuf_free_count %d\n",
1238 __func__, qlge->instance, rx_ring->sbuf_free_count));
1239 }
1240
1241 /*
1242 * rx recycle call back function
1243 */
1244 static void
1245 ql_release_to_sbuf_free_list(caddr_t p)
1246 {
1247 struct bq_desc *sbq_desc = (struct bq_desc *)(void *)p;
1248
1249 if (sbq_desc == NULL)
1250 return;
1251 ql_refill_sbuf_free_list(sbq_desc, B_TRUE);
1252 }
1253
1254 /*
1255 * Add a large buffer descriptor to free list
1256 */
1257 static void
1258 ql_refill_lbuf_free_list(struct bq_desc *lbq_desc, boolean_t alloc_memory)
1259 {
1260 struct rx_ring *rx_ring = lbq_desc->rx_ring;
1261 uint64_t *lbq_entry;
1262 qlge_t *qlge = rx_ring->qlge;
1263
1264 /* Sync access */
1265 mutex_enter(&rx_ring->lbq_lock);
1266
1267 lbq_desc->upl_inuse = 0;
1268 /*
1269 * If we are freeing the buffers as a result of adapter unload, get out
1270 */
1271 if ((lbq_desc->free_buf != NULL) ||
1272 (qlge->mac_flags == QL_MAC_DETACH)) {
1273 if (lbq_desc->free_buf == NULL)
1274 atomic_dec_32(&rx_ring->rx_indicate);
1275 mutex_exit(&rx_ring->lbq_lock);
1276 return;
1277 }
1278 #ifdef QLGE_LOAD_UNLOAD
1279 if (rx_ring->rx_indicate == 0)
1280 cmn_err(CE_WARN, "lbq: indicate wrong");
1281 #endif
1282 #ifdef QLGE_TRACK_BUFFER_USAGE
1283 uint32_t lb_consumer_idx;
1284 uint32_t lb_producer_idx;
1285 uint32_t num_free_buffers;
1286 uint32_t temp;
1287
1288 temp = ql_read_doorbell_reg(qlge, rx_ring->lbq_prod_idx_db_reg);
1289
1290 lb_producer_idx = temp & 0x0000ffff;
1291 lb_consumer_idx = (temp >> 16);
1292
1293 if (lb_consumer_idx > lb_producer_idx)
1294 num_free_buffers = NUM_LARGE_BUFFERS -
1295 (lb_consumer_idx - lb_producer_idx);
1296 else
1297 num_free_buffers = lb_producer_idx - lb_consumer_idx;
1298
1299 if (num_free_buffers < qlge->rx_lb_low_count[rx_ring->cq_id]) {
1300 qlge->rx_lb_low_count[rx_ring->cq_id] = num_free_buffers;
1301 }
1302 #endif
1303
1304 #ifdef QLGE_LOAD_UNLOAD
1305 if (rx_ring->rx_indicate > 0xFF000000)
1306 cmn_err(CE_WARN, "lbq: indicate(%d) wrong: %d mac_flags %d,"
1307 "lbq_desc index %d",
1308 rx_ring->cq_id, rx_ring->rx_indicate, rx_ring->mac_flags,
1309 lbq_desc->index);
1310 #endif
1311 if (alloc_memory) {
1312 lbq_desc->mp =
1313 desballoc((unsigned char *)(lbq_desc->bd_dma.vaddr),
1314 rx_ring->lbq_buf_size, 0, &lbq_desc->rx_recycle);
1315 if (lbq_desc->mp == NULL) {
1316 rx_ring->rx_failed_lbq_allocs++;
1317 }
1318 }
1319
1320 /* Got the packet from the stack decrement rx_indicate count */
1321 atomic_dec_32(&rx_ring->rx_indicate);
1322
1323 ql_add_lbuf_to_free_list(rx_ring, lbq_desc);
1324
1325 /* Rearm if possible */
1326 if ((rx_ring->lbuf_free_count >= MIN_BUFFERS_FREE_COUNT) &&
1327 (qlge->mac_flags == QL_MAC_STARTED)) {
1328 lbq_entry = rx_ring->lbq_dma.vaddr;
1329 lbq_entry += rx_ring->lbq_prod_idx;
1330 while (rx_ring->lbuf_free_count > MIN_BUFFERS_ARM_COUNT) {
1331 /* Get first one from free list */
1332 lbq_desc = ql_get_lbuf_from_free_list(rx_ring);
1333
1334 *lbq_entry = cpu_to_le64(lbq_desc->bd_dma.dma_addr);
1335 lbq_entry++;
1336 rx_ring->lbq_prod_idx++;
1337 if (rx_ring->lbq_prod_idx >= rx_ring->lbq_len) {
1338 rx_ring->lbq_prod_idx = 0;
1339 lbq_entry = rx_ring->lbq_dma.vaddr;
1340 }
1341
1342 /* Add to end of in use list */
1343 ql_add_lbuf_to_in_use_list(rx_ring, lbq_desc);
1344 }
1345
1346 /* Update large buffer queue producer index */
1347 ql_update_lbq_prod_idx(rx_ring->qlge, rx_ring);
1348 }
1349
1350 mutex_exit(&rx_ring->lbq_lock);
1351 QL_PRINT(DBG_RX_RING, ("%s exitd, lbuf_free_count %d\n",
1352 __func__, rx_ring->lbuf_free_count));
1353 }
1354 /*
1355 * rx recycle call back function
1356 */
1357 static void
1358 ql_release_to_lbuf_free_list(caddr_t p)
1359 {
1360 struct bq_desc *lbq_desc = (struct bq_desc *)(void *)p;
1361
1362 if (lbq_desc == NULL)
1363 return;
1364 ql_refill_lbuf_free_list(lbq_desc, B_TRUE);
1365 }
1366
1367 /*
1368 * free small buffer queue buffers
1369 */
1370 static void
1371 ql_free_sbq_buffers(struct rx_ring *rx_ring)
1372 {
1373 struct bq_desc *sbq_desc;
1374 uint32_t i;
1375 uint32_t j = rx_ring->sbq_free_head;
1376 int force_cnt = 0;
1377
1378 for (i = 0; i < rx_ring->sbuf_free_count; i++) {
1379 sbq_desc = rx_ring->sbuf_free[j];
1380 sbq_desc->free_buf = 1;
1381 j++;
1382 if (j >= rx_ring->sbq_len) {
1383 j = 0;
1384 }
1385 if (sbq_desc->mp != NULL) {
1386 freemsg(sbq_desc->mp);
1387 sbq_desc->mp = NULL;
1388 }
1389 }
1390 rx_ring->sbuf_free_count = 0;
1391
1392 j = rx_ring->sbq_use_head;
1393 for (i = 0; i < rx_ring->sbuf_in_use_count; i++) {
1394 sbq_desc = rx_ring->sbuf_in_use[j];
1395 sbq_desc->free_buf = 1;
1396 j++;
1397 if (j >= rx_ring->sbq_len) {
1398 j = 0;
1399 }
1400 if (sbq_desc->mp != NULL) {
1401 freemsg(sbq_desc->mp);
1402 sbq_desc->mp = NULL;
1403 }
1404 }
1405 rx_ring->sbuf_in_use_count = 0;
1406
1407 sbq_desc = &rx_ring->sbq_desc[0];
1408 for (i = 0; i < rx_ring->sbq_len; i++, sbq_desc++) {
1409 /*
1410 * Set flag so that the callback does not allocate a new buffer
1411 */
1412 sbq_desc->free_buf = 1;
1413 if (sbq_desc->upl_inuse != 0) {
1414 force_cnt++;
1415 }
1416 if (sbq_desc->bd_dma.dma_handle != NULL) {
1417 ql_free_phys(&sbq_desc->bd_dma.dma_handle,
1418 &sbq_desc->bd_dma.acc_handle);
1419 sbq_desc->bd_dma.dma_handle = NULL;
1420 sbq_desc->bd_dma.acc_handle = NULL;
1421 }
1422 }
1423 #ifdef QLGE_LOAD_UNLOAD
1424 cmn_err(CE_NOTE, "sbq: free %d inuse %d force %d\n",
1425 rx_ring->sbuf_free_count, rx_ring->sbuf_in_use_count, force_cnt);
1426 #endif
1427 if (rx_ring->sbuf_in_use != NULL) {
1428 kmem_free(rx_ring->sbuf_in_use, (rx_ring->sbq_len *
1429 sizeof (struct bq_desc *)));
1430 rx_ring->sbuf_in_use = NULL;
1431 }
1432
1433 if (rx_ring->sbuf_free != NULL) {
1434 kmem_free(rx_ring->sbuf_free, (rx_ring->sbq_len *
1435 sizeof (struct bq_desc *)));
1436 rx_ring->sbuf_free = NULL;
1437 }
1438 }
1439
1440 /* Allocate small buffers */
1441 static int
1442 ql_alloc_sbufs(qlge_t *qlge, struct rx_ring *rx_ring)
1443 {
1444 struct bq_desc *sbq_desc;
1445 int i;
1446 ddi_dma_cookie_t dma_cookie;
1447
1448 rx_ring->sbq_use_head = 0;
1449 rx_ring->sbq_use_tail = 0;
1450 rx_ring->sbuf_in_use_count = 0;
1451 rx_ring->sbq_free_head = 0;
1452 rx_ring->sbq_free_tail = 0;
1453 rx_ring->sbuf_free_count = 0;
1454 rx_ring->sbuf_free = kmem_zalloc(rx_ring->sbq_len *
1455 sizeof (struct bq_desc *), KM_NOSLEEP);
1456 if (rx_ring->sbuf_free == NULL) {
1457 cmn_err(CE_WARN,
1458 "!%s: sbuf_free_list alloc: failed",
1459 __func__);
1460 goto alloc_sbuf_err;
1461 }
1462
1463 rx_ring->sbuf_in_use = kmem_zalloc(rx_ring->sbq_len *
1464 sizeof (struct bq_desc *), KM_NOSLEEP);
1465 if (rx_ring->sbuf_in_use == NULL) {
1466 cmn_err(CE_WARN,
1467 "!%s: sbuf_inuse_list alloc: failed",
1468 __func__);
1469 goto alloc_sbuf_err;
1470 }
1471
1472 sbq_desc = &rx_ring->sbq_desc[0];
1473
1474 for (i = 0; i < rx_ring->sbq_len; i++, sbq_desc++) {
1475 /* Allocate buffer */
1476 if (ql_alloc_phys_rbuf(qlge->dip, &sbq_desc->bd_dma.dma_handle,
1477 &ql_buf_acc_attr,
1478 DDI_DMA_READ | DDI_DMA_STREAMING,
1479 &sbq_desc->bd_dma.acc_handle,
1480 (size_t)rx_ring->sbq_buf_size, /* mem size */
1481 (size_t)0, /* default alignment */
1482 (caddr_t *)&sbq_desc->bd_dma.vaddr,
1483 &dma_cookie) != 0) {
1484 cmn_err(CE_WARN,
1485 "!%s: ddi_dma_alloc_handle: failed",
1486 __func__);
1487 goto alloc_sbuf_err;
1488 }
1489
1490 /* Set context for Return buffer callback */
1491 sbq_desc->bd_dma.dma_addr = dma_cookie.dmac_laddress;
1492 sbq_desc->rx_recycle.free_func = ql_release_to_sbuf_free_list;
1493 sbq_desc->rx_recycle.free_arg = (caddr_t)sbq_desc;
1494 sbq_desc->rx_ring = rx_ring;
1495 sbq_desc->upl_inuse = 0;
1496 sbq_desc->free_buf = 0;
1497
1498 sbq_desc->mp =
1499 desballoc((unsigned char *)(sbq_desc->bd_dma.vaddr),
1500 rx_ring->sbq_buf_size, 0, &sbq_desc->rx_recycle);
1501 if (sbq_desc->mp == NULL) {
1502 cmn_err(CE_WARN, "%s: desballoc() failed", __func__);
1503 goto alloc_sbuf_err;
1504 }
1505 ql_add_sbuf_to_free_list(rx_ring, sbq_desc);
1506 }
1507
1508 return (DDI_SUCCESS);
1509
1510 alloc_sbuf_err:
1511 ql_free_sbq_buffers(rx_ring);
1512 return (DDI_FAILURE);
1513 }
1514
1515 static void
1516 ql_free_lbq_buffers(struct rx_ring *rx_ring)
1517 {
1518 struct bq_desc *lbq_desc;
1519 uint32_t i, j;
1520 int force_cnt = 0;
1521
1522 j = rx_ring->lbq_free_head;
1523 for (i = 0; i < rx_ring->lbuf_free_count; i++) {
1524 lbq_desc = rx_ring->lbuf_free[j];
1525 lbq_desc->free_buf = 1;
1526 j++;
1527 if (j >= rx_ring->lbq_len)
1528 j = 0;
1529 if (lbq_desc->mp != NULL) {
1530 freemsg(lbq_desc->mp);
1531 lbq_desc->mp = NULL;
1532 }
1533 }
1534 rx_ring->lbuf_free_count = 0;
1535
1536 j = rx_ring->lbq_use_head;
1537 for (i = 0; i < rx_ring->lbuf_in_use_count; i++) {
1538 lbq_desc = rx_ring->lbuf_in_use[j];
1539 lbq_desc->free_buf = 1;
1540 j++;
1541 if (j >= rx_ring->lbq_len) {
1542 j = 0;
1543 }
1544 if (lbq_desc->mp != NULL) {
1545 freemsg(lbq_desc->mp);
1546 lbq_desc->mp = NULL;
1547 }
1548 }
1549 rx_ring->lbuf_in_use_count = 0;
1550
1551 lbq_desc = &rx_ring->lbq_desc[0];
1552 for (i = 0; i < rx_ring->lbq_len; i++, lbq_desc++) {
1553 /* Set flag so that callback will not allocate a new buffer */
1554 lbq_desc->free_buf = 1;
1555 if (lbq_desc->upl_inuse != 0) {
1556 force_cnt++;
1557 }
1558 if (lbq_desc->bd_dma.dma_handle != NULL) {
1559 ql_free_phys(&lbq_desc->bd_dma.dma_handle,
1560 &lbq_desc->bd_dma.acc_handle);
1561 lbq_desc->bd_dma.dma_handle = NULL;
1562 lbq_desc->bd_dma.acc_handle = NULL;
1563 }
1564 }
1565 #ifdef QLGE_LOAD_UNLOAD
1566 if (force_cnt) {
1567 cmn_err(CE_WARN, "lbq: free %d inuse %d force %d",
1568 rx_ring->lbuf_free_count, rx_ring->lbuf_in_use_count,
1569 force_cnt);
1570 }
1571 #endif
1572 if (rx_ring->lbuf_in_use != NULL) {
1573 kmem_free(rx_ring->lbuf_in_use, (rx_ring->lbq_len *
1574 sizeof (struct bq_desc *)));
1575 rx_ring->lbuf_in_use = NULL;
1576 }
1577
1578 if (rx_ring->lbuf_free != NULL) {
1579 kmem_free(rx_ring->lbuf_free, (rx_ring->lbq_len *
1580 sizeof (struct bq_desc *)));
1581 rx_ring->lbuf_free = NULL;
1582 }
1583 }
1584
1585 /* Allocate large buffers */
1586 static int
1587 ql_alloc_lbufs(qlge_t *qlge, struct rx_ring *rx_ring)
1588 {
1589 struct bq_desc *lbq_desc;
1590 ddi_dma_cookie_t dma_cookie;
1591 int i;
1592 uint32_t lbq_buf_size;
1593
1594 rx_ring->lbq_use_head = 0;
1595 rx_ring->lbq_use_tail = 0;
1596 rx_ring->lbuf_in_use_count = 0;
1597 rx_ring->lbq_free_head = 0;
1598 rx_ring->lbq_free_tail = 0;
1599 rx_ring->lbuf_free_count = 0;
1600 rx_ring->lbuf_free = kmem_zalloc(rx_ring->lbq_len *
1601 sizeof (struct bq_desc *), KM_NOSLEEP);
1602 if (rx_ring->lbuf_free == NULL) {
1603 cmn_err(CE_WARN,
1604 "!%s: lbuf_free_list alloc: failed",
1605 __func__);
1606 goto alloc_lbuf_err;
1607 }
1608
1609 rx_ring->lbuf_in_use = kmem_zalloc(rx_ring->lbq_len *
1610 sizeof (struct bq_desc *), KM_NOSLEEP);
1611
1612 if (rx_ring->lbuf_in_use == NULL) {
1613 cmn_err(CE_WARN,
1614 "!%s: lbuf_inuse_list alloc: failed",
1615 __func__);
1616 goto alloc_lbuf_err;
1617 }
1618
1619 lbq_buf_size = (qlge->mtu == ETHERMTU) ?
1620 LRG_BUF_NORMAL_SIZE : LRG_BUF_JUMBO_SIZE;
1621
1622 lbq_desc = &rx_ring->lbq_desc[0];
1623 for (i = 0; i < rx_ring->lbq_len; i++, lbq_desc++) {
1624 rx_ring->lbq_buf_size = lbq_buf_size;
1625 /* Allocate buffer */
1626 if (ql_alloc_phys_rbuf(qlge->dip, &lbq_desc->bd_dma.dma_handle,
1627 &ql_buf_acc_attr,
1628 DDI_DMA_READ | DDI_DMA_STREAMING,
1629 &lbq_desc->bd_dma.acc_handle,
1630 (size_t)rx_ring->lbq_buf_size, /* mem size */
1631 (size_t)0, /* default alignment */
1632 (caddr_t *)&lbq_desc->bd_dma.vaddr,
1633 &dma_cookie) != 0) {
1634 cmn_err(CE_WARN,
1635 "!%s: ddi_dma_alloc_handle: failed",
1636 __func__);
1637 goto alloc_lbuf_err;
1638 }
1639
1640 /* Set context for Return buffer callback */
1641 lbq_desc->bd_dma.dma_addr = dma_cookie.dmac_laddress;
1642 lbq_desc->rx_recycle.free_func = ql_release_to_lbuf_free_list;
1643 lbq_desc->rx_recycle.free_arg = (caddr_t)lbq_desc;
1644 lbq_desc->rx_ring = rx_ring;
1645 lbq_desc->upl_inuse = 0;
1646 lbq_desc->free_buf = 0;
1647
1648 lbq_desc->mp =
1649 desballoc((unsigned char *)(lbq_desc->bd_dma.vaddr),
1650 rx_ring->lbq_buf_size, 0, &lbq_desc->rx_recycle);
1651 if (lbq_desc->mp == NULL) {
1652 cmn_err(CE_WARN, "%s: desballoc() failed", __func__);
1653 goto alloc_lbuf_err;
1654 }
1655 ql_add_lbuf_to_free_list(rx_ring, lbq_desc);
1656 } /* For all large buffers */
1657
1658 return (DDI_SUCCESS);
1659
1660 alloc_lbuf_err:
1661 ql_free_lbq_buffers(rx_ring);
1662 return (DDI_FAILURE);
1663 }
1664
1665 /*
1666 * Free rx buffers
1667 */
1668 static void
1669 ql_free_rx_buffers(qlge_t *qlge)
1670 {
1671 int i;
1672 struct rx_ring *rx_ring;
1673
1674 for (i = 0; i < qlge->rx_ring_count; i++) {
1675 rx_ring = &qlge->rx_ring[i];
1676 if (rx_ring->type != TX_Q) {
1677 ql_free_lbq_buffers(rx_ring);
1678 ql_free_sbq_buffers(rx_ring);
1679 }
1680 }
1681 }
1682
1683 /*
1684 * Allocate rx buffers
1685 */
1686 static int
1687 ql_alloc_rx_buffers(qlge_t *qlge)
1688 {
1689 struct rx_ring *rx_ring;
1690 int i;
1691
1692 for (i = 0; i < qlge->rx_ring_count; i++) {
1693 rx_ring = &qlge->rx_ring[i];
1694 if (rx_ring->type != TX_Q) {
1695 if (ql_alloc_sbufs(qlge, rx_ring) != DDI_SUCCESS)
1696 goto alloc_err;
1697 if (ql_alloc_lbufs(qlge, rx_ring) != DDI_SUCCESS)
1698 goto alloc_err;
1699 }
1700 }
1701 #ifdef QLGE_TRACK_BUFFER_USAGE
1702 for (i = 0; i < qlge->rx_ring_count; i++) {
1703 if (qlge->rx_ring[i].type == RX_Q) {
1704 qlge->rx_sb_low_count[i] = NUM_SMALL_BUFFERS;
1705 qlge->rx_lb_low_count[i] = NUM_LARGE_BUFFERS;
1706 }
1707 qlge->cq_low_count[i] = NUM_RX_RING_ENTRIES;
1708 }
1709 #endif
1710 return (DDI_SUCCESS);
1711
1712 alloc_err:
1713 ql_free_rx_buffers(qlge);
1714 return (DDI_FAILURE);
1715 }
1716
1717 /*
1718 * Initialize large buffer queue ring
1719 */
1720 static void
1721 ql_init_lbq_ring(struct rx_ring *rx_ring)
1722 {
1723 uint16_t i;
1724 struct bq_desc *lbq_desc;
1725
1726 bzero(rx_ring->lbq_desc, rx_ring->lbq_len * sizeof (struct bq_desc));
1727 for (i = 0; i < rx_ring->lbq_len; i++) {
1728 lbq_desc = &rx_ring->lbq_desc[i];
1729 lbq_desc->index = i;
1730 }
1731 }
1732
1733 /*
1734 * Initialize small buffer queue ring
1735 */
1736 static void
1737 ql_init_sbq_ring(struct rx_ring *rx_ring)
1738 {
1739 uint16_t i;
1740 struct bq_desc *sbq_desc;
1741
1742 bzero(rx_ring->sbq_desc, rx_ring->sbq_len * sizeof (struct bq_desc));
1743 for (i = 0; i < rx_ring->sbq_len; i++) {
1744 sbq_desc = &rx_ring->sbq_desc[i];
1745 sbq_desc->index = i;
1746 }
1747 }
1748
1749 /*
1750 * Calculate the pseudo-header checksum if hardware can not do
1751 */
1752 static void
1753 ql_pseudo_cksum(uint8_t *buf)
1754 {
1755 uint32_t cksum;
1756 uint16_t iphl;
1757 uint16_t proto;
1758
1759 iphl = (uint16_t)(4 * (buf[0] & 0xF));
1760 cksum = (((uint16_t)buf[2])<<8) + buf[3] - iphl;
1761 cksum += proto = buf[9];
1762 cksum += (((uint16_t)buf[12])<<8) + buf[13];
1763 cksum += (((uint16_t)buf[14])<<8) + buf[15];
1764 cksum += (((uint16_t)buf[16])<<8) + buf[17];
1765 cksum += (((uint16_t)buf[18])<<8) + buf[19];
1766 cksum = (cksum>>16) + (cksum & 0xFFFF);
1767 cksum = (cksum>>16) + (cksum & 0xFFFF);
1768
1769 /*
1770 * Point it to the TCP/UDP header, and
1771 * update the checksum field.
1772 */
1773 buf += iphl + ((proto == IPPROTO_TCP) ?
1774 TCP_CKSUM_OFFSET : UDP_CKSUM_OFFSET);
1775
1776 *(uint16_t *)(void *)buf = (uint16_t)htons((uint16_t)cksum);
1777
1778 }
1779
1780 /*
1781 * Transmit an incoming packet.
1782 */
1783 mblk_t *
1784 ql_ring_tx(void *arg, mblk_t *mp)
1785 {
1786 struct tx_ring *tx_ring = (struct tx_ring *)arg;
1787 qlge_t *qlge = tx_ring->qlge;
1788 mblk_t *next;
1789 int rval;
1790 uint32_t tx_count = 0;
1791
1792 if (qlge->port_link_state == LS_DOWN) {
1793 /* can not send message while link is down */
1794 mblk_t *tp;
1795
1796 while (mp != NULL) {
1797 tp = mp->b_next;
1798 mp->b_next = NULL;
1799 freemsg(mp);
1800 mp = tp;
1801 }
1802 goto exit;
1803 }
1804
1805 mutex_enter(&tx_ring->tx_lock);
1806 /* if mac is not started, driver is not ready, can not send */
1807 if (tx_ring->mac_flags != QL_MAC_STARTED) {
1808 cmn_err(CE_WARN, "%s(%d)ring not started, mode %d "
1809 " return packets",
1810 __func__, qlge->instance, tx_ring->mac_flags);
1811 mutex_exit(&tx_ring->tx_lock);
1812 goto exit;
1813 }
1814
1815 /* we must try to send all */
1816 while (mp != NULL) {
1817 /*
1818 * if number of available slots is less than a threshold,
1819 * then quit
1820 */
1821 if (tx_ring->tx_free_count <= TX_STOP_THRESHOLD) {
1822 tx_ring->queue_stopped = 1;
1823 rval = DDI_FAILURE;
1824 #ifdef QLGE_LOAD_UNLOAD
1825 cmn_err(CE_WARN, "%s(%d) no resources",
1826 __func__, qlge->instance);
1827 #endif
1828 tx_ring->defer++;
1829 /*
1830 * If we return the buffer back we are expected to call
1831 * mac_tx_ring_update() when resources are available
1832 */
1833 break;
1834 }
1835
1836 next = mp->b_next;
1837 mp->b_next = NULL;
1838
1839 rval = ql_send_common(tx_ring, mp);
1840
1841 if (rval != DDI_SUCCESS) {
1842 mp->b_next = next;
1843 break;
1844 }
1845 tx_count++;
1846 mp = next;
1847 }
1848
1849 /*
1850 * After all msg blocks are mapped or copied to tx buffer,
1851 * trigger the hardware to send!
1852 */
1853 if (tx_count > 0) {
1854 ql_write_doorbell_reg(tx_ring->qlge, tx_ring->prod_idx_db_reg,
1855 tx_ring->prod_idx);
1856 }
1857
1858 mutex_exit(&tx_ring->tx_lock);
1859 exit:
1860 return (mp);
1861 }
1862
1863
1864 /*
1865 * This function builds an mblk list for the given inbound
1866 * completion.
1867 */
1868
1869 static mblk_t *
1870 ql_build_rx_mp(qlge_t *qlge, struct rx_ring *rx_ring,
1871 struct ib_mac_iocb_rsp *ib_mac_rsp)
1872 {
1873 mblk_t *mp = NULL;
1874 mblk_t *mp1 = NULL; /* packet header */
1875 mblk_t *mp2 = NULL; /* packet content */
1876 struct bq_desc *lbq_desc;
1877 struct bq_desc *sbq_desc;
1878 uint32_t err_flag = (ib_mac_rsp->flags2 & IB_MAC_IOCB_RSP_ERR_MASK);
1879 uint32_t payload_len = le32_to_cpu(ib_mac_rsp->data_len);
1880 uint32_t header_len = le32_to_cpu(ib_mac_rsp->hdr_len);
1881 uint32_t pkt_len = payload_len + header_len;
1882 uint32_t done;
1883 uint64_t *curr_ial_ptr;
1884 uint32_t ial_data_addr_low;
1885 uint32_t actual_data_addr_low;
1886 mblk_t *mp_ial = NULL; /* ial chained packets */
1887 uint32_t size;
1888 uint32_t cp_offset;
1889 boolean_t rx_copy = B_FALSE;
1890 mblk_t *tp = NULL;
1891
1892 /*
1893 * Check if error flags are set
1894 */
1895 if (err_flag != 0) {
1896 if ((err_flag & IB_MAC_IOCB_RSP_ERR_OVERSIZE) != 0)
1897 rx_ring->frame_too_long++;
1898 if ((err_flag & IB_MAC_IOCB_RSP_ERR_UNDERSIZE) != 0)
1899 rx_ring->frame_too_short++;
1900 if ((err_flag & IB_MAC_IOCB_RSP_ERR_CRC) != 0)
1901 rx_ring->fcs_err++;
1902 #ifdef QLGE_LOAD_UNLOAD
1903 cmn_err(CE_WARN, "bad packet, type 0x%x", err_flag);
1904 #endif
1905 QL_DUMP(DBG_RX, "qlge_ring_rx: bad response iocb dump\n",
1906 (uint8_t *)ib_mac_rsp, 8,
1907 (size_t)sizeof (struct ib_mac_iocb_rsp));
1908 }
1909
1910 /* header should not be in large buffer */
1911 if (ib_mac_rsp->flags4 & IB_MAC_IOCB_RSP_HL) {
1912 cmn_err(CE_WARN, "header in large buffer or invalid!");
1913 err_flag |= 1;
1914 }
1915 /* if whole packet is too big than rx buffer size */
1916 if (pkt_len > qlge->max_frame_size) {
1917 cmn_err(CE_WARN, "ql_build_rx_mpframe too long(%d)!", pkt_len);
1918 err_flag |= 1;
1919 }
1920 if (qlge->rx_copy ||
1921 (rx_ring->sbuf_in_use_count <= qlge->rx_copy_threshold) ||
1922 (rx_ring->lbuf_in_use_count <= qlge->rx_copy_threshold)) {
1923 rx_copy = B_TRUE;
1924 }
1925
1926 /* if using rx copy mode, we need to allocate a big enough buffer */
1927 if (rx_copy) {
1928 qlge->stats.norcvbuf++;
1929 tp = allocb(payload_len + header_len + qlge->ip_hdr_offset,
1930 BPRI_MED);
1931 if (tp == NULL) {
1932 cmn_err(CE_WARN, "rx copy failed to allocate memory");
1933 } else {
1934 tp->b_rptr += qlge->ip_hdr_offset;
1935 }
1936 }
1937 /*
1938 * Handle the header buffer if present.
1939 * packet header must be valid and saved in one small buffer
1940 * broadcast/multicast packets' headers not splitted
1941 */
1942 if ((ib_mac_rsp->flags4 & IB_MAC_IOCB_RSP_HV) &&
1943 (ib_mac_rsp->flags4 & IB_MAC_IOCB_RSP_HS)) {
1944 QL_PRINT(DBG_RX, ("Header of %d bytes in small buffer.\n",
1945 header_len));
1946 /* Sync access */
1947 sbq_desc = ql_get_sbuf_from_in_use_list(rx_ring);
1948
1949 ASSERT(sbq_desc != NULL);
1950
1951 /*
1952 * Validate addresses from the ASIC with the
1953 * expected sbuf address
1954 */
1955 if (cpu_to_le64(sbq_desc->bd_dma.dma_addr)
1956 != ib_mac_rsp->hdr_addr) {
1957 /* Small buffer address mismatch */
1958 cmn_err(CE_WARN, "%s(%d) ring%d packet saved"
1959 " in wrong small buffer",
1960 __func__, qlge->instance, rx_ring->cq_id);
1961 goto fatal_error;
1962 }
1963 /* get this packet */
1964 mp1 = sbq_desc->mp;
1965 /* Flush DMA'd data */
1966 (void) ddi_dma_sync(sbq_desc->bd_dma.dma_handle,
1967 0, header_len, DDI_DMA_SYNC_FORKERNEL);
1968
1969 if ((err_flag != 0)|| (mp1 == NULL)) {
1970 /* failed on this packet, put it back for re-arming */
1971 #ifdef QLGE_LOAD_UNLOAD
1972 cmn_err(CE_WARN, "get header from small buffer fail");
1973 #endif
1974 ql_refill_sbuf_free_list(sbq_desc, B_FALSE);
1975 mp1 = NULL;
1976 } else if (rx_copy) {
1977 if (tp != NULL) {
1978 bcopy(sbq_desc->bd_dma.vaddr, tp->b_rptr,
1979 header_len);
1980 }
1981 ql_refill_sbuf_free_list(sbq_desc, B_FALSE);
1982 mp1 = NULL;
1983 } else {
1984 if ((qlge->ip_hdr_offset != 0)&&
1985 (header_len < SMALL_BUFFER_SIZE)) {
1986 /*
1987 * copy entire header to a 2 bytes boundary
1988 * address for 8100 adapters so that the IP
1989 * header can be on a 4 byte boundary address
1990 */
1991 bcopy(mp1->b_rptr,
1992 (mp1->b_rptr + SMALL_BUFFER_SIZE +
1993 qlge->ip_hdr_offset),
1994 header_len);
1995 mp1->b_rptr += SMALL_BUFFER_SIZE +
1996 qlge->ip_hdr_offset;
1997 }
1998
1999 /*
2000 * Adjust the mp payload_len to match
2001 * the packet header payload_len
2002 */
2003 mp1->b_wptr = mp1->b_rptr + header_len;
2004 mp1->b_next = mp1->b_cont = NULL;
2005 QL_DUMP(DBG_RX, "\t RX packet header dump:\n",
2006 (uint8_t *)mp1->b_rptr, 8, header_len);
2007 }
2008 }
2009
2010 /*
2011 * packet data or whole packet can be in small or one or
2012 * several large buffer(s)
2013 */
2014 if (ib_mac_rsp->flags3 & IB_MAC_IOCB_RSP_DS) {
2015 /*
2016 * The data is in a single small buffer.
2017 */
2018 sbq_desc = ql_get_sbuf_from_in_use_list(rx_ring);
2019
2020 ASSERT(sbq_desc != NULL);
2021
2022 QL_PRINT(DBG_RX,
2023 ("%d bytes in a single small buffer, sbq_desc = %p, "
2024 "sbq_desc->bd_dma.dma_addr = %x,"
2025 " ib_mac_rsp->data_addr = %x, mp = %p\n",
2026 payload_len, sbq_desc, sbq_desc->bd_dma.dma_addr,
2027 ib_mac_rsp->data_addr, sbq_desc->mp));
2028
2029 /*
2030 * Validate addresses from the ASIC with the
2031 * expected sbuf address
2032 */
2033 if (cpu_to_le64(sbq_desc->bd_dma.dma_addr)
2034 != ib_mac_rsp->data_addr) {
2035 /* Small buffer address mismatch */
2036 cmn_err(CE_WARN, "%s(%d) ring%d packet saved"
2037 " in wrong small buffer",
2038 __func__, qlge->instance, rx_ring->cq_id);
2039 goto fatal_error;
2040 }
2041 /* get this packet */
2042 mp2 = sbq_desc->mp;
2043 (void) ddi_dma_sync(sbq_desc->bd_dma.dma_handle,
2044 0, payload_len, DDI_DMA_SYNC_FORKERNEL);
2045 if ((err_flag != 0) || (mp2 == NULL)) {
2046 #ifdef QLGE_LOAD_UNLOAD
2047 /* failed on this packet, put it back for re-arming */
2048 cmn_err(CE_WARN, "ignore bad data from small buffer");
2049 #endif
2050 ql_refill_sbuf_free_list(sbq_desc, B_FALSE);
2051 mp2 = NULL;
2052 } else if (rx_copy) {
2053 if (tp != NULL) {
2054 bcopy(sbq_desc->bd_dma.vaddr,
2055 tp->b_rptr + header_len, payload_len);
2056 tp->b_wptr =
2057 tp->b_rptr + header_len + payload_len;
2058 }
2059 ql_refill_sbuf_free_list(sbq_desc, B_FALSE);
2060 mp2 = NULL;
2061 } else {
2062 /* Adjust the buffer length to match the payload_len */
2063 mp2->b_wptr = mp2->b_rptr + payload_len;
2064 mp2->b_next = mp2->b_cont = NULL;
2065 /* Flush DMA'd data */
2066 QL_DUMP(DBG_RX, "\t RX packet payload dump:\n",
2067 (uint8_t *)mp2->b_rptr, 8, payload_len);
2068 /*
2069 * if payload is too small , copy to
2070 * the end of packet header
2071 */
2072 if ((mp1 != NULL) &&
2073 (payload_len <= qlge->payload_copy_thresh) &&
2074 (pkt_len <
2075 (SMALL_BUFFER_SIZE - qlge->ip_hdr_offset))) {
2076 bcopy(mp2->b_rptr, mp1->b_wptr, payload_len);
2077 mp1->b_wptr += payload_len;
2078 freemsg(mp2);
2079 mp2 = NULL;
2080 }
2081 }
2082 } else if (ib_mac_rsp->flags3 & IB_MAC_IOCB_RSP_DL) {
2083 /*
2084 * The data is in a single large buffer.
2085 */
2086 lbq_desc = ql_get_lbuf_from_in_use_list(rx_ring);
2087
2088 QL_PRINT(DBG_RX,
2089 ("%d bytes in a single large buffer, lbq_desc = %p, "
2090 "lbq_desc->bd_dma.dma_addr = %x,"
2091 " ib_mac_rsp->data_addr = %x, mp = %p\n",
2092 payload_len, lbq_desc, lbq_desc->bd_dma.dma_addr,
2093 ib_mac_rsp->data_addr, lbq_desc->mp));
2094
2095 ASSERT(lbq_desc != NULL);
2096
2097 /*
2098 * Validate addresses from the ASIC with
2099 * the expected lbuf address
2100 */
2101 if (cpu_to_le64(lbq_desc->bd_dma.dma_addr)
2102 != ib_mac_rsp->data_addr) {
2103 /* Large buffer address mismatch */
2104 cmn_err(CE_WARN, "%s(%d) ring%d packet saved"
2105 " in wrong large buffer",
2106 __func__, qlge->instance, rx_ring->cq_id);
2107 goto fatal_error;
2108 }
2109 mp2 = lbq_desc->mp;
2110 /* Flush DMA'd data */
2111 (void) ddi_dma_sync(lbq_desc->bd_dma.dma_handle,
2112 0, payload_len, DDI_DMA_SYNC_FORKERNEL);
2113 if ((err_flag != 0) || (mp2 == NULL)) {
2114 #ifdef QLGE_LOAD_UNLOAD
2115 cmn_err(CE_WARN, "ignore bad data from large buffer");
2116 #endif
2117 /* failed on this packet, put it back for re-arming */
2118 ql_refill_lbuf_free_list(lbq_desc, B_FALSE);
2119 mp2 = NULL;
2120 } else if (rx_copy) {
2121 if (tp != NULL) {
2122 bcopy(lbq_desc->bd_dma.vaddr,
2123 tp->b_rptr + header_len, payload_len);
2124 tp->b_wptr =
2125 tp->b_rptr + header_len + payload_len;
2126 }
2127 ql_refill_lbuf_free_list(lbq_desc, B_FALSE);
2128 mp2 = NULL;
2129 } else {
2130 /*
2131 * Adjust the buffer length to match
2132 * the packet payload_len
2133 */
2134 mp2->b_wptr = mp2->b_rptr + payload_len;
2135 mp2->b_next = mp2->b_cont = NULL;
2136 QL_DUMP(DBG_RX, "\t RX packet payload dump:\n",
2137 (uint8_t *)mp2->b_rptr, 8, payload_len);
2138 /*
2139 * if payload is too small , copy to
2140 * the end of packet header
2141 */
2142 if ((mp1 != NULL) &&
2143 (payload_len <= qlge->payload_copy_thresh) &&
2144 (pkt_len<
2145 (SMALL_BUFFER_SIZE - qlge->ip_hdr_offset))) {
2146 bcopy(mp2->b_rptr, mp1->b_wptr, payload_len);
2147 mp1->b_wptr += payload_len;
2148 freemsg(mp2);
2149 mp2 = NULL;
2150 }
2151 }
2152 } else if (payload_len) { /* ial case */
2153 /*
2154 * payload available but not in sml nor lrg buffer,
2155 * so, it is saved in IAL
2156 */
2157 #ifdef QLGE_LOAD_UNLOAD
2158 cmn_err(CE_NOTE, "packet chained in IAL \n");
2159 #endif
2160 /* lrg buf addresses are saved in one small buffer */
2161 sbq_desc = ql_get_sbuf_from_in_use_list(rx_ring);
2162 curr_ial_ptr = (uint64_t *)sbq_desc->bd_dma.vaddr;
2163 done = 0;
2164 cp_offset = 0;
2165
2166 while (!done) {
2167 ial_data_addr_low =
2168 (uint32_t)(le64_to_cpu(*curr_ial_ptr) &
2169 0xFFFFFFFE);
2170 /* check if this is the last packet fragment */
2171 done = (uint32_t)(le64_to_cpu(*curr_ial_ptr) & 1);
2172 curr_ial_ptr++;
2173 /*
2174 * The data is in one or several large buffer(s).
2175 */
2176 lbq_desc = ql_get_lbuf_from_in_use_list(rx_ring);
2177 actual_data_addr_low =
2178 (uint32_t)(lbq_desc->bd_dma.dma_addr &
2179 0xFFFFFFFE);
2180 if (ial_data_addr_low != actual_data_addr_low) {
2181 cmn_err(CE_WARN,
2182 "packet saved in wrong ial lrg buffer"
2183 " expected %x, actual %lx",
2184 ial_data_addr_low,
2185 (uintptr_t)lbq_desc->bd_dma.dma_addr);
2186 goto fatal_error;
2187 }
2188
2189 size = (payload_len < rx_ring->lbq_buf_size)?
2190 payload_len : rx_ring->lbq_buf_size;
2191 payload_len -= size;
2192 mp2 = lbq_desc->mp;
2193 if ((err_flag != 0) || (mp2 == NULL)) {
2194 #ifdef QLGE_LOAD_UNLOAD
2195 cmn_err(CE_WARN,
2196 "ignore bad data from large buffer");
2197 #endif
2198 ql_refill_lbuf_free_list(lbq_desc, B_FALSE);
2199 mp2 = NULL;
2200 } else if (rx_copy) {
2201 if (tp != NULL) {
2202 (void) ddi_dma_sync(
2203 lbq_desc->bd_dma.dma_handle,
2204 0, size, DDI_DMA_SYNC_FORKERNEL);
2205 bcopy(lbq_desc->bd_dma.vaddr,
2206 tp->b_rptr + header_len + cp_offset,
2207 size);
2208 tp->b_wptr =
2209 tp->b_rptr + size + cp_offset +
2210 header_len;
2211 cp_offset += size;
2212 }
2213 ql_refill_lbuf_free_list(lbq_desc, B_FALSE);
2214 mp2 = NULL;
2215 } else {
2216 if (mp_ial == NULL) {
2217 mp_ial = mp2;
2218 } else {
2219 linkb(mp_ial, mp2);
2220 }
2221
2222 mp2->b_next = NULL;
2223 mp2->b_cont = NULL;
2224 mp2->b_wptr = mp2->b_rptr + size;
2225 /* Flush DMA'd data */
2226 (void) ddi_dma_sync(lbq_desc->bd_dma.dma_handle,
2227 0, size, DDI_DMA_SYNC_FORKERNEL);
2228 QL_PRINT(DBG_RX, ("ial %d payload received \n",
2229 size));
2230 QL_DUMP(DBG_RX, "\t Mac data dump:\n",
2231 (uint8_t *)mp2->b_rptr, 8, size);
2232 }
2233 }
2234 if (err_flag != 0) {
2235 #ifdef QLGE_LOAD_UNLOAD
2236 /* failed on this packet, put it back for re-arming */
2237 cmn_err(CE_WARN, "ignore bad data from small buffer");
2238 #endif
2239 ql_refill_sbuf_free_list(sbq_desc, B_FALSE);
2240 } else {
2241 mp2 = mp_ial;
2242 freemsg(sbq_desc->mp);
2243 }
2244 }
2245 /*
2246 * some packets' hdr not split, then send mp2 upstream, otherwise,
2247 * concatenate message block mp2 to the tail of message header, mp1
2248 */
2249 if (!err_flag) {
2250 if (rx_copy) {
2251 if (tp != NULL) {
2252 tp->b_next = NULL;
2253 tp->b_cont = NULL;
2254 tp->b_wptr = tp->b_rptr +
2255 header_len + payload_len;
2256 }
2257 mp = tp;
2258 } else {
2259 if (mp1) {
2260 if (mp2) {
2261 QL_PRINT(DBG_RX,
2262 ("packet in mp1 and mp2\n"));
2263 /* mp1->b_cont = mp2; */
2264 linkb(mp1, mp2);
2265 mp = mp1;
2266 } else {
2267 QL_PRINT(DBG_RX,
2268 ("packet in mp1 only\n"));
2269 mp = mp1;
2270 }
2271 } else if (mp2) {
2272 QL_PRINT(DBG_RX, ("packet in mp2 only\n"));
2273 mp = mp2;
2274 }
2275 }
2276 }
2277 return (mp);
2278
2279 fatal_error:
2280 /* fatal Error! */
2281 if (qlge->fm_enable) {
2282 ddi_fm_service_impact(qlge->dip, DDI_SERVICE_DEGRADED);
2283 ql_fm_ereport(qlge, DDI_FM_DEVICE_INVAL_STATE);
2284 atomic_or_32(&qlge->flags, ADAPTER_ERROR);
2285 }
2286 if (tp) {
2287 freemsg(tp);
2288 }
2289
2290 /* *mp->b_wptr = 0; */
2291 ql_wake_asic_reset_soft_intr(qlge);
2292 return (NULL);
2293
2294 }
2295
2296 /*
2297 * Bump completion queue consumer index.
2298 */
2299 static void
2300 ql_update_cq(struct rx_ring *rx_ring)
2301 {
2302 rx_ring->cnsmr_idx++;
2303 rx_ring->curr_entry++;
2304 if (rx_ring->cnsmr_idx >= rx_ring->cq_len) {
2305 rx_ring->cnsmr_idx = 0;
2306 rx_ring->curr_entry = rx_ring->cq_dma.vaddr;
2307 }
2308 }
2309
2310 /*
2311 * Update completion queue consumer index.
2312 */
2313 static void
2314 ql_write_cq_idx(struct rx_ring *rx_ring)
2315 {
2316 qlge_t *qlge = rx_ring->qlge;
2317
2318 ql_write_doorbell_reg(qlge, rx_ring->cnsmr_idx_db_reg,
2319 rx_ring->cnsmr_idx);
2320 }
2321
2322 /*
2323 * Processes a SYS-Chip Event Notification Completion Event.
2324 * The incoming notification event that describes a link up/down
2325 * or some sorts of error happens.
2326 */
2327 static void
2328 ql_process_chip_ae_intr(qlge_t *qlge,
2329 struct ib_sys_event_iocb_rsp *ib_sys_event_rsp_ptr)
2330 {
2331 uint8_t eventType = ib_sys_event_rsp_ptr->event_type;
2332 uint32_t soft_req = 0;
2333
2334 switch (eventType) {
2335 case SYS_EVENT_PORT_LINK_UP: /* 0x0h */
2336 QL_PRINT(DBG_MBX, ("Port Link Up\n"));
2337 break;
2338
2339 case SYS_EVENT_PORT_LINK_DOWN: /* 0x1h */
2340 QL_PRINT(DBG_MBX, ("Port Link Down\n"));
2341 break;
2342
2343 case SYS_EVENT_MULTIPLE_CAM_HITS : /* 0x6h */
2344 cmn_err(CE_WARN, "A multiple CAM hits look up error "
2345 "occurred");
2346 soft_req |= NEED_HW_RESET;
2347 break;
2348
2349 case SYS_EVENT_SOFT_ECC_ERR: /* 0x7h */
2350 cmn_err(CE_WARN, "Soft ECC error detected");
2351 soft_req |= NEED_HW_RESET;
2352 break;
2353
2354 case SYS_EVENT_MGMT_FATAL_ERR: /* 0x8h */
2355 cmn_err(CE_WARN, "Management (MPI) Processor fatal"
2356 " error occured");
2357 soft_req |= NEED_MPI_RESET;
2358 break;
2359
2360 case SYS_EVENT_MAC_INTERRUPT: /* 0x9h */
2361 QL_PRINT(DBG_MBX, ("MAC Interrupt"));
2362 break;
2363
2364 case SYS_EVENT_PCI_ERR_READING_SML_LRG_BUF: /* 0x40h */
2365 cmn_err(CE_WARN, "PCI Error reading small/large "
2366 "buffers occured");
2367 soft_req |= NEED_HW_RESET;
2368 break;
2369
2370 default:
2371 QL_PRINT(DBG_RX, ("%s(%d) unknown Sys Event: "
2372 "type 0x%x occured",
2373 __func__, qlge->instance, eventType));
2374 break;
2375 }
2376
2377 if ((soft_req & NEED_MPI_RESET) != 0) {
2378 ql_wake_mpi_reset_soft_intr(qlge);
2379 if (qlge->fm_enable) {
2380 ql_fm_ereport(qlge, DDI_FM_DEVICE_INVAL_STATE);
2381 ddi_fm_service_impact(qlge->dip, DDI_SERVICE_DEGRADED);
2382 }
2383 } else if ((soft_req & NEED_HW_RESET) != 0) {
2384 ql_wake_asic_reset_soft_intr(qlge);
2385 if (qlge->fm_enable) {
2386 ql_fm_ereport(qlge, DDI_FM_DEVICE_INVAL_STATE);
2387 ddi_fm_service_impact(qlge->dip, DDI_SERVICE_DEGRADED);
2388 }
2389 }
2390 }
2391
2392 /*
2393 * set received packet checksum flag
2394 */
2395 void
2396 ql_set_rx_cksum(mblk_t *mp, struct ib_mac_iocb_rsp *net_rsp)
2397 {
2398 uint32_t flags;
2399
2400 /* Not TCP or UDP packet? nothing more to do */
2401 if (((net_rsp->flags2 & IB_MAC_IOCB_RSP_T) == 0) &&
2402 ((net_rsp->flags2 & IB_MAC_IOCB_RSP_U) == 0))
2403 return;
2404
2405 /* No CKO support for IPv6 */
2406 if ((net_rsp->flags3 & IB_MAC_IOCB_RSP_V6) != 0)
2407 return;
2408
2409 /*
2410 * If checksum error, don't set flags; stack will calculate
2411 * checksum, detect the error and update statistics
2412 */
2413 if (((net_rsp->flags1 & IB_MAC_IOCB_RSP_TE) != 0) ||
2414 ((net_rsp->flags1 & IB_MAC_IOCB_RSP_IE) != 0))
2415 return;
2416
2417 /* TCP or UDP packet and checksum valid */
2418 if (((net_rsp->flags2 & IB_MAC_IOCB_RSP_T) != 0) &&
2419 ((net_rsp->flags1 & IB_MAC_IOCB_RSP_NU) == 0)) {
2420 flags = HCK_FULLCKSUM_OK;
2421 mac_hcksum_set(mp, 0, 0, 0, 0, flags);
2422 }
2423 if (((net_rsp->flags2 & IB_MAC_IOCB_RSP_U) != 0) &&
2424 ((net_rsp->flags1 & IB_MAC_IOCB_RSP_NU) == 0)) {
2425 flags = HCK_FULLCKSUM_OK;
2426 mac_hcksum_set(mp, 0, 0, 0, 0, flags);
2427 }
2428 }
2429
2430 /*
2431 * This function goes through h/w descriptor in one specified rx ring,
2432 * receives the data if the descriptor status shows the data is ready.
2433 * It returns a chain of mblks containing the received data, to be
2434 * passed up to mac_rx_ring().
2435 */
2436 mblk_t *
2437 ql_ring_rx(struct rx_ring *rx_ring, int poll_bytes)
2438 {
2439 qlge_t *qlge = rx_ring->qlge;
2440 uint32_t prod = ql_read_sh_reg(qlge, rx_ring);
2441 struct ib_mac_iocb_rsp *net_rsp;
2442 mblk_t *mp;
2443 mblk_t *mblk_head;
2444 mblk_t **mblk_tail;
2445 uint32_t received_bytes = 0;
2446 uint32_t length;
2447 #ifdef QLGE_PERFORMANCE
2448 uint32_t pkt_ct = 0;
2449 #endif
2450
2451 #ifdef QLGE_TRACK_BUFFER_USAGE
2452 uint32_t consumer_idx;
2453 uint32_t producer_idx;
2454 uint32_t num_free_entries;
2455 uint32_t temp;
2456
2457 temp = ql_read_doorbell_reg(qlge, rx_ring->cnsmr_idx_db_reg);
2458 consumer_idx = temp & 0x0000ffff;
2459 producer_idx = (temp >> 16);
2460
2461 if (consumer_idx > producer_idx)
2462 num_free_entries = (consumer_idx - producer_idx);
2463 else
2464 num_free_entries = NUM_RX_RING_ENTRIES - (
2465 producer_idx - consumer_idx);
2466
2467 if (num_free_entries < qlge->cq_low_count[rx_ring->cq_id])
2468 qlge->cq_low_count[rx_ring->cq_id] = num_free_entries;
2469
2470 #endif
2471 mblk_head = NULL;
2472 mblk_tail = &mblk_head;
2473
2474 while ((prod != rx_ring->cnsmr_idx)) {
2475 QL_PRINT(DBG_RX,
2476 ("%s cq_id = %d, prod = %d, cnsmr = %d.\n",
2477 __func__, rx_ring->cq_id, prod, rx_ring->cnsmr_idx));
2478
2479 net_rsp = (struct ib_mac_iocb_rsp *)rx_ring->curr_entry;
2480 (void) ddi_dma_sync(rx_ring->cq_dma.dma_handle,
2481 (off_t)((uintptr_t)net_rsp -
2482 (uintptr_t)rx_ring->cq_dma.vaddr),
2483 (size_t)sizeof (*net_rsp), DDI_DMA_SYNC_FORKERNEL);
2484 QL_DUMP(DBG_RX, "qlge_ring_rx: rx completion iocb\n",
2485 rx_ring->curr_entry, 8, (size_t)sizeof (*net_rsp));
2486
2487 switch (net_rsp->opcode) {
2488
2489 case OPCODE_IB_MAC_IOCB:
2490 /* Adding length of pkt header and payload */
2491 length = le32_to_cpu(net_rsp->data_len) +
2492 le32_to_cpu(net_rsp->hdr_len);
2493 if ((poll_bytes != QLGE_POLL_ALL) &&
2494 ((received_bytes + length) > poll_bytes)) {
2495 continue;
2496 }
2497 received_bytes += length;
2498
2499 #ifdef QLGE_PERFORMANCE
2500 pkt_ct++;
2501 #endif
2502 mp = ql_build_rx_mp(qlge, rx_ring, net_rsp);
2503 if (mp != NULL) {
2504 if (rx_ring->mac_flags != QL_MAC_STARTED) {
2505 /*
2506 * Increment number of packets we have
2507 * indicated to the stack, should be
2508 * decremented when we get it back
2509 * or when freemsg is called
2510 */
2511 ASSERT(rx_ring->rx_indicate
2512 <= rx_ring->cq_len);
2513 #ifdef QLGE_LOAD_UNLOAD
2514 cmn_err(CE_WARN, "%s do not send to OS,"
2515 " mac_flags %d, indicate %d",
2516 __func__, rx_ring->mac_flags,
2517 rx_ring->rx_indicate);
2518 #endif
2519 QL_PRINT(DBG_RX,
2520 ("cq_id = %d, packet "
2521 "dropped, mac not "
2522 "enabled.\n",
2523 rx_ring->cq_id));
2524 rx_ring->rx_pkt_dropped_mac_unenabled++;
2525
2526 /* rx_lock is expected to be held */
2527 mutex_exit(&rx_ring->rx_lock);
2528 freemsg(mp);
2529 mutex_enter(&rx_ring->rx_lock);
2530 mp = NULL;
2531 }
2532
2533 if (mp != NULL) {
2534 /*
2535 * IP full packet has been
2536 * successfully verified by
2537 * H/W and is correct
2538 */
2539 ql_set_rx_cksum(mp, net_rsp);
2540
2541 rx_ring->rx_packets++;
2542 rx_ring->rx_bytes += length;
2543 *mblk_tail = mp;
2544 mblk_tail = &mp->b_next;
2545 }
2546 } else {
2547 QL_PRINT(DBG_RX,
2548 ("cq_id = %d, packet dropped\n",
2549 rx_ring->cq_id));
2550 rx_ring->rx_packets_dropped_no_buffer++;
2551 }
2552 break;
2553
2554 case OPCODE_IB_SYS_EVENT_IOCB:
2555 ql_process_chip_ae_intr(qlge,
2556 (struct ib_sys_event_iocb_rsp *)
2557 net_rsp);
2558 break;
2559
2560 default:
2561 cmn_err(CE_WARN,
2562 "%s Ring(%d)Hit default case, not handled!"
2563 " dropping the packet, "
2564 "opcode = %x.", __func__, rx_ring->cq_id,
2565 net_rsp->opcode);
2566 break;
2567 }
2568 /* increment cnsmr_idx and curr_entry */
2569 ql_update_cq(rx_ring);
2570 prod = ql_read_sh_reg(qlge, rx_ring);
2571
2572 }
2573
2574 #ifdef QLGE_PERFORMANCE
2575 if (pkt_ct >= 7)
2576 rx_ring->hist[7]++;
2577 else if (pkt_ct == 6)
2578 rx_ring->hist[6]++;
2579 else if (pkt_ct == 5)
2580 rx_ring->hist[5]++;
2581 else if (pkt_ct == 4)
2582 rx_ring->hist[4]++;
2583 else if (pkt_ct == 3)
2584 rx_ring->hist[3]++;
2585 else if (pkt_ct == 2)
2586 rx_ring->hist[2]++;
2587 else if (pkt_ct == 1)
2588 rx_ring->hist[1]++;
2589 else if (pkt_ct == 0)
2590 rx_ring->hist[0]++;
2591 #endif
2592
2593 /* update cnsmr_idx */
2594 ql_write_cq_idx(rx_ring);
2595 /* do not enable interrupt for polling mode */
2596 if (poll_bytes == QLGE_POLL_ALL)
2597 ql_enable_completion_interrupt(rx_ring->qlge, rx_ring->irq);
2598 return (mblk_head);
2599 }
2600
2601 /* Process an outbound completion from an rx ring. */
2602 static void
2603 ql_process_mac_tx_intr(qlge_t *qlge, struct ob_mac_iocb_rsp *mac_rsp)
2604 {
2605 struct tx_ring *tx_ring;
2606 struct tx_ring_desc *tx_ring_desc;
2607 int j;
2608
2609 tx_ring = &qlge->tx_ring[mac_rsp->txq_idx];
2610 tx_ring_desc = tx_ring->wq_desc;
2611 tx_ring_desc += mac_rsp->tid;
2612
2613 if (tx_ring_desc->tx_type == USE_DMA) {
2614 QL_PRINT(DBG_TX, ("%s(%d): tx type USE_DMA\n",
2615 __func__, qlge->instance));
2616
2617 /*
2618 * Release the DMA resource that is used for
2619 * DMA binding.
2620 */
2621 for (j = 0; j < tx_ring_desc->tx_dma_handle_used; j++) {
2622 (void) ddi_dma_unbind_handle(
2623 tx_ring_desc->tx_dma_handle[j]);
2624 }
2625
2626 tx_ring_desc->tx_dma_handle_used = 0;
2627 /*
2628 * Free the mblk after sending completed
2629 */
2630 if (tx_ring_desc->mp != NULL) {
2631 freemsg(tx_ring_desc->mp);
2632 tx_ring_desc->mp = NULL;
2633 }
2634 }
2635
2636 tx_ring->obytes += tx_ring_desc->tx_bytes;
2637 tx_ring->opackets++;
2638
2639 if (mac_rsp->flags1 & (OB_MAC_IOCB_RSP_E | OB_MAC_IOCB_RSP_S |
2640 OB_MAC_IOCB_RSP_L | OB_MAC_IOCB_RSP_B)) {
2641 tx_ring->errxmt++;
2642 if (mac_rsp->flags1 & OB_MAC_IOCB_RSP_E) {
2643 /* EMPTY */
2644 QL_PRINT(DBG_TX,
2645 ("Total descriptor length did not match "
2646 "transfer length.\n"));
2647 }
2648 if (mac_rsp->flags1 & OB_MAC_IOCB_RSP_S) {
2649 /* EMPTY */
2650 QL_PRINT(DBG_TX,
2651 ("Frame too short to be legal, not sent.\n"));
2652 }
2653 if (mac_rsp->flags1 & OB_MAC_IOCB_RSP_L) {
2654 /* EMPTY */
2655 QL_PRINT(DBG_TX,
2656 ("Frame too long, but sent anyway.\n"));
2657 }
2658 if (mac_rsp->flags3 & OB_MAC_IOCB_RSP_B) {
2659 /* EMPTY */
2660 QL_PRINT(DBG_TX,
2661 ("PCI backplane error. Frame not sent.\n"));
2662 }
2663 }
2664 atomic_inc_32(&tx_ring->tx_free_count);
2665 }
2666
2667 /*
2668 * clean up tx completion iocbs
2669 */
2670 int
2671 ql_clean_outbound_rx_ring(struct rx_ring *rx_ring)
2672 {
2673 qlge_t *qlge = rx_ring->qlge;
2674 uint32_t prod = ql_read_sh_reg(qlge, rx_ring);
2675 struct ob_mac_iocb_rsp *net_rsp = NULL;
2676 int count = 0;
2677 struct tx_ring *tx_ring;
2678 boolean_t resume_tx = B_FALSE;
2679
2680 mutex_enter(&rx_ring->rx_lock);
2681 #ifdef QLGE_TRACK_BUFFER_USAGE
2682 {
2683 uint32_t consumer_idx;
2684 uint32_t producer_idx;
2685 uint32_t num_free_entries;
2686 uint32_t temp;
2687
2688 temp = ql_read_doorbell_reg(qlge, rx_ring->cnsmr_idx_db_reg);
2689 consumer_idx = temp & 0x0000ffff;
2690 producer_idx = (temp >> 16);
2691
2692 if (consumer_idx > producer_idx)
2693 num_free_entries = (consumer_idx - producer_idx);
2694 else
2695 num_free_entries = NUM_RX_RING_ENTRIES -
2696 (producer_idx - consumer_idx);
2697
2698 if (num_free_entries < qlge->cq_low_count[rx_ring->cq_id])
2699 qlge->cq_low_count[rx_ring->cq_id] = num_free_entries;
2700
2701 }
2702 #endif
2703 /* While there are entries in the completion queue. */
2704 while (prod != rx_ring->cnsmr_idx) {
2705
2706 QL_PRINT(DBG_RX,
2707 ("%s cq_id = %d, prod = %d, cnsmr = %d.\n", __func__,
2708 rx_ring->cq_id, prod, rx_ring->cnsmr_idx));
2709
2710 net_rsp = (struct ob_mac_iocb_rsp *)rx_ring->curr_entry;
2711 (void) ddi_dma_sync(rx_ring->cq_dma.dma_handle,
2712 (off_t)((uintptr_t)net_rsp -
2713 (uintptr_t)rx_ring->cq_dma.vaddr),
2714 (size_t)sizeof (*net_rsp), DDI_DMA_SYNC_FORKERNEL);
2715
2716 QL_DUMP(DBG_RX, "ql_clean_outbound_rx_ring: "
2717 "response packet data\n",
2718 rx_ring->curr_entry, 8,
2719 (size_t)sizeof (*net_rsp));
2720
2721 switch (net_rsp->opcode) {
2722
2723 case OPCODE_OB_MAC_OFFLOAD_IOCB:
2724 case OPCODE_OB_MAC_IOCB:
2725 ql_process_mac_tx_intr(qlge, net_rsp);
2726 break;
2727
2728 default:
2729 cmn_err(CE_WARN,
2730 "%s Hit default case, not handled! "
2731 "dropping the packet,"
2732 " opcode = %x.",
2733 __func__, net_rsp->opcode);
2734 break;
2735 }
2736 count++;
2737 ql_update_cq(rx_ring);
2738 prod = ql_read_sh_reg(qlge, rx_ring);
2739 }
2740 ql_write_cq_idx(rx_ring);
2741
2742 mutex_exit(&rx_ring->rx_lock);
2743
2744 net_rsp = (struct ob_mac_iocb_rsp *)rx_ring->curr_entry;
2745 tx_ring = &qlge->tx_ring[net_rsp->txq_idx];
2746
2747 mutex_enter(&tx_ring->tx_lock);
2748
2749 if (tx_ring->queue_stopped &&
2750 (tx_ring->tx_free_count > TX_RESUME_THRESHOLD)) {
2751 /*
2752 * The queue got stopped because the tx_ring was full.
2753 * Wake it up, because it's now at least 25% empty.
2754 */
2755 tx_ring->queue_stopped = 0;
2756 resume_tx = B_TRUE;
2757 }
2758
2759 mutex_exit(&tx_ring->tx_lock);
2760 /* Don't hold the lock during OS callback */
2761 if (resume_tx)
2762 RESUME_TX(tx_ring);
2763 return (count);
2764 }
2765
2766 /*
2767 * reset asic when error happens
2768 */
2769 /* ARGSUSED */
2770 static uint_t
2771 ql_asic_reset_work(caddr_t arg1, caddr_t arg2)
2772 {
2773 qlge_t *qlge = (qlge_t *)((void *)arg1);
2774 int status;
2775
2776 mutex_enter(&qlge->gen_mutex);
2777 (void) ql_do_stop(qlge);
2778 /*
2779 * Write default ethernet address to chip register Mac
2780 * Address slot 0 and Enable Primary Mac Function.
2781 */
2782 mutex_enter(&qlge->hw_mutex);
2783 (void) ql_unicst_set(qlge,
2784 (uint8_t *)qlge->unicst_addr[0].addr.ether_addr_octet, 0);
2785 mutex_exit(&qlge->hw_mutex);
2786 qlge->mac_flags = QL_MAC_INIT;
2787 status = ql_do_start(qlge);
2788 if (status != DDI_SUCCESS)
2789 goto error;
2790 qlge->mac_flags = QL_MAC_STARTED;
2791 mutex_exit(&qlge->gen_mutex);
2792 ddi_fm_service_impact(qlge->dip, DDI_SERVICE_RESTORED);
2793
2794 return (DDI_INTR_CLAIMED);
2795
2796 error:
2797 mutex_exit(&qlge->gen_mutex);
2798 cmn_err(CE_WARN,
2799 "qlge up/down cycle failed, closing device");
2800 if (qlge->fm_enable) {
2801 ql_fm_ereport(qlge, DDI_FM_DEVICE_INVAL_STATE);
2802 ddi_fm_service_impact(qlge->dip, DDI_SERVICE_LOST);
2803 atomic_or_32(&qlge->flags, ADAPTER_ERROR);
2804 }
2805 return (DDI_INTR_CLAIMED);
2806 }
2807
2808 /*
2809 * Reset MPI
2810 */
2811 /* ARGSUSED */
2812 static uint_t
2813 ql_mpi_reset_work(caddr_t arg1, caddr_t arg2)
2814 {
2815 qlge_t *qlge = (qlge_t *)((void *)arg1);
2816
2817 (void) ql_reset_mpi_risc(qlge);
2818 return (DDI_INTR_CLAIMED);
2819 }
2820
2821 /*
2822 * Process MPI mailbox messages
2823 */
2824 /* ARGSUSED */
2825 static uint_t
2826 ql_mpi_event_work(caddr_t arg1, caddr_t arg2)
2827 {
2828 qlge_t *qlge = (qlge_t *)((void *)arg1);
2829
2830 ql_do_mpi_intr(qlge);
2831 return (DDI_INTR_CLAIMED);
2832 }
2833
2834 /* Fire up a handler to reset the MPI processor. */
2835 void
2836 ql_wake_asic_reset_soft_intr(qlge_t *qlge)
2837 {
2838 (void) ddi_intr_trigger_softint(qlge->asic_reset_intr_hdl, NULL);
2839 }
2840
2841 static void
2842 ql_wake_mpi_reset_soft_intr(qlge_t *qlge)
2843 {
2844 (void) ddi_intr_trigger_softint(qlge->mpi_reset_intr_hdl, NULL);
2845 }
2846
2847 static void
2848 ql_wake_mpi_event_soft_intr(qlge_t *qlge)
2849 {
2850 (void) ddi_intr_trigger_softint(qlge->mpi_event_intr_hdl, NULL);
2851 }
2852
2853 /*
2854 * This handles a fatal error, MPI activity, and the default
2855 * rx_ring in an MSI-X multiple interrupt vector environment.
2856 * In MSI/Legacy environment it also process the rest of
2857 * the rx_rings.
2858 */
2859 /* ARGSUSED */
2860 static uint_t
2861 ql_isr(caddr_t arg1, caddr_t arg2)
2862 {
2863 struct rx_ring *rx_ring = (struct rx_ring *)((void *)arg1);
2864 struct rx_ring *ob_ring;
2865 qlge_t *qlge = rx_ring->qlge;
2866 struct intr_ctx *intr_ctx = &qlge->intr_ctx[0];
2867 uint32_t var, prod;
2868 int i;
2869 int work_done = 0;
2870
2871 mblk_t *mp;
2872
2873 _NOTE(ARGUNUSED(arg2));
2874
2875 ++qlge->rx_interrupts[rx_ring->cq_id];
2876
2877 if (ql_atomic_read_32(&qlge->intr_ctx[0].irq_cnt)) {
2878 ql_write_reg(qlge, REG_RSVD7, 0xfeed0002);
2879 var = ql_read_reg(qlge, REG_ERROR_STATUS);
2880 var = ql_read_reg(qlge, REG_STATUS);
2881 var = ql_read_reg(qlge, REG_INTERRUPT_STATUS_1);
2882 return (DDI_INTR_CLAIMED);
2883 }
2884
2885 ql_disable_completion_interrupt(qlge, intr_ctx->intr);
2886
2887 /*
2888 * process send completes on first stride tx ring if available
2889 */
2890 if (qlge->isr_stride) {
2891 ob_ring = &qlge->rx_ring[qlge->isr_stride];
2892 if (ql_read_sh_reg(qlge, ob_ring) !=
2893 ob_ring->cnsmr_idx) {
2894 (void) ql_clean_outbound_rx_ring(ob_ring);
2895 }
2896 }
2897 /*
2898 * Check the default queue and wake handler if active.
2899 */
2900 rx_ring = &qlge->rx_ring[0];
2901 prod = ql_read_sh_reg(qlge, rx_ring);
2902 QL_PRINT(DBG_INTR, ("rx-ring[0] prod index 0x%x, consumer 0x%x ",
2903 prod, rx_ring->cnsmr_idx));
2904 /* check if interrupt is due to incoming packet */
2905 if (prod != rx_ring->cnsmr_idx) {
2906 QL_PRINT(DBG_INTR, ("Waking handler for rx_ring[0].\n"));
2907 ql_disable_completion_interrupt(qlge, intr_ctx->intr);
2908 mutex_enter(&rx_ring->rx_lock);
2909 mp = ql_ring_rx(rx_ring, QLGE_POLL_ALL);
2910 mutex_exit(&rx_ring->rx_lock);
2911
2912 if (mp != NULL)
2913 RX_UPSTREAM(rx_ring, mp);
2914 work_done++;
2915 } else {
2916 /*
2917 * If interrupt is not due to incoming packet, read status
2918 * register to see if error happens or mailbox interrupt.
2919 */
2920 var = ql_read_reg(qlge, REG_STATUS);
2921 if ((var & STATUS_FE) != 0) {
2922 ql_write_reg(qlge, REG_RSVD7, 0xfeed0003);
2923 if (qlge->fm_enable) {
2924 atomic_or_32(&qlge->flags, ADAPTER_ERROR);
2925 ql_fm_ereport(qlge, DDI_FM_DEVICE_INVAL_STATE);
2926 ddi_fm_service_impact(qlge->dip,
2927 DDI_SERVICE_LOST);
2928 }
2929 cmn_err(CE_WARN, "Got fatal error, STS = %x.", var);
2930 var = ql_read_reg(qlge, REG_ERROR_STATUS);
2931 cmn_err(CE_WARN,
2932 "Resetting chip. Error Status Register = 0x%x",
2933 var);
2934 ql_wake_asic_reset_soft_intr(qlge);
2935 return (DDI_INTR_CLAIMED);
2936 }
2937
2938 /*
2939 * Check MPI processor activity.
2940 */
2941 if ((var & STATUS_PI) != 0) {
2942 /*
2943 * We've got an async event or mailbox completion.
2944 * Handle it and clear the source of the interrupt.
2945 */
2946 ql_write_reg(qlge, REG_RSVD7, 0xfeed0004);
2947
2948 QL_PRINT(DBG_INTR, ("Got MPI processor interrupt.\n"));
2949 ql_disable_completion_interrupt(qlge, intr_ctx->intr);
2950 ql_wake_mpi_event_soft_intr(qlge);
2951 work_done++;
2952 }
2953 }
2954
2955
2956 if (qlge->intr_type != DDI_INTR_TYPE_MSIX) {
2957 /*
2958 * Start the DPC for each active queue.
2959 */
2960 for (i = 1; i < qlge->rx_ring_count; i++) {
2961 rx_ring = &qlge->rx_ring[i];
2962
2963 if (ql_read_sh_reg(qlge, rx_ring) !=
2964 rx_ring->cnsmr_idx) {
2965 QL_PRINT(DBG_INTR,
2966 ("Waking handler for rx_ring[%d].\n", i));
2967
2968 ql_disable_completion_interrupt(qlge,
2969 rx_ring->irq);
2970 if (rx_ring->type == TX_Q) {
2971 (void) ql_clean_outbound_rx_ring(
2972 rx_ring);
2973 ql_enable_completion_interrupt(
2974 rx_ring->qlge, rx_ring->irq);
2975 } else {
2976 mutex_enter(&rx_ring->rx_lock);
2977 mp = ql_ring_rx(rx_ring, QLGE_POLL_ALL);
2978 mutex_exit(&rx_ring->rx_lock);
2979 if (mp != NULL)
2980 RX_UPSTREAM(rx_ring, mp);
2981 #ifdef QLGE_LOAD_UNLOAD
2982 if (rx_ring->mac_flags ==
2983 QL_MAC_STOPPED)
2984 cmn_err(CE_NOTE,
2985 "%s rx_indicate(%d) %d\n",
2986 __func__, i,
2987 rx_ring->rx_indicate);
2988 #endif
2989 }
2990 work_done++;
2991 }
2992 }
2993 }
2994
2995 ql_enable_completion_interrupt(qlge, intr_ctx->intr);
2996
2997 return (work_done ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED);
2998 }
2999
3000 /*
3001 * MSI-X Multiple Vector Interrupt Handler for outbound (TX) completions.
3002 */
3003 /* ARGSUSED */
3004 static uint_t
3005 ql_msix_tx_isr(caddr_t arg1, caddr_t arg2)
3006 {
3007 struct rx_ring *rx_ring = (struct rx_ring *)((void *)arg1);
3008 qlge_t *qlge = rx_ring->qlge;
3009 _NOTE(ARGUNUSED(arg2));
3010
3011 ++qlge->rx_interrupts[rx_ring->cq_id];
3012 (void) ql_clean_outbound_rx_ring(rx_ring);
3013 ql_enable_completion_interrupt(rx_ring->qlge, rx_ring->irq);
3014
3015 return (DDI_INTR_CLAIMED);
3016 }
3017
3018 /*
3019 * MSI-X Multiple Vector Interrupt Handler
3020 */
3021 /* ARGSUSED */
3022 static uint_t
3023 ql_msix_isr(caddr_t arg1, caddr_t arg2)
3024 {
3025 struct rx_ring *rx_ring = (struct rx_ring *)((void *)arg1);
3026 struct rx_ring *ob_ring;
3027 qlge_t *qlge = rx_ring->qlge;
3028 mblk_t *mp;
3029 _NOTE(ARGUNUSED(arg2));
3030
3031 QL_PRINT(DBG_INTR, ("%s for ring %d\n", __func__, rx_ring->cq_id));
3032
3033 ql_disable_completion_interrupt(qlge, rx_ring->irq);
3034
3035 /*
3036 * process send completes on stride tx ring if available
3037 */
3038 if (qlge->isr_stride) {
3039 ob_ring = rx_ring + qlge->isr_stride;
3040 if (ql_read_sh_reg(qlge, ob_ring) !=
3041 ob_ring->cnsmr_idx) {
3042 ++qlge->rx_interrupts[ob_ring->cq_id];
3043 (void) ql_clean_outbound_rx_ring(ob_ring);
3044 }
3045 }
3046
3047 ++qlge->rx_interrupts[rx_ring->cq_id];
3048
3049 mutex_enter(&rx_ring->rx_lock);
3050 mp = ql_ring_rx(rx_ring, QLGE_POLL_ALL);
3051 mutex_exit(&rx_ring->rx_lock);
3052
3053 if (mp != NULL)
3054 RX_UPSTREAM(rx_ring, mp);
3055
3056 return (DDI_INTR_CLAIMED);
3057 }
3058
3059 /*
3060 * Poll n_bytes of chained incoming packets
3061 */
3062 mblk_t *
3063 ql_ring_rx_poll(void *arg, int n_bytes)
3064 {
3065 struct rx_ring *rx_ring = (struct rx_ring *)arg;
3066 qlge_t *qlge = rx_ring->qlge;
3067 mblk_t *mp = NULL;
3068 uint32_t var;
3069
3070 ASSERT(n_bytes >= 0);
3071 QL_PRINT(DBG_GLD, ("%s for ring(%d) to read max %d bytes\n",
3072 __func__, rx_ring->cq_id, n_bytes));
3073
3074 ++qlge->rx_polls[rx_ring->cq_id];
3075
3076 if (n_bytes == 0)
3077 return (mp);
3078 mutex_enter(&rx_ring->rx_lock);
3079 mp = ql_ring_rx(rx_ring, n_bytes);
3080 mutex_exit(&rx_ring->rx_lock);
3081
3082 if ((rx_ring->cq_id == 0) && (mp == NULL)) {
3083 var = ql_read_reg(qlge, REG_STATUS);
3084 /*
3085 * Check for fatal error.
3086 */
3087 if ((var & STATUS_FE) != 0) {
3088 ql_write_reg(qlge, REG_RSVD7, 0xfeed0003);
3089 var = ql_read_reg(qlge, REG_ERROR_STATUS);
3090 cmn_err(CE_WARN, "Got fatal error %x.", var);
3091 ql_wake_asic_reset_soft_intr(qlge);
3092 if (qlge->fm_enable) {
3093 atomic_or_32(&qlge->flags, ADAPTER_ERROR);
3094 ql_fm_ereport(qlge, DDI_FM_DEVICE_INVAL_STATE);
3095 ddi_fm_service_impact(qlge->dip,
3096 DDI_SERVICE_LOST);
3097 }
3098 }
3099 /*
3100 * Check MPI processor activity.
3101 */
3102 if ((var & STATUS_PI) != 0) {
3103 /*
3104 * We've got an async event or mailbox completion.
3105 * Handle it and clear the source of the interrupt.
3106 */
3107 ql_write_reg(qlge, REG_RSVD7, 0xfeed0004);
3108 ql_do_mpi_intr(qlge);
3109 }
3110 }
3111
3112 return (mp);
3113 }
3114
3115 /*
3116 * MSI-X Multiple Vector Interrupt Handler for inbound (RX) completions.
3117 */
3118 /* ARGSUSED */
3119 static uint_t
3120 ql_msix_rx_isr(caddr_t arg1, caddr_t arg2)
3121 {
3122 struct rx_ring *rx_ring = (struct rx_ring *)((void *)arg1);
3123 qlge_t *qlge = rx_ring->qlge;
3124 mblk_t *mp;
3125 _NOTE(ARGUNUSED(arg2));
3126
3127 QL_PRINT(DBG_INTR, ("%s for ring %d\n", __func__, rx_ring->cq_id));
3128
3129 ++qlge->rx_interrupts[rx_ring->cq_id];
3130
3131 mutex_enter(&rx_ring->rx_lock);
3132 mp = ql_ring_rx(rx_ring, QLGE_POLL_ALL);
3133 mutex_exit(&rx_ring->rx_lock);
3134
3135 if (mp != NULL)
3136 RX_UPSTREAM(rx_ring, mp);
3137
3138 return (DDI_INTR_CLAIMED);
3139 }
3140
3141
3142 /*
3143 *
3144 * Allocate DMA Buffer for ioctl service
3145 *
3146 */
3147 static int
3148 ql_alloc_ioctl_dma_buf(qlge_t *qlge)
3149 {
3150 uint64_t phy_addr;
3151 uint64_t alloc_size;
3152 ddi_dma_cookie_t dma_cookie;
3153
3154 alloc_size = qlge->ioctl_buf_dma_attr.mem_len =
3155 max(WCS_MPI_CODE_RAM_LENGTH, MEMC_MPI_RAM_LENGTH);
3156 if (ql_alloc_phys(qlge->dip, &qlge->ioctl_buf_dma_attr.dma_handle,
3157 &ql_buf_acc_attr,
3158 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3159 &qlge->ioctl_buf_dma_attr.acc_handle,
3160 (size_t)alloc_size, /* mem size */
3161 (size_t)0, /* alignment */
3162 (caddr_t *)&qlge->ioctl_buf_dma_attr.vaddr,
3163 &dma_cookie) != 0) {
3164 cmn_err(CE_WARN, "%s(%d): ioctl DMA allocation failed.",
3165 __func__, qlge->instance);
3166 return (DDI_FAILURE);
3167 }
3168
3169 phy_addr = dma_cookie.dmac_laddress;
3170
3171 if (qlge->ioctl_buf_dma_attr.vaddr == NULL) {
3172 cmn_err(CE_WARN, "%s(%d): failed.", __func__, qlge->instance);
3173 return (DDI_FAILURE);
3174 }
3175
3176 qlge->ioctl_buf_dma_attr.dma_addr = phy_addr;
3177
3178 QL_PRINT(DBG_MBX, ("%s: ioctl_dma_buf_virt_addr = 0x%lx, "
3179 "phy_addr = 0x%lx\n",
3180 __func__, qlge->ioctl_buf_dma_attr.vaddr, phy_addr));
3181
3182 return (DDI_SUCCESS);
3183 }
3184
3185
3186 /*
3187 * Function to free physical memory.
3188 */
3189 static void
3190 ql_free_phys(ddi_dma_handle_t *dma_handle, ddi_acc_handle_t *acc_handle)
3191 {
3192 if (*dma_handle != NULL) {
3193 (void) ddi_dma_unbind_handle(*dma_handle);
3194 if (*acc_handle != NULL)
3195 ddi_dma_mem_free(acc_handle);
3196 ddi_dma_free_handle(dma_handle);
3197 *acc_handle = NULL;
3198 *dma_handle = NULL;
3199 }
3200 }
3201
3202 /*
3203 * Function to free ioctl dma buffer.
3204 */
3205 static void
3206 ql_free_ioctl_dma_buf(qlge_t *qlge)
3207 {
3208 if (qlge->ioctl_buf_dma_attr.dma_handle != NULL) {
3209 ql_free_phys(&qlge->ioctl_buf_dma_attr.dma_handle,
3210 &qlge->ioctl_buf_dma_attr.acc_handle);
3211
3212 qlge->ioctl_buf_dma_attr.vaddr = NULL;
3213 qlge->ioctl_buf_dma_attr.dma_handle = NULL;
3214 }
3215 }
3216
3217 /*
3218 * Free shadow register space used for request and completion queues
3219 */
3220 static void
3221 ql_free_shadow_space(qlge_t *qlge)
3222 {
3223 if (qlge->host_copy_shadow_dma_attr.dma_handle != NULL) {
3224 ql_free_phys(&qlge->host_copy_shadow_dma_attr.dma_handle,
3225 &qlge->host_copy_shadow_dma_attr.acc_handle);
3226 bzero(&qlge->host_copy_shadow_dma_attr,
3227 sizeof (qlge->host_copy_shadow_dma_attr));
3228 }
3229
3230 if (qlge->buf_q_ptr_base_addr_dma_attr.dma_handle != NULL) {
3231 ql_free_phys(&qlge->buf_q_ptr_base_addr_dma_attr.dma_handle,
3232 &qlge->buf_q_ptr_base_addr_dma_attr.acc_handle);
3233 bzero(&qlge->buf_q_ptr_base_addr_dma_attr,
3234 sizeof (qlge->buf_q_ptr_base_addr_dma_attr));
3235 }
3236 }
3237
3238 /*
3239 * Allocate shadow register space for request and completion queues
3240 */
3241 static int
3242 ql_alloc_shadow_space(qlge_t *qlge)
3243 {
3244 ddi_dma_cookie_t dma_cookie;
3245
3246 if (ql_alloc_phys(qlge->dip,
3247 &qlge->host_copy_shadow_dma_attr.dma_handle,
3248 &ql_dev_acc_attr,
3249 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3250 &qlge->host_copy_shadow_dma_attr.acc_handle,
3251 (size_t)VM_PAGE_SIZE, /* mem size */
3252 (size_t)4, /* 4 bytes alignment */
3253 (caddr_t *)&qlge->host_copy_shadow_dma_attr.vaddr,
3254 &dma_cookie) != 0) {
3255 bzero(&qlge->host_copy_shadow_dma_attr,
3256 sizeof (qlge->host_copy_shadow_dma_attr));
3257
3258 cmn_err(CE_WARN, "%s(%d): Unable to allocate DMA memory for "
3259 "response shadow registers", __func__, qlge->instance);
3260 return (DDI_FAILURE);
3261 }
3262
3263 qlge->host_copy_shadow_dma_attr.dma_addr = dma_cookie.dmac_laddress;
3264
3265 if (ql_alloc_phys(qlge->dip,
3266 &qlge->buf_q_ptr_base_addr_dma_attr.dma_handle,
3267 &ql_desc_acc_attr,
3268 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3269 &qlge->buf_q_ptr_base_addr_dma_attr.acc_handle,
3270 (size_t)VM_PAGE_SIZE, /* mem size */
3271 (size_t)4, /* 4 bytes alignment */
3272 (caddr_t *)&qlge->buf_q_ptr_base_addr_dma_attr.vaddr,
3273 &dma_cookie) != 0) {
3274 bzero(&qlge->buf_q_ptr_base_addr_dma_attr,
3275 sizeof (qlge->buf_q_ptr_base_addr_dma_attr));
3276
3277 cmn_err(CE_WARN, "%s(%d): Unable to allocate DMA memory "
3278 "for request shadow registers",
3279 __func__, qlge->instance);
3280 goto err_wqp_sh_area;
3281 }
3282 qlge->buf_q_ptr_base_addr_dma_attr.dma_addr = dma_cookie.dmac_laddress;
3283
3284 return (DDI_SUCCESS);
3285
3286 err_wqp_sh_area:
3287 ql_free_phys(&qlge->host_copy_shadow_dma_attr.dma_handle,
3288 &qlge->host_copy_shadow_dma_attr.acc_handle);
3289 bzero(&qlge->host_copy_shadow_dma_attr,
3290 sizeof (qlge->host_copy_shadow_dma_attr));
3291
3292 return (DDI_FAILURE);
3293 }
3294
3295 /*
3296 * Initialize a tx ring
3297 */
3298 static void
3299 ql_init_tx_ring(struct tx_ring *tx_ring)
3300 {
3301 int i;
3302 struct ob_mac_iocb_req *mac_iocb_ptr = tx_ring->wq_dma.vaddr;
3303 struct tx_ring_desc *tx_ring_desc = tx_ring->wq_desc;
3304
3305 for (i = 0; i < tx_ring->wq_len; i++) {
3306 tx_ring_desc->index = i;
3307 tx_ring_desc->queue_entry = mac_iocb_ptr;
3308 mac_iocb_ptr++;
3309 tx_ring_desc++;
3310 }
3311 tx_ring->tx_free_count = tx_ring->wq_len;
3312 tx_ring->queue_stopped = 0;
3313 }
3314
3315 /*
3316 * Free one tx ring resources
3317 */
3318 static void
3319 ql_free_tx_resources(struct tx_ring *tx_ring)
3320 {
3321 struct tx_ring_desc *tx_ring_desc;
3322 int i, j;
3323
3324 if (tx_ring->wq_dma.dma_handle != NULL) {
3325 ql_free_phys(&tx_ring->wq_dma.dma_handle,
3326 &tx_ring->wq_dma.acc_handle);
3327 bzero(&tx_ring->wq_dma, sizeof (tx_ring->wq_dma));
3328 }
3329 if (tx_ring->wq_desc != NULL) {
3330 tx_ring_desc = tx_ring->wq_desc;
3331 for (i = 0; i < tx_ring->wq_len; i++, tx_ring_desc++) {
3332 for (j = 0; j < QL_MAX_TX_DMA_HANDLES; j++) {
3333 if (tx_ring_desc->tx_dma_handle[j]) {
3334 /*
3335 * The unbinding will happen in tx
3336 * completion, here we just free the
3337 * handles
3338 */
3339 ddi_dma_free_handle(
3340 &(tx_ring_desc->tx_dma_handle[j]));
3341 tx_ring_desc->tx_dma_handle[j] = NULL;
3342 }
3343 }
3344 if (tx_ring_desc->oal != NULL) {
3345 tx_ring_desc->oal_dma_addr = 0;
3346 tx_ring_desc->oal = NULL;
3347 tx_ring_desc->copy_buffer = NULL;
3348 tx_ring_desc->copy_buffer_dma_addr = 0;
3349
3350 ql_free_phys(&tx_ring_desc->oal_dma.dma_handle,
3351 &tx_ring_desc->oal_dma.acc_handle);
3352 }
3353 }
3354 kmem_free(tx_ring->wq_desc,
3355 tx_ring->wq_len * sizeof (struct tx_ring_desc));
3356 tx_ring->wq_desc = NULL;
3357 }
3358 /* free the wqicb struct */
3359 if (tx_ring->wqicb_dma.dma_handle) {
3360 ql_free_phys(&tx_ring->wqicb_dma.dma_handle,
3361 &tx_ring->wqicb_dma.acc_handle);
3362 bzero(&tx_ring->wqicb_dma, sizeof (tx_ring->wqicb_dma));
3363 }
3364 }
3365
3366 /*
3367 * Allocate work (request) queue memory and transmit
3368 * descriptors for this transmit ring
3369 */
3370 static int
3371 ql_alloc_tx_resources(qlge_t *qlge, struct tx_ring *tx_ring)
3372 {
3373 ddi_dma_cookie_t dma_cookie;
3374 struct tx_ring_desc *tx_ring_desc;
3375 int i, j;
3376 uint32_t length;
3377
3378 /* allocate dma buffers for obiocbs */
3379 if (ql_alloc_phys(qlge->dip, &tx_ring->wq_dma.dma_handle,
3380 &ql_desc_acc_attr,
3381 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3382 &tx_ring->wq_dma.acc_handle,
3383 (size_t)tx_ring->wq_size, /* mem size */
3384 (size_t)128, /* alignment:128 bytes boundary */
3385 (caddr_t *)&tx_ring->wq_dma.vaddr,
3386 &dma_cookie) != 0) {
3387 bzero(&tx_ring->wq_dma, sizeof (&tx_ring->wq_dma));
3388 cmn_err(CE_WARN, "%s(%d): reqQ allocation failed.",
3389 __func__, qlge->instance);
3390 return (DDI_FAILURE);
3391 }
3392 tx_ring->wq_dma.dma_addr = dma_cookie.dmac_laddress;
3393
3394 tx_ring->wq_desc =
3395 kmem_zalloc(tx_ring->wq_len * sizeof (struct tx_ring_desc),
3396 KM_NOSLEEP);
3397 if (tx_ring->wq_desc == NULL) {
3398 goto err;
3399 } else {
3400 tx_ring_desc = tx_ring->wq_desc;
3401 /*
3402 * Allocate a large enough structure to hold the following
3403 * 1. oal buffer MAX_SGELEMENTS * sizeof (oal_entry) bytes
3404 * 2. copy buffer of QL_MAX_COPY_LENGTH bytes
3405 */
3406 length = (sizeof (struct oal_entry) * MAX_SG_ELEMENTS)
3407 + QL_MAX_COPY_LENGTH;
3408 for (i = 0; i < tx_ring->wq_len; i++, tx_ring_desc++) {
3409
3410 if (ql_alloc_phys(qlge->dip,
3411 &tx_ring_desc->oal_dma.dma_handle,
3412 &ql_desc_acc_attr,
3413 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3414 &tx_ring_desc->oal_dma.acc_handle,
3415 (size_t)length, /* mem size */
3416 (size_t)0, /* default alignment:8 bytes boundary */
3417 (caddr_t *)&tx_ring_desc->oal_dma.vaddr,
3418 &dma_cookie) != 0) {
3419 bzero(&tx_ring_desc->oal_dma,
3420 sizeof (tx_ring_desc->oal_dma));
3421 cmn_err(CE_WARN, "%s(%d): reqQ tx buf &"
3422 "oal alloc failed.",
3423 __func__, qlge->instance);
3424 goto err;
3425 }
3426
3427 tx_ring_desc->oal = tx_ring_desc->oal_dma.vaddr;
3428 tx_ring_desc->oal_dma_addr = dma_cookie.dmac_laddress;
3429 tx_ring_desc->copy_buffer =
3430 (caddr_t)((uint8_t *)tx_ring_desc->oal
3431 + (sizeof (struct oal_entry) * MAX_SG_ELEMENTS));
3432 tx_ring_desc->copy_buffer_dma_addr =
3433 (tx_ring_desc->oal_dma_addr
3434 + (sizeof (struct oal_entry) * MAX_SG_ELEMENTS));
3435
3436 /* Allocate dma handles for transmit buffers */
3437 for (j = 0; j < QL_MAX_TX_DMA_HANDLES; j++) {
3438 if (ddi_dma_alloc_handle(qlge->dip,
3439 &tx_mapping_dma_attr,
3440 DDI_DMA_DONTWAIT,
3441 0, &tx_ring_desc->tx_dma_handle[j])
3442 != DDI_SUCCESS) {
3443 tx_ring_desc->tx_dma_handle[j] = NULL;
3444 cmn_err(CE_WARN,
3445 "!%s: ddi_dma_alloc_handle: "
3446 "tx_dma_handle "
3447 "alloc failed", __func__);
3448 ql_free_phys(
3449 &tx_ring_desc->oal_dma.dma_handle,
3450 &tx_ring_desc->oal_dma.acc_handle);
3451 goto err;
3452 }
3453 }
3454 }
3455 }
3456 /* alloc a wqicb control block to load this tx ring to hw */
3457 if (ql_alloc_phys(qlge->dip, &tx_ring->wqicb_dma.dma_handle,
3458 &ql_desc_acc_attr,
3459 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3460 &tx_ring->wqicb_dma.acc_handle,
3461 (size_t)sizeof (struct wqicb_t), /* mem size */
3462 (size_t)0, /* alignment:128 bytes boundary */
3463 (caddr_t *)&tx_ring->wqicb_dma.vaddr,
3464 &dma_cookie) != 0) {
3465 bzero(&tx_ring->wqicb_dma, sizeof (tx_ring->wqicb_dma));
3466 cmn_err(CE_WARN, "%s(%d): wqicb allocation failed.",
3467 __func__, qlge->instance);
3468 goto err;
3469 }
3470 tx_ring->wqicb_dma.dma_addr = dma_cookie.dmac_laddress;
3471
3472 return (DDI_SUCCESS);
3473
3474 err:
3475 ql_free_tx_resources(tx_ring);
3476 return (DDI_FAILURE);
3477 }
3478
3479 /*
3480 * Free one rx ring resources
3481 */
3482 static void
3483 ql_free_rx_resources(struct rx_ring *rx_ring)
3484 {
3485 /* Free the small buffer queue. */
3486 if (rx_ring->sbq_dma.dma_handle) {
3487 ql_free_phys(&rx_ring->sbq_dma.dma_handle,
3488 &rx_ring->sbq_dma.acc_handle);
3489 bzero(&rx_ring->sbq_dma, sizeof (rx_ring->sbq_dma));
3490 }
3491
3492 /* Free the small buffer queue control blocks. */
3493 if (rx_ring->sbq_desc != NULL) {
3494 kmem_free(rx_ring->sbq_desc, rx_ring->sbq_len *
3495 sizeof (struct bq_desc));
3496 rx_ring->sbq_desc = NULL;
3497 }
3498
3499 /* Free the large buffer queue. */
3500 if (rx_ring->lbq_dma.dma_handle) {
3501 ql_free_phys(&rx_ring->lbq_dma.dma_handle,
3502 &rx_ring->lbq_dma.acc_handle);
3503 bzero(&rx_ring->lbq_dma, sizeof (rx_ring->lbq_dma));
3504 }
3505
3506 /* Free the large buffer queue control blocks. */
3507 if (rx_ring->lbq_desc != NULL) {
3508 kmem_free(rx_ring->lbq_desc, rx_ring->lbq_len *
3509 sizeof (struct bq_desc));
3510 rx_ring->lbq_desc = NULL;
3511 }
3512
3513 /* Free cqicb struct */
3514 if (rx_ring->cqicb_dma.dma_handle) {
3515 ql_free_phys(&rx_ring->cqicb_dma.dma_handle,
3516 &rx_ring->cqicb_dma.acc_handle);
3517 bzero(&rx_ring->cqicb_dma, sizeof (rx_ring->cqicb_dma));
3518 }
3519 /* Free the rx queue. */
3520 if (rx_ring->cq_dma.dma_handle) {
3521 ql_free_phys(&rx_ring->cq_dma.dma_handle,
3522 &rx_ring->cq_dma.acc_handle);
3523 bzero(&rx_ring->cq_dma, sizeof (rx_ring->cq_dma));
3524 }
3525 }
3526
3527 /*
3528 * Allocate queues and buffers for this completions queue based
3529 * on the values in the parameter structure.
3530 */
3531 static int
3532 ql_alloc_rx_resources(qlge_t *qlge, struct rx_ring *rx_ring)
3533 {
3534 ddi_dma_cookie_t dma_cookie;
3535
3536 if (ql_alloc_phys(qlge->dip, &rx_ring->cq_dma.dma_handle,
3537 &ql_desc_acc_attr,
3538 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3539 &rx_ring->cq_dma.acc_handle,
3540 (size_t)rx_ring->cq_size, /* mem size */
3541 (size_t)128, /* alignment:128 bytes boundary */
3542 (caddr_t *)&rx_ring->cq_dma.vaddr,
3543 &dma_cookie) != 0) {
3544 bzero(&rx_ring->cq_dma, sizeof (rx_ring->cq_dma));
3545 cmn_err(CE_WARN, "%s(%d): rspQ allocation failed.",
3546 __func__, qlge->instance);
3547 return (DDI_FAILURE);
3548 }
3549 rx_ring->cq_dma.dma_addr = dma_cookie.dmac_laddress;
3550
3551 if (rx_ring->sbq_len != 0) {
3552 /*
3553 * Allocate small buffer queue.
3554 */
3555 if (ql_alloc_phys(qlge->dip, &rx_ring->sbq_dma.dma_handle,
3556 &ql_desc_acc_attr,
3557 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3558 &rx_ring->sbq_dma.acc_handle,
3559 (size_t)rx_ring->sbq_size, /* mem size */
3560 (size_t)128, /* alignment:128 bytes boundary */
3561 (caddr_t *)&rx_ring->sbq_dma.vaddr,
3562 &dma_cookie) != 0) {
3563 bzero(&rx_ring->sbq_dma, sizeof (rx_ring->sbq_dma));
3564 cmn_err(CE_WARN,
3565 "%s(%d): small buffer queue allocation failed.",
3566 __func__, qlge->instance);
3567 goto err_mem;
3568 }
3569 rx_ring->sbq_dma.dma_addr = dma_cookie.dmac_laddress;
3570
3571 /*
3572 * Allocate small buffer queue control blocks.
3573 */
3574 rx_ring->sbq_desc =
3575 kmem_zalloc(rx_ring->sbq_len * sizeof (struct bq_desc),
3576 KM_NOSLEEP);
3577 if (rx_ring->sbq_desc == NULL) {
3578 cmn_err(CE_WARN,
3579 "sbq control block allocation failed.");
3580 goto err_mem;
3581 }
3582
3583 ql_init_sbq_ring(rx_ring);
3584 }
3585
3586 if (rx_ring->lbq_len != 0) {
3587 /*
3588 * Allocate large buffer queue.
3589 */
3590 if (ql_alloc_phys(qlge->dip, &rx_ring->lbq_dma.dma_handle,
3591 &ql_desc_acc_attr,
3592 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3593 &rx_ring->lbq_dma.acc_handle,
3594 (size_t)rx_ring->lbq_size, /* mem size */
3595 (size_t)128, /* alignment:128 bytes boundary */
3596 (caddr_t *)&rx_ring->lbq_dma.vaddr,
3597 &dma_cookie) != 0) {
3598 bzero(&rx_ring->lbq_dma, sizeof (rx_ring->lbq_dma));
3599 cmn_err(CE_WARN, "%s(%d): lbq allocation failed.",
3600 __func__, qlge->instance);
3601 goto err_mem;
3602 }
3603 rx_ring->lbq_dma.dma_addr = dma_cookie.dmac_laddress;
3604
3605 /*
3606 * Allocate large buffer queue control blocks.
3607 */
3608 rx_ring->lbq_desc =
3609 kmem_zalloc(rx_ring->lbq_len * sizeof (struct bq_desc),
3610 KM_NOSLEEP);
3611 if (rx_ring->lbq_desc == NULL) {
3612 cmn_err(CE_WARN,
3613 "Large buffer queue control block allocation "
3614 "failed.");
3615 goto err_mem;
3616 }
3617 ql_init_lbq_ring(rx_ring);
3618 }
3619
3620 if (ql_alloc_phys(qlge->dip, &rx_ring->cqicb_dma.dma_handle,
3621 &ql_desc_acc_attr,
3622 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3623 &rx_ring->cqicb_dma.acc_handle,
3624 (size_t)sizeof (struct cqicb_t), /* mem size */
3625 (size_t)0, /* alignment:128 bytes boundary */
3626 (caddr_t *)&rx_ring->cqicb_dma.vaddr,
3627 &dma_cookie) != 0) {
3628 bzero(&rx_ring->cqicb_dma, sizeof (rx_ring->cqicb_dma));
3629 cmn_err(CE_WARN, "%s(%d): cqicb allocation failed.",
3630 __func__, qlge->instance);
3631 goto err_mem;
3632 }
3633 rx_ring->cqicb_dma.dma_addr = dma_cookie.dmac_laddress;
3634
3635 return (DDI_SUCCESS);
3636
3637 err_mem:
3638 ql_free_rx_resources(rx_ring);
3639 return (DDI_FAILURE);
3640 }
3641
3642 /*
3643 * Frees tx/rx queues memory resources
3644 */
3645 static void
3646 ql_free_mem_resources(qlge_t *qlge)
3647 {
3648 int i;
3649
3650 if (qlge->ricb_dma.dma_handle) {
3651 /* free the ricb struct */
3652 ql_free_phys(&qlge->ricb_dma.dma_handle,
3653 &qlge->ricb_dma.acc_handle);
3654 bzero(&qlge->ricb_dma, sizeof (qlge->ricb_dma));
3655 }
3656
3657 ql_free_rx_buffers(qlge);
3658
3659 ql_free_ioctl_dma_buf(qlge);
3660
3661 for (i = 0; i < qlge->tx_ring_count; i++)
3662 ql_free_tx_resources(&qlge->tx_ring[i]);
3663
3664 for (i = 0; i < qlge->rx_ring_count; i++)
3665 ql_free_rx_resources(&qlge->rx_ring[i]);
3666
3667 ql_free_shadow_space(qlge);
3668 }
3669
3670 /*
3671 * Allocate buffer queues, large buffers and small buffers etc
3672 *
3673 * This API is called in the gld_attach member function. It is called
3674 * only once. Later reset,reboot should not re-allocate all rings and
3675 * buffers.
3676 */
3677 static int
3678 ql_alloc_mem_resources(qlge_t *qlge)
3679 {
3680 int i;
3681 ddi_dma_cookie_t dma_cookie;
3682
3683 /* Allocate space for our shadow registers */
3684 if (ql_alloc_shadow_space(qlge))
3685 return (DDI_FAILURE);
3686
3687 for (i = 0; i < qlge->rx_ring_count; i++) {
3688 if (ql_alloc_rx_resources(qlge, &qlge->rx_ring[i]) != 0) {
3689 cmn_err(CE_WARN, "RX resource allocation failed.");
3690 goto err_mem;
3691 }
3692 }
3693 /* Allocate tx queue resources */
3694 for (i = 0; i < qlge->tx_ring_count; i++) {
3695 if (ql_alloc_tx_resources(qlge, &qlge->tx_ring[i]) != 0) {
3696 cmn_err(CE_WARN, "Tx resource allocation failed.");
3697 goto err_mem;
3698 }
3699 }
3700
3701 if (ql_alloc_ioctl_dma_buf(qlge) != DDI_SUCCESS) {
3702 goto err_mem;
3703 }
3704
3705 if (ql_alloc_rx_buffers(qlge) != DDI_SUCCESS) {
3706 cmn_err(CE_WARN, "?%s(%d): ql_alloc_rx_buffers failed",
3707 __func__, qlge->instance);
3708 goto err_mem;
3709 }
3710
3711 qlge->sequence |= INIT_ALLOC_RX_BUF;
3712
3713 if (ql_alloc_phys(qlge->dip, &qlge->ricb_dma.dma_handle,
3714 &ql_desc_acc_attr,
3715 DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
3716 &qlge->ricb_dma.acc_handle,
3717 (size_t)sizeof (struct ricb), /* mem size */
3718 (size_t)0, /* alignment:128 bytes boundary */
3719 (caddr_t *)&qlge->ricb_dma.vaddr,
3720 &dma_cookie) != 0) {
3721 bzero(&qlge->ricb_dma, sizeof (qlge->ricb_dma));
3722 cmn_err(CE_WARN, "%s(%d): ricb allocation failed.",
3723 __func__, qlge->instance);
3724 goto err_mem;
3725 }
3726 qlge->ricb_dma.dma_addr = dma_cookie.dmac_laddress;
3727
3728 return (DDI_SUCCESS);
3729
3730 err_mem:
3731 ql_free_mem_resources(qlge);
3732 return (DDI_FAILURE);
3733 }
3734
3735
3736 /*
3737 * Function used to allocate physical memory and zero it.
3738 */
3739
3740 static int
3741 ql_alloc_phys_rbuf(dev_info_t *dip, ddi_dma_handle_t *dma_handle,
3742 ddi_device_acc_attr_t *device_acc_attr,
3743 uint_t dma_flags,
3744 ddi_acc_handle_t *acc_handle,
3745 size_t size,
3746 size_t alignment,
3747 caddr_t *vaddr,
3748 ddi_dma_cookie_t *dma_cookie)
3749 {
3750 size_t rlen;
3751 uint_t cnt;
3752
3753 /*
3754 * Workaround for SUN XMITS buffer must end and start on 8 byte
3755 * boundary. Else, hardware will overrun the buffer. Simple fix is
3756 * to make sure buffer has enough room for overrun.
3757 */
3758 if (size & 7) {
3759 size += 8 - (size & 7);
3760 }
3761
3762 /* Adjust the alignment if requested */
3763 if (alignment) {
3764 dma_attr.dma_attr_align = alignment;
3765 }
3766
3767 /*
3768 * Allocate DMA handle
3769 */
3770 if (ddi_dma_alloc_handle(dip, &dma_attr_rbuf, DDI_DMA_DONTWAIT, NULL,
3771 dma_handle) != DDI_SUCCESS) {
3772 cmn_err(CE_WARN, QL_BANG "%s: ddi_dma_alloc_handle FAILED",
3773 __func__);
3774 *dma_handle = NULL;
3775 return (QL_ERROR);
3776 }
3777 /*
3778 * Allocate DMA memory
3779 */
3780 if (ddi_dma_mem_alloc(*dma_handle, size, device_acc_attr,
3781 dma_flags & (DDI_DMA_CONSISTENT|DDI_DMA_STREAMING),
3782 DDI_DMA_DONTWAIT,
3783 NULL, vaddr, &rlen, acc_handle) != DDI_SUCCESS) {
3784 cmn_err(CE_WARN, "alloc_phys: DMA Memory alloc Failed");
3785 ddi_dma_free_handle(dma_handle);
3786 *acc_handle = NULL;
3787 *dma_handle = NULL;
3788 return (QL_ERROR);
3789 }
3790
3791 if (ddi_dma_addr_bind_handle(*dma_handle, NULL, *vaddr, rlen,
3792 dma_flags, DDI_DMA_DONTWAIT, NULL,
3793 dma_cookie, &cnt) != DDI_DMA_MAPPED) {
3794 ddi_dma_mem_free(acc_handle);
3795
3796 ddi_dma_free_handle(dma_handle);
3797 cmn_err(CE_WARN, "%s ddi_dma_addr_bind_handle FAILED",
3798 __func__);
3799 *acc_handle = NULL;
3800 *dma_handle = NULL;
3801 return (QL_ERROR);
3802 }
3803
3804 if (cnt != 1) {
3805
3806 ql_free_phys(dma_handle, acc_handle);
3807
3808 cmn_err(CE_WARN, "%s: cnt != 1; Failed segment count",
3809 __func__);
3810 return (QL_ERROR);
3811 }
3812
3813 bzero((caddr_t)*vaddr, rlen);
3814
3815 return (0);
3816 }
3817
3818 /*
3819 * Function used to allocate physical memory and zero it.
3820 */
3821 static int
3822 ql_alloc_phys(dev_info_t *dip, ddi_dma_handle_t *dma_handle,
3823 ddi_device_acc_attr_t *device_acc_attr,
3824 uint_t dma_flags,
3825 ddi_acc_handle_t *acc_handle,
3826 size_t size,
3827 size_t alignment,
3828 caddr_t *vaddr,
3829 ddi_dma_cookie_t *dma_cookie)
3830 {
3831 size_t rlen;
3832 uint_t cnt;
3833
3834 /*
3835 * Workaround for SUN XMITS buffer must end and start on 8 byte
3836 * boundary. Else, hardware will overrun the buffer. Simple fix is
3837 * to make sure buffer has enough room for overrun.
3838 */
3839 if (size & 7) {
3840 size += 8 - (size & 7);
3841 }
3842
3843 /* Adjust the alignment if requested */
3844 if (alignment) {
3845 dma_attr.dma_attr_align = alignment;
3846 }
3847
3848 /*
3849 * Allocate DMA handle
3850 */
3851 if (ddi_dma_alloc_handle(dip, &dma_attr, DDI_DMA_DONTWAIT, NULL,
3852 dma_handle) != DDI_SUCCESS) {
3853 cmn_err(CE_WARN, QL_BANG "%s: ddi_dma_alloc_handle FAILED",
3854 __func__);
3855 *dma_handle = NULL;
3856 return (QL_ERROR);
3857 }
3858 /*
3859 * Allocate DMA memory
3860 */
3861 if (ddi_dma_mem_alloc(*dma_handle, size, device_acc_attr,
3862 dma_flags & (DDI_DMA_CONSISTENT|DDI_DMA_STREAMING),
3863 DDI_DMA_DONTWAIT,
3864 NULL, vaddr, &rlen, acc_handle) != DDI_SUCCESS) {
3865 cmn_err(CE_WARN, "alloc_phys: DMA Memory alloc Failed");
3866 ddi_dma_free_handle(dma_handle);
3867 *acc_handle = NULL;
3868 *dma_handle = NULL;
3869 return (QL_ERROR);
3870 }
3871
3872 if (ddi_dma_addr_bind_handle(*dma_handle, NULL, *vaddr, rlen,
3873 dma_flags, DDI_DMA_DONTWAIT, NULL,
3874 dma_cookie, &cnt) != DDI_DMA_MAPPED) {
3875 ddi_dma_mem_free(acc_handle);
3876 ddi_dma_free_handle(dma_handle);
3877 cmn_err(CE_WARN, "%s ddi_dma_addr_bind_handle FAILED",
3878 __func__);
3879 *acc_handle = NULL;
3880 *dma_handle = NULL;
3881 return (QL_ERROR);
3882 }
3883
3884 if (cnt != 1) {
3885
3886 ql_free_phys(dma_handle, acc_handle);
3887
3888 cmn_err(CE_WARN, "%s: cnt != 1; Failed segment count",
3889 __func__);
3890 return (QL_ERROR);
3891 }
3892
3893 bzero((caddr_t)*vaddr, rlen);
3894
3895 return (0);
3896 }
3897
3898 /*
3899 * Add interrupt handlers based on the interrupt type.
3900 * Before adding the interrupt handlers, the interrupt vectors should
3901 * have been allocated, and the rx/tx rings have also been allocated.
3902 */
3903 static int
3904 ql_add_intr_handlers(qlge_t *qlge)
3905 {
3906 int vector = 0;
3907 int rc, i;
3908 uint32_t value;
3909 struct intr_ctx *intr_ctx = &qlge->intr_ctx[0];
3910
3911 switch (qlge->intr_type) {
3912 case DDI_INTR_TYPE_MSIX:
3913 /*
3914 * Add interrupt handler for rx and tx rings: vector[0 -
3915 * (qlge->intr_cnt -1)].
3916 */
3917 value = 0;
3918 for (vector = 0; vector < qlge->intr_cnt; vector++) {
3919 ql_atomic_set_32(&intr_ctx->irq_cnt, value);
3920
3921 /*
3922 * associate interrupt vector with interrupt handler
3923 */
3924 rc = ddi_intr_add_handler(qlge->htable[vector],
3925 (ddi_intr_handler_t *)intr_ctx->handler,
3926 (void *)&qlge->rx_ring[vector], NULL);
3927
3928 QL_PRINT(DBG_INIT, ("rx_ring[%d] 0x%p\n",
3929 vector, &qlge->rx_ring[vector]));
3930 if (rc != DDI_SUCCESS) {
3931 QL_PRINT(DBG_INIT,
3932 ("Add rx interrupt handler failed. "
3933 "return: %d, vector: %d", rc, vector));
3934 for (vector--; vector >= 0; vector--) {
3935 (void) ddi_intr_remove_handler(
3936 qlge->htable[vector]);
3937 }
3938 return (DDI_FAILURE);
3939 }
3940 intr_ctx++;
3941 }
3942 break;
3943
3944 case DDI_INTR_TYPE_MSI:
3945 /*
3946 * Add interrupt handlers for the only vector
3947 */
3948 ql_atomic_set_32(&intr_ctx->irq_cnt, value);
3949
3950 rc = ddi_intr_add_handler(qlge->htable[vector],
3951 ql_isr,
3952 (caddr_t)&qlge->rx_ring[0], NULL);
3953
3954 if (rc != DDI_SUCCESS) {
3955 QL_PRINT(DBG_INIT,
3956 ("Add MSI interrupt handler failed: %d\n", rc));
3957 return (DDI_FAILURE);
3958 }
3959 break;
3960
3961 case DDI_INTR_TYPE_FIXED:
3962 /*
3963 * Add interrupt handlers for the only vector
3964 */
3965 ql_atomic_set_32(&intr_ctx->irq_cnt, value);
3966
3967 rc = ddi_intr_add_handler(qlge->htable[vector],
3968 ql_isr,
3969 (caddr_t)&qlge->rx_ring[0], NULL);
3970
3971 if (rc != DDI_SUCCESS) {
3972 QL_PRINT(DBG_INIT,
3973 ("Add legacy interrupt handler failed: %d\n", rc));
3974 return (DDI_FAILURE);
3975 }
3976 break;
3977
3978 default:
3979 return (DDI_FAILURE);
3980 }
3981
3982 /* Enable interrupts */
3983 /* Block enable */
3984 if (qlge->intr_cap & DDI_INTR_FLAG_BLOCK) {
3985 QL_PRINT(DBG_INIT, ("Block enabling %d interrupt(s)\n",
3986 qlge->intr_cnt));
3987 (void) ddi_intr_block_enable(qlge->htable, qlge->intr_cnt);
3988 } else { /* Non block enable */
3989 for (i = 0; i < qlge->intr_cnt; i++) {
3990 QL_PRINT(DBG_INIT, ("Non Block Enabling interrupt %d "
3991 "handle 0x%x\n", i, qlge->htable[i]));
3992 (void) ddi_intr_enable(qlge->htable[i]);
3993 }
3994 }
3995 qlge->sequence |= INIT_INTR_ENABLED;
3996
3997 return (DDI_SUCCESS);
3998 }
3999
4000 /*
4001 * Here we build the intr_ctx structures based on
4002 * our rx_ring count and intr vector count.
4003 * The intr_ctx structure is used to hook each vector
4004 * to possibly different handlers.
4005 */
4006 static void
4007 ql_resolve_queues_to_irqs(qlge_t *qlge)
4008 {
4009 int i = 0;
4010 struct intr_ctx *intr_ctx = &qlge->intr_ctx[0];
4011
4012 if (qlge->intr_type == DDI_INTR_TYPE_MSIX) {
4013 /*
4014 * Each rx_ring has its own intr_ctx since we
4015 * have separate vectors for each queue.
4016 * This only true when MSI-X is enabled.
4017 */
4018 for (i = 0; i < qlge->intr_cnt; i++, intr_ctx++) {
4019 qlge->rx_ring[i].irq = i;
4020 intr_ctx->intr = i;
4021 intr_ctx->qlge = qlge;
4022
4023 /*
4024 * We set up each vectors enable/disable/read bits so
4025 * there's no bit/mask calculations in critical path.
4026 */
4027 intr_ctx->intr_en_mask =
4028 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4029 INTR_EN_TYPE_ENABLE | INTR_EN_IHD_MASK |
4030 INTR_EN_IHD | i;
4031 intr_ctx->intr_dis_mask =
4032 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4033 INTR_EN_TYPE_DISABLE | INTR_EN_IHD_MASK |
4034 INTR_EN_IHD | i;
4035 intr_ctx->intr_read_mask =
4036 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4037 INTR_EN_TYPE_READ | INTR_EN_IHD_MASK | INTR_EN_IHD
4038 | i;
4039
4040 if (i == 0) {
4041 /*
4042 * Default queue handles bcast/mcast plus
4043 * async events.
4044 */
4045 intr_ctx->handler = ql_isr;
4046 } else if (qlge->rx_ring[i].type == TX_Q) {
4047 /*
4048 * Outbound queue is for outbound completions
4049 * only.
4050 */
4051 if (qlge->isr_stride)
4052 intr_ctx->handler = ql_msix_isr;
4053 else
4054 intr_ctx->handler = ql_msix_tx_isr;
4055 } else {
4056 /*
4057 * Inbound queues handle unicast frames only.
4058 */
4059 if (qlge->isr_stride)
4060 intr_ctx->handler = ql_msix_isr;
4061 else
4062 intr_ctx->handler = ql_msix_rx_isr;
4063 }
4064 }
4065 i = qlge->intr_cnt;
4066 for (; i < qlge->rx_ring_count; i++, intr_ctx++) {
4067 int iv = i - qlge->isr_stride;
4068 qlge->rx_ring[i].irq = iv;
4069 intr_ctx->intr = iv;
4070 intr_ctx->qlge = qlge;
4071
4072 /*
4073 * We set up each vectors enable/disable/read bits so
4074 * there's no bit/mask calculations in critical path.
4075 */
4076 intr_ctx->intr_en_mask =
4077 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4078 INTR_EN_TYPE_ENABLE | INTR_EN_IHD_MASK |
4079 INTR_EN_IHD | iv;
4080 intr_ctx->intr_dis_mask =
4081 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4082 INTR_EN_TYPE_DISABLE | INTR_EN_IHD_MASK |
4083 INTR_EN_IHD | iv;
4084 intr_ctx->intr_read_mask =
4085 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4086 INTR_EN_TYPE_READ | INTR_EN_IHD_MASK | INTR_EN_IHD
4087 | iv;
4088
4089 if (qlge->rx_ring[i].type == TX_Q) {
4090 /*
4091 * Outbound queue is for outbound completions
4092 * only.
4093 */
4094 intr_ctx->handler = ql_msix_isr;
4095 } else {
4096 /*
4097 * Inbound queues handle unicast frames only.
4098 */
4099 intr_ctx->handler = ql_msix_rx_isr;
4100 }
4101 }
4102 } else {
4103 /*
4104 * All rx_rings use the same intr_ctx since
4105 * there is only one vector.
4106 */
4107 intr_ctx->intr = 0;
4108 intr_ctx->qlge = qlge;
4109 /*
4110 * We set up each vectors enable/disable/read bits so
4111 * there's no bit/mask calculations in the critical path.
4112 */
4113 intr_ctx->intr_en_mask =
4114 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4115 INTR_EN_TYPE_ENABLE;
4116 intr_ctx->intr_dis_mask =
4117 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4118 INTR_EN_TYPE_DISABLE;
4119 intr_ctx->intr_read_mask =
4120 INTR_EN_TYPE_MASK | INTR_EN_INTR_MASK |
4121 INTR_EN_TYPE_READ;
4122 /*
4123 * Single interrupt means one handler for all rings.
4124 */
4125 intr_ctx->handler = ql_isr;
4126 for (i = 0; i < qlge->rx_ring_count; i++)
4127 qlge->rx_ring[i].irq = 0;
4128 }
4129 }
4130
4131
4132 /*
4133 * Free allocated interrupts.
4134 */
4135 static void
4136 ql_free_irq_vectors(qlge_t *qlge)
4137 {
4138 int i;
4139 int rc;
4140
4141 if (qlge->sequence & INIT_INTR_ENABLED) {
4142 /* Disable all interrupts */
4143 if (qlge->intr_cap & DDI_INTR_FLAG_BLOCK) {
4144 /* Call ddi_intr_block_disable() */
4145 (void) ddi_intr_block_disable(qlge->htable,
4146 qlge->intr_cnt);
4147 } else {
4148 for (i = 0; i < qlge->intr_cnt; i++) {
4149 (void) ddi_intr_disable(qlge->htable[i]);
4150 }
4151 }
4152
4153 qlge->sequence &= ~INIT_INTR_ENABLED;
4154 }
4155
4156 for (i = 0; i < qlge->intr_cnt; i++) {
4157
4158 if (qlge->sequence & INIT_ADD_INTERRUPT)
4159 (void) ddi_intr_remove_handler(qlge->htable[i]);
4160
4161 if (qlge->sequence & INIT_INTR_ALLOC) {
4162 rc = ddi_intr_free(qlge->htable[i]);
4163 if (rc != DDI_SUCCESS) {
4164 /* EMPTY */
4165 QL_PRINT(DBG_INIT, ("Free intr failed: %d",
4166 rc));
4167 }
4168 }
4169 }
4170 if (qlge->sequence & INIT_INTR_ALLOC)
4171 qlge->sequence &= ~INIT_INTR_ALLOC;
4172
4173 if (qlge->sequence & INIT_ADD_INTERRUPT)
4174 qlge->sequence &= ~INIT_ADD_INTERRUPT;
4175
4176 if (qlge->htable) {
4177 kmem_free(qlge->htable, qlge->intr_size);
4178 qlge->htable = NULL;
4179 }
4180 }
4181
4182 /*
4183 * Allocate interrupt vectors
4184 * For legacy and MSI, only 1 handle is needed.
4185 * For MSI-X, if fewer than 2 vectors are available, return failure.
4186 * Upon success, this maps the vectors to rx and tx rings for
4187 * interrupts.
4188 */
4189 static int
4190 ql_request_irq_vectors(qlge_t *qlge, int intr_type)
4191 {
4192 dev_info_t *devinfo;
4193 uint32_t request, orig;
4194 int count, avail, actual;
4195 int minimum;
4196 int rc;
4197
4198 devinfo = qlge->dip;
4199
4200 switch (intr_type) {
4201 case DDI_INTR_TYPE_FIXED:
4202 request = 1; /* Request 1 legacy interrupt handle */
4203 minimum = 1;
4204 QL_PRINT(DBG_INIT, ("interrupt type: legacy\n"));
4205 break;
4206
4207 case DDI_INTR_TYPE_MSI:
4208 request = 1; /* Request 1 MSI interrupt handle */
4209 minimum = 1;
4210 QL_PRINT(DBG_INIT, ("interrupt type: MSI\n"));
4211 break;
4212
4213 case DDI_INTR_TYPE_MSIX:
4214 /*
4215 * Ideal number of vectors for the adapter is
4216 * # rss rings + tx completion rings for default completion
4217 * queue.
4218 */
4219 request = qlge->rx_ring_count;
4220
4221 orig = request;
4222 if (request > (MAX_RX_RINGS))
4223 request = MAX_RX_RINGS;
4224 minimum = 2;
4225 QL_PRINT(DBG_INIT, ("interrupt type: MSI-X\n"));
4226 break;
4227
4228 default:
4229 QL_PRINT(DBG_INIT, ("Invalid parameter\n"));
4230 return (DDI_FAILURE);
4231 }
4232
4233 QL_PRINT(DBG_INIT, ("interrupt handles requested: %d minimum: %d\n",
4234 request, minimum));
4235
4236 /*
4237 * Get number of supported interrupts
4238 */
4239 rc = ddi_intr_get_nintrs(devinfo, intr_type, &count);
4240 if ((rc != DDI_SUCCESS) || (count < minimum)) {
4241 QL_PRINT(DBG_INIT, ("Get interrupt number failed. Return: %d, "
4242 "count: %d\n", rc, count));
4243 return (DDI_FAILURE);
4244 }
4245 QL_PRINT(DBG_INIT, ("interrupts supported: %d\n", count));
4246
4247 /*
4248 * Get number of available interrupts
4249 */
4250 rc = ddi_intr_get_navail(devinfo, intr_type, &avail);
4251 if ((rc != DDI_SUCCESS) || (avail < minimum)) {
4252 QL_PRINT(DBG_INIT,
4253 ("Get interrupt available number failed. Return:"
4254 " %d, available: %d\n", rc, avail));
4255 return (DDI_FAILURE);
4256 }
4257 QL_PRINT(DBG_INIT, ("interrupts available: %d\n", avail));
4258
4259 if (avail < request) {
4260 QL_PRINT(DBG_INIT, ("Request %d handles, %d available\n",
4261 request, avail));
4262 request = avail;
4263 }
4264
4265 actual = 0;
4266 qlge->intr_cnt = 0;
4267
4268 /*
4269 * Allocate an array of interrupt handles
4270 */
4271 qlge->intr_size = (size_t)(request * sizeof (ddi_intr_handle_t));
4272 qlge->htable = kmem_alloc(qlge->intr_size, KM_SLEEP);
4273
4274 rc = ddi_intr_alloc(devinfo, qlge->htable, intr_type, 0,
4275 (int)request, &actual, DDI_INTR_ALLOC_NORMAL);
4276 if (rc != DDI_SUCCESS) {
4277 cmn_err(CE_WARN, "%s(%d) Allocate interrupts failed. return:"
4278 " %d, request: %d, actual: %d",
4279 __func__, qlge->instance, rc, request, actual);
4280 goto ql_intr_alloc_fail;
4281 }
4282 qlge->intr_cnt = actual;
4283
4284 qlge->sequence |= INIT_INTR_ALLOC;
4285
4286 /*
4287 * If the actual number of vectors is less than the minumum
4288 * then fail.
4289 */
4290 if (actual < minimum) {
4291 cmn_err(CE_WARN,
4292 "Insufficient interrupt handles available: %d", actual);
4293 goto ql_intr_alloc_fail;
4294 }
4295
4296 /*
4297 * For MSI-X, actual might force us to reduce number of tx & rx rings
4298 */
4299 if ((intr_type == DDI_INTR_TYPE_MSIX) && (orig > actual)) {
4300 if (actual >= (orig / 2)) {
4301 count = orig / 2;
4302 qlge->rss_ring_count = count;
4303 qlge->tx_ring_count = count;
4304 qlge->isr_stride = count;
4305 } else if (actual >= (orig / 4)) {
4306 count = orig / 4;
4307 qlge->rss_ring_count = count;
4308 qlge->tx_ring_count = count;
4309 qlge->isr_stride = count;
4310 } else if (actual >= (orig / 8)) {
4311 count = orig / 8;
4312 qlge->rss_ring_count = count;
4313 qlge->tx_ring_count = count;
4314 qlge->isr_stride = count;
4315 } else if (actual < MAX_RX_RINGS) {
4316 qlge->tx_ring_count = 1;
4317 qlge->rss_ring_count = actual - 1;
4318 }
4319 qlge->intr_cnt = count;
4320 qlge->rx_ring_count = qlge->tx_ring_count +
4321 qlge->rss_ring_count;
4322 }
4323 cmn_err(CE_NOTE, "!qlge(%d) tx %d, rss %d, stride %d\n", qlge->instance,
4324 qlge->tx_ring_count, qlge->rss_ring_count, qlge->isr_stride);
4325
4326 /*
4327 * Get priority for first vector, assume remaining are all the same
4328 */
4329 rc = ddi_intr_get_pri(qlge->htable[0], &qlge->intr_pri);
4330 if (rc != DDI_SUCCESS) {
4331 QL_PRINT(DBG_INIT, ("Get interrupt priority failed: %d\n", rc));
4332 goto ql_intr_alloc_fail;
4333 }
4334
4335 rc = ddi_intr_get_cap(qlge->htable[0], &qlge->intr_cap);
4336 if (rc != DDI_SUCCESS) {
4337 QL_PRINT(DBG_INIT, ("Get interrupt cap failed: %d\n", rc));
4338 goto ql_intr_alloc_fail;
4339 }
4340
4341 qlge->intr_type = intr_type;
4342
4343 return (DDI_SUCCESS);
4344
4345 ql_intr_alloc_fail:
4346 ql_free_irq_vectors(qlge);
4347
4348 return (DDI_FAILURE);
4349 }
4350
4351 /*
4352 * Allocate interrupt vector(s) for one of the following interrupt types, MSI-X,
4353 * MSI or Legacy. In MSI and Legacy modes we only support a single receive and
4354 * transmit queue.
4355 */
4356 int
4357 ql_alloc_irqs(qlge_t *qlge)
4358 {
4359 int intr_types;
4360 int rval;
4361
4362 /*
4363 * Get supported interrupt types
4364 */
4365 if (ddi_intr_get_supported_types(qlge->dip, &intr_types)
4366 != DDI_SUCCESS) {
4367 cmn_err(CE_WARN, "%s(%d):ddi_intr_get_supported_types failed",
4368 __func__, qlge->instance);
4369
4370 return (DDI_FAILURE);
4371 }
4372
4373 QL_PRINT(DBG_INIT, ("%s(%d) Interrupt types supported %d\n",
4374 __func__, qlge->instance, intr_types));
4375
4376 /* Install MSI-X interrupts */
4377 if ((intr_types & DDI_INTR_TYPE_MSIX) != 0) {
4378 QL_PRINT(DBG_INIT, ("%s(%d) MSI-X interrupt supported %d\n",
4379 __func__, qlge->instance, intr_types));
4380 rval = ql_request_irq_vectors(qlge, DDI_INTR_TYPE_MSIX);
4381 if (rval == DDI_SUCCESS) {
4382 return (rval);
4383 }
4384 QL_PRINT(DBG_INIT, ("%s(%d) MSI-X interrupt allocation failed,"
4385 " trying MSI interrupts ...\n", __func__, qlge->instance));
4386 }
4387
4388 /*
4389 * We will have 2 completion queues in MSI / Legacy mode,
4390 * Queue 0 for default completions
4391 * Queue 1 for transmit completions
4392 */
4393 qlge->rss_ring_count = 1; /* Default completion queue (0) for all */
4394 qlge->tx_ring_count = 1; /* Single tx completion queue */
4395 qlge->rx_ring_count = qlge->tx_ring_count + qlge->rss_ring_count;
4396
4397 QL_PRINT(DBG_INIT, ("%s(%d) Falling back to single completion queue \n",
4398 __func__, qlge->instance));
4399 /*
4400 * Add the h/w interrupt handler and initialise mutexes
4401 */
4402 rval = DDI_FAILURE;
4403
4404 /*
4405 * If OS supports MSIX interrupt but fails to allocate, then try
4406 * MSI interrupt. If MSI interrupt allocation fails also, then roll
4407 * back to fixed interrupt.
4408 */
4409 if (intr_types & DDI_INTR_TYPE_MSI) {
4410 rval = ql_request_irq_vectors(qlge, DDI_INTR_TYPE_MSI);
4411 if (rval == DDI_SUCCESS) {
4412 qlge->intr_type = DDI_INTR_TYPE_MSI;
4413 QL_PRINT(DBG_INIT, ("%s(%d) use MSI Interrupt \n",
4414 __func__, qlge->instance));
4415 }
4416 }
4417
4418 /* Try Fixed interrupt Legacy mode */
4419 if (rval != DDI_SUCCESS) {
4420 rval = ql_request_irq_vectors(qlge, DDI_INTR_TYPE_FIXED);
4421 if (rval != DDI_SUCCESS) {
4422 cmn_err(CE_WARN, "%s(%d):Legacy mode interrupt "
4423 "allocation failed",
4424 __func__, qlge->instance);
4425 } else {
4426 qlge->intr_type = DDI_INTR_TYPE_FIXED;
4427 QL_PRINT(DBG_INIT, ("%s(%d) use Fixed Interrupt \n",
4428 __func__, qlge->instance));
4429 }
4430 }
4431
4432 return (rval);
4433 }
4434
4435 static void
4436 ql_free_rx_tx_locks(qlge_t *qlge)
4437 {
4438 int i;
4439 struct rx_ring *rx_ring;
4440 struct tx_ring *tx_ring;
4441
4442 for (i = 0; i < qlge->tx_ring_count; i++) {
4443 tx_ring = &qlge->tx_ring[i];
4444 mutex_destroy(&tx_ring->tx_lock);
4445 }
4446
4447 for (i = 0; i < qlge->rx_ring_count; i++) {
4448 rx_ring = &qlge->rx_ring[i];
4449 mutex_destroy(&rx_ring->rx_lock);
4450 mutex_destroy(&rx_ring->sbq_lock);
4451 mutex_destroy(&rx_ring->lbq_lock);
4452 }
4453 }
4454
4455 /*
4456 * Frees all resources allocated during attach.
4457 *
4458 * Input:
4459 * dip = pointer to device information structure.
4460 * sequence = bits indicating resources to free.
4461 *
4462 * Context:
4463 * Kernel context.
4464 */
4465 static void
4466 ql_free_resources(qlge_t *qlge)
4467 {
4468
4469 /* Disable driver timer */
4470 ql_stop_timer(qlge);
4471
4472 if (qlge->sequence & INIT_MAC_REGISTERED) {
4473 (void) mac_unregister(qlge->mh);
4474 qlge->sequence &= ~INIT_MAC_REGISTERED;
4475 }
4476
4477 if (qlge->sequence & INIT_MAC_ALLOC) {
4478 /* Nothing to do, macp is already freed */
4479 qlge->sequence &= ~INIT_MAC_ALLOC;
4480 }
4481
4482 if (qlge->sequence & INIT_PCI_CONFIG_SETUP) {
4483 pci_config_teardown(&qlge->pci_handle);
4484 qlge->sequence &= ~INIT_PCI_CONFIG_SETUP;
4485 }
4486
4487 if (qlge->sequence & INIT_INTR_ALLOC) {
4488 ql_free_irq_vectors(qlge);
4489 qlge->sequence &= ~INIT_ADD_INTERRUPT;
4490 }
4491
4492 if (qlge->sequence & INIT_ADD_SOFT_INTERRUPT) {
4493 (void) ddi_intr_remove_softint(qlge->mpi_event_intr_hdl);
4494 (void) ddi_intr_remove_softint(qlge->mpi_reset_intr_hdl);
4495 (void) ddi_intr_remove_softint(qlge->asic_reset_intr_hdl);
4496 qlge->sequence &= ~INIT_ADD_SOFT_INTERRUPT;
4497 }
4498
4499 if (qlge->sequence & INIT_KSTATS) {
4500 ql_fini_kstats(qlge);
4501 qlge->sequence &= ~INIT_KSTATS;
4502 }
4503
4504 if (qlge->sequence & INIT_MUTEX) {
4505 mutex_destroy(&qlge->gen_mutex);
4506 mutex_destroy(&qlge->hw_mutex);
4507 mutex_destroy(&qlge->mbx_mutex);
4508 cv_destroy(&qlge->cv_mbx_intr);
4509 qlge->sequence &= ~INIT_MUTEX;
4510 }
4511
4512 if (qlge->sequence & INIT_LOCKS_CREATED) {
4513 ql_free_rx_tx_locks(qlge);
4514 qlge->sequence &= ~INIT_LOCKS_CREATED;
4515 }
4516
4517 if (qlge->sequence & INIT_MEMORY_ALLOC) {
4518 ql_free_mem_resources(qlge);
4519 qlge->sequence &= ~INIT_MEMORY_ALLOC;
4520 }
4521
4522 if (qlge->sequence & INIT_REGS_SETUP) {
4523 ddi_regs_map_free(&qlge->dev_handle);
4524 qlge->sequence &= ~INIT_REGS_SETUP;
4525 }
4526
4527 if (qlge->sequence & INIT_DOORBELL_REGS_SETUP) {
4528 ddi_regs_map_free(&qlge->dev_doorbell_reg_handle);
4529 qlge->sequence &= ~INIT_DOORBELL_REGS_SETUP;
4530 }
4531
4532 /*
4533 * free flash flt table that allocated in attach stage
4534 */
4535 if ((qlge->flt.ql_flt_entry_ptr != NULL)&&
4536 (qlge->flt.header.length != 0)) {
4537 kmem_free(qlge->flt.ql_flt_entry_ptr, qlge->flt.header.length);
4538 qlge->flt.ql_flt_entry_ptr = NULL;
4539 }
4540
4541 if (qlge->sequence & INIT_FM) {
4542 ql_fm_fini(qlge);
4543 qlge->sequence &= ~INIT_FM;
4544 }
4545
4546 ddi_prop_remove_all(qlge->dip);
4547 ddi_set_driver_private(qlge->dip, NULL);
4548
4549 /* finally, free qlge structure */
4550 if (qlge->sequence & INIT_SOFTSTATE_ALLOC) {
4551 kmem_free(qlge, sizeof (qlge_t));
4552 }
4553 }
4554
4555 /*
4556 * Set promiscuous mode of the driver
4557 * Caller must catch HW_LOCK
4558 */
4559 void
4560 ql_set_promiscuous(qlge_t *qlge, int mode)
4561 {
4562 if (mode) {
4563 (void) ql_set_routing_reg(qlge, RT_IDX_PROMISCUOUS_SLOT,
4564 RT_IDX_VALID, 1);
4565 } else {
4566 (void) ql_set_routing_reg(qlge, RT_IDX_PROMISCUOUS_SLOT,
4567 RT_IDX_VALID, 0);
4568 }
4569 }
4570 /*
4571 * Write 'data1' to Mac Protocol Address Index Register and
4572 * 'data2' to Mac Protocol Address Data Register
4573 * Assuming that the Mac Protocol semaphore lock has been acquired.
4574 */
4575 static int
4576 ql_write_mac_proto_regs(qlge_t *qlge, uint32_t data1, uint32_t data2)
4577 {
4578 int return_value = DDI_SUCCESS;
4579
4580 if (ql_wait_reg_bit(qlge, REG_MAC_PROTOCOL_ADDRESS_INDEX,
4581 MAC_PROTOCOL_ADDRESS_INDEX_MW, BIT_SET, 5) != DDI_SUCCESS) {
4582 cmn_err(CE_WARN, "Wait for MAC_PROTOCOL Address Register "
4583 "timeout.");
4584 return_value = DDI_FAILURE;
4585 goto out;
4586 }
4587 ql_write_reg(qlge, REG_MAC_PROTOCOL_ADDRESS_INDEX /* A8 */, data1);
4588 ql_write_reg(qlge, REG_MAC_PROTOCOL_DATA /* 0xAC */, data2);
4589 out:
4590 return (return_value);
4591 }
4592 /*
4593 * Enable the 'index'ed multicast address in the host memory's multicast_list
4594 */
4595 int
4596 ql_add_multicast_address(qlge_t *qlge, int index)
4597 {
4598 int rtn_val = DDI_FAILURE;
4599 uint32_t offset;
4600 uint32_t value1, value2;
4601
4602 /* Acquire the required semaphore */
4603 if (ql_sem_spinlock(qlge, QL_MAC_PROTOCOL_SEM_MASK) != DDI_SUCCESS) {
4604 return (rtn_val);
4605 }
4606
4607 /* Program Offset0 - lower 32 bits of the MAC address */
4608 offset = 0;
4609 value1 = MAC_PROTOCOL_ADDRESS_ENABLE | MAC_PROTOCOL_TYPE_MULTICAST |
4610 (index << 4) | offset;
4611 value2 = ((qlge->multicast_list[index].addr.ether_addr_octet[2] << 24)
4612 |(qlge->multicast_list[index].addr.ether_addr_octet[3] << 16)
4613 |(qlge->multicast_list[index].addr.ether_addr_octet[4] << 8)
4614 |(qlge->multicast_list[index].addr.ether_addr_octet[5]));
4615 if (ql_write_mac_proto_regs(qlge, value1, value2) != DDI_SUCCESS)
4616 goto out;
4617
4618 /* Program offset1: upper 16 bits of the MAC address */
4619 offset = 1;
4620 value1 = MAC_PROTOCOL_ADDRESS_ENABLE | MAC_PROTOCOL_TYPE_MULTICAST |
4621 (index<<4) | offset;
4622 value2 = ((qlge->multicast_list[index].addr.ether_addr_octet[0] << 8)
4623 |qlge->multicast_list[index].addr.ether_addr_octet[1]);
4624 if (ql_write_mac_proto_regs(qlge, value1, value2) != DDI_SUCCESS) {
4625 goto out;
4626 }
4627 rtn_val = DDI_SUCCESS;
4628 out:
4629 ql_sem_unlock(qlge, QL_MAC_PROTOCOL_SEM_MASK);
4630 return (rtn_val);
4631 }
4632
4633 /*
4634 * Disable the 'index'ed multicast address in the host memory's multicast_list
4635 */
4636 int
4637 ql_remove_multicast_address(qlge_t *qlge, int index)
4638 {
4639 int rtn_val = DDI_FAILURE;
4640 uint32_t offset;
4641 uint32_t value1, value2;
4642
4643 /* Acquire the required semaphore */
4644 if (ql_sem_spinlock(qlge, QL_MAC_PROTOCOL_SEM_MASK) != DDI_SUCCESS) {
4645 return (rtn_val);
4646 }
4647 /* Program Offset0 - lower 32 bits of the MAC address */
4648 offset = 0;
4649 value1 = (MAC_PROTOCOL_TYPE_MULTICAST | offset)|(index<<4);
4650 value2 =
4651 ((qlge->multicast_list[index].addr.ether_addr_octet[2] << 24)
4652 |(qlge->multicast_list[index].addr.ether_addr_octet[3] << 16)
4653 |(qlge->multicast_list[index].addr.ether_addr_octet[4] << 8)
4654 |(qlge->multicast_list[index].addr.ether_addr_octet[5]));
4655 if (ql_write_mac_proto_regs(qlge, value1, value2) != DDI_SUCCESS) {
4656 goto out;
4657 }
4658 /* Program offset1: upper 16 bits of the MAC address */
4659 offset = 1;
4660 value1 = (MAC_PROTOCOL_TYPE_MULTICAST | offset)|(index<<4);
4661 value2 = 0;
4662 if (ql_write_mac_proto_regs(qlge, value1, value2) != DDI_SUCCESS) {
4663 goto out;
4664 }
4665 rtn_val = DDI_SUCCESS;
4666 out:
4667 ql_sem_unlock(qlge, QL_MAC_PROTOCOL_SEM_MASK);
4668 return (rtn_val);
4669 }
4670
4671 /*
4672 * Add a new multicast address to the list of supported list
4673 * This API is called after OS called gld_set_multicast (GLDv2)
4674 * or m_multicst (GLDv3)
4675 *
4676 * Restriction:
4677 * The number of maximum multicast address is limited by hardware.
4678 */
4679 int
4680 ql_add_to_multicast_list(qlge_t *qlge, uint8_t *ep)
4681 {
4682 uint32_t index = qlge->multicast_list_count;
4683 int rval = DDI_SUCCESS;
4684 int status;
4685
4686 if ((ep[0] & 01) == 0) {
4687 rval = EINVAL;
4688 goto exit;
4689 }
4690
4691 /* if there is an availabe space in multicast_list, then add it */
4692 if (index < MAX_MULTICAST_LIST_SIZE) {
4693 bcopy(ep, qlge->multicast_list[index].addr.ether_addr_octet,
4694 ETHERADDRL);
4695 /* increment the total number of addresses in multicast list */
4696 (void) ql_add_multicast_address(qlge, index);
4697 qlge->multicast_list_count++;
4698 QL_PRINT(DBG_GLD,
4699 ("%s(%d): added to index of multicast list= 0x%x, "
4700 "total %d\n", __func__, qlge->instance, index,
4701 qlge->multicast_list_count));
4702
4703 if (index > MAX_MULTICAST_HW_SIZE) {
4704 if (!qlge->multicast_promisc) {
4705 status = ql_set_routing_reg(qlge,
4706 RT_IDX_ALLMULTI_SLOT,
4707 RT_IDX_MCAST, 1);
4708 if (status) {
4709 cmn_err(CE_WARN,
4710 "Failed to init routing reg "
4711 "for mcast promisc mode.");
4712 rval = ENOENT;
4713 goto exit;
4714 }
4715 qlge->multicast_promisc = B_TRUE;
4716 }
4717 }
4718 } else {
4719 rval = ENOENT;
4720 }
4721 exit:
4722 return (rval);
4723 }
4724
4725 /*
4726 * Remove an old multicast address from the list of supported multicast
4727 * addresses. This API is called after OS called gld_set_multicast (GLDv2)
4728 * or m_multicst (GLDv3)
4729 * The number of maximum multicast address is limited by hardware.
4730 */
4731 int
4732 ql_remove_from_multicast_list(qlge_t *qlge, uint8_t *ep)
4733 {
4734 uint32_t total = qlge->multicast_list_count;
4735 int i = 0;
4736 int rmv_index = 0;
4737 size_t length = sizeof (ql_multicast_addr);
4738 int status;
4739
4740 for (i = 0; i < total; i++) {
4741 if (bcmp(ep, &qlge->multicast_list[i].addr, ETHERADDRL) != 0) {
4742 continue;
4743 }
4744
4745 rmv_index = i;
4746 /* block move the reset of other multicast address forward */
4747 length = ((total -1) -i) * sizeof (ql_multicast_addr);
4748 if (length > 0) {
4749 bcopy(&qlge->multicast_list[i+1],
4750 &qlge->multicast_list[i], length);
4751 }
4752 qlge->multicast_list_count--;
4753 if (qlge->multicast_list_count <= MAX_MULTICAST_HW_SIZE) {
4754 /*
4755 * there is a deletion in multicast list table,
4756 * re-enable them
4757 */
4758 for (i = rmv_index; i < qlge->multicast_list_count;
4759 i++) {
4760 (void) ql_add_multicast_address(qlge, i);
4761 }
4762 /* and disable the last one */
4763 (void) ql_remove_multicast_address(qlge, i);
4764
4765 /* disable multicast promiscuous mode */
4766 if (qlge->multicast_promisc) {
4767 status = ql_set_routing_reg(qlge,
4768 RT_IDX_ALLMULTI_SLOT,
4769 RT_IDX_MCAST, 0);
4770 if (status) {
4771 cmn_err(CE_WARN,
4772 "Failed to init routing reg for "
4773 "mcast promisc mode.");
4774 goto exit;
4775 }
4776 /* write to config register */
4777 qlge->multicast_promisc = B_FALSE;
4778 }
4779 }
4780 break;
4781 }
4782 exit:
4783 return (DDI_SUCCESS);
4784 }
4785
4786 /*
4787 * Read a XGMAC register
4788 */
4789 int
4790 ql_read_xgmac_reg(qlge_t *qlge, uint32_t addr, uint32_t *val)
4791 {
4792 int rtn_val = DDI_FAILURE;
4793
4794 /* wait for XGMAC Address register RDY bit set */
4795 if (ql_wait_reg_bit(qlge, REG_XGMAC_ADDRESS, XGMAC_ADDRESS_RDY,
4796 BIT_SET, 10) != DDI_SUCCESS) {
4797 goto out;
4798 }
4799 /* start rx transaction */
4800 ql_write_reg(qlge, REG_XGMAC_ADDRESS, addr|XGMAC_ADDRESS_READ_TRANSACT);
4801
4802 /*
4803 * wait for XGMAC Address register RDY bit set,
4804 * which indicates data is ready
4805 */
4806 if (ql_wait_reg_bit(qlge, REG_XGMAC_ADDRESS, XGMAC_ADDRESS_RDY,
4807 BIT_SET, 10) != DDI_SUCCESS) {
4808 goto out;
4809 }
4810 /* read data from XGAMC_DATA register */
4811 *val = ql_read_reg(qlge, REG_XGMAC_DATA);
4812 rtn_val = DDI_SUCCESS;
4813 out:
4814 return (rtn_val);
4815 }
4816
4817 /*
4818 * Implement checksum offload for IPv4 IP packets
4819 */
4820 static void
4821 ql_hw_csum_setup(qlge_t *qlge, uint32_t pflags, caddr_t bp,
4822 struct ob_mac_iocb_req *mac_iocb_ptr)
4823 {
4824 struct ip *iphdr = NULL;
4825 struct ether_header *ethhdr;
4826 struct ether_vlan_header *ethvhdr;
4827 struct tcphdr *tcp_hdr;
4828 uint32_t etherType;
4829 int mac_hdr_len, ip_hdr_len, tcp_udp_hdr_len;
4830 int ip_hdr_off, tcp_udp_hdr_off, hdr_off;
4831
4832 ethhdr = (struct ether_header *)((void *)bp);
4833 ethvhdr = (struct ether_vlan_header *)((void *)bp);
4834 /* Is this vlan packet? */
4835 if (ntohs(ethvhdr->ether_tpid) == ETHERTYPE_VLAN) {
4836 mac_hdr_len = sizeof (struct ether_vlan_header);
4837 etherType = ntohs(ethvhdr->ether_type);
4838 } else {
4839 mac_hdr_len = sizeof (struct ether_header);
4840 etherType = ntohs(ethhdr->ether_type);
4841 }
4842 /* Is this IPv4 or IPv6 packet? */
4843 if (IPH_HDR_VERSION((ipha_t *)(void *)(bp+mac_hdr_len)) ==
4844 IPV4_VERSION) {
4845 if (etherType == ETHERTYPE_IP /* 0800 */) {
4846 iphdr = (struct ip *)(void *)(bp+mac_hdr_len);
4847 } else {
4848 /* EMPTY */
4849 QL_PRINT(DBG_TX,
4850 ("%s(%d) : IPv4 None IP packet type 0x%x\n",
4851 __func__, qlge->instance, etherType));
4852 }
4853 }
4854 /* ipV4 packets */
4855 if (iphdr != NULL) {
4856
4857 ip_hdr_len = IPH_HDR_LENGTH(iphdr);
4858 QL_PRINT(DBG_TX,
4859 ("%s(%d) : IPv4 header length using IPH_HDR_LENGTH:"
4860 " %d bytes \n", __func__, qlge->instance, ip_hdr_len));
4861
4862 ip_hdr_off = mac_hdr_len;
4863 QL_PRINT(DBG_TX, ("%s(%d) : ip_hdr_len=%d\n",
4864 __func__, qlge->instance, ip_hdr_len));
4865
4866 mac_iocb_ptr->flag0 = (uint8_t)(mac_iocb_ptr->flag0 |
4867 OB_MAC_IOCB_REQ_IPv4);
4868
4869 if (pflags & HCK_IPV4_HDRCKSUM) {
4870 QL_PRINT(DBG_TX, ("%s(%d) : Do IPv4 header checksum\n",
4871 __func__, qlge->instance));
4872 mac_iocb_ptr->opcode = OPCODE_OB_MAC_OFFLOAD_IOCB;
4873 mac_iocb_ptr->flag2 = (uint8_t)(mac_iocb_ptr->flag2 |
4874 OB_MAC_IOCB_REQ_IC);
4875 iphdr->ip_sum = 0;
4876 mac_iocb_ptr->hdr_off = (uint16_t)
4877 cpu_to_le16(ip_hdr_off);
4878 }
4879 if (pflags & HCK_FULLCKSUM) {
4880 if (iphdr->ip_p == IPPROTO_TCP) {
4881 tcp_hdr =
4882 (struct tcphdr *)(void *)
4883 ((uint8_t *)(void *)iphdr + ip_hdr_len);
4884 QL_PRINT(DBG_TX, ("%s(%d) : Do TCP checksum\n",
4885 __func__, qlge->instance));
4886 mac_iocb_ptr->opcode =
4887 OPCODE_OB_MAC_OFFLOAD_IOCB;
4888 mac_iocb_ptr->flag1 =
4889 (uint8_t)(mac_iocb_ptr->flag1 |
4890 OB_MAC_IOCB_REQ_TC);
4891 mac_iocb_ptr->flag2 =
4892 (uint8_t)(mac_iocb_ptr->flag2 |
4893 OB_MAC_IOCB_REQ_IC);
4894 iphdr->ip_sum = 0;
4895 tcp_udp_hdr_off = mac_hdr_len+ip_hdr_len;
4896 tcp_udp_hdr_len = tcp_hdr->th_off*4;
4897 QL_PRINT(DBG_TX, ("%s(%d): tcp header len:%d\n",
4898 __func__, qlge->instance, tcp_udp_hdr_len));
4899 hdr_off = ip_hdr_off;
4900 tcp_udp_hdr_off <<= 6;
4901 hdr_off |= tcp_udp_hdr_off;
4902 mac_iocb_ptr->hdr_off =
4903 (uint16_t)cpu_to_le16(hdr_off);
4904 mac_iocb_ptr->protocol_hdr_len = (uint16_t)
4905 cpu_to_le16(mac_hdr_len + ip_hdr_len +
4906 tcp_udp_hdr_len);
4907
4908 /*
4909 * if the chip is unable to do pseudo header
4910 * cksum calculation, do it in then put the
4911 * result to the data passed to the chip
4912 */
4913 if (qlge->cfg_flags &
4914 CFG_HW_UNABLE_PSEUDO_HDR_CKSUM) {
4915 ql_pseudo_cksum((uint8_t *)iphdr);
4916 }
4917 } else if (iphdr->ip_p == IPPROTO_UDP) {
4918 QL_PRINT(DBG_TX, ("%s(%d) : Do UDP checksum\n",
4919 __func__, qlge->instance));
4920 mac_iocb_ptr->opcode =
4921 OPCODE_OB_MAC_OFFLOAD_IOCB;
4922 mac_iocb_ptr->flag1 =
4923 (uint8_t)(mac_iocb_ptr->flag1 |
4924 OB_MAC_IOCB_REQ_UC);
4925 mac_iocb_ptr->flag2 =
4926 (uint8_t)(mac_iocb_ptr->flag2 |
4927 OB_MAC_IOCB_REQ_IC);
4928 iphdr->ip_sum = 0;
4929 tcp_udp_hdr_off = mac_hdr_len + ip_hdr_len;
4930 tcp_udp_hdr_len = sizeof (struct udphdr);
4931 QL_PRINT(DBG_TX, ("%s(%d):udp header len:%d\n",
4932 __func__, qlge->instance, tcp_udp_hdr_len));
4933 hdr_off = ip_hdr_off;
4934 tcp_udp_hdr_off <<= 6;
4935 hdr_off |= tcp_udp_hdr_off;
4936 mac_iocb_ptr->hdr_off =
4937 (uint16_t)cpu_to_le16(hdr_off);
4938 mac_iocb_ptr->protocol_hdr_len = (uint16_t)
4939 cpu_to_le16(mac_hdr_len + ip_hdr_len
4940 + tcp_udp_hdr_len);
4941
4942 /*
4943 * if the chip is unable to calculate pseudo
4944 * hdr cksum,do it in then put the result to
4945 * the data passed to the chip
4946 */
4947 if (qlge->cfg_flags &
4948 CFG_HW_UNABLE_PSEUDO_HDR_CKSUM) {
4949 ql_pseudo_cksum((uint8_t *)iphdr);
4950 }
4951 }
4952 }
4953 }
4954 }
4955
4956 /*
4957 * For TSO/LSO:
4958 * MAC frame transmission with TCP large segment offload is performed in the
4959 * same way as the MAC frame transmission with checksum offload with the
4960 * exception that the maximum TCP segment size (MSS) must be specified to
4961 * allow the chip to segment the data into legal sized frames.
4962 * The host also needs to calculate a pseudo-header checksum over the
4963 * following fields:
4964 * Source IP Address, Destination IP Address, and the Protocol.
4965 * The TCP length is not included in the pseudo-header calculation.
4966 * The pseudo-header checksum is place in the TCP checksum field of the
4967 * prototype header.
4968 */
4969 static void
4970 ql_lso_pseudo_cksum(uint8_t *buf)
4971 {
4972 uint32_t cksum;
4973 uint16_t iphl;
4974 uint16_t proto;
4975
4976 /*
4977 * Calculate the LSO pseudo-header checksum.
4978 */
4979 iphl = (uint16_t)(4 * (buf[0] & 0xF));
4980 cksum = proto = buf[9];
4981 cksum += (((uint16_t)buf[12])<<8) + buf[13];
4982 cksum += (((uint16_t)buf[14])<<8) + buf[15];
4983 cksum += (((uint16_t)buf[16])<<8) + buf[17];
4984 cksum += (((uint16_t)buf[18])<<8) + buf[19];
4985 cksum = (cksum>>16) + (cksum & 0xFFFF);
4986 cksum = (cksum>>16) + (cksum & 0xFFFF);
4987
4988 /*
4989 * Point it to the TCP/UDP header, and
4990 * update the checksum field.
4991 */
4992 buf += iphl + ((proto == IPPROTO_TCP) ?
4993 TCP_CKSUM_OFFSET : UDP_CKSUM_OFFSET);
4994
4995 *(uint16_t *)(void *)buf = (uint16_t)htons((uint16_t)cksum);
4996 }
4997
4998 /*
4999 * For IPv4 IP packets, distribute the tx packets evenly among tx rings
5000 */
5001 typedef uint32_t ub4; /* unsigned 4-byte quantities */
5002 typedef uint8_t ub1;
5003
5004 #define hashsize(n) ((ub4)1<<(n))
5005 #define hashmask(n) (hashsize(n)-1)
5006
5007 #define mix(a, b, c) \
5008 { \
5009 a -= b; a -= c; a ^= (c>>13); \
5010 b -= c; b -= a; b ^= (a<<8); \
5011 c -= a; c -= b; c ^= (b>>13); \
5012 a -= b; a -= c; a ^= (c>>12); \
5013 b -= c; b -= a; b ^= (a<<16); \
5014 c -= a; c -= b; c ^= (b>>5); \
5015 a -= b; a -= c; a ^= (c>>3); \
5016 b -= c; b -= a; b ^= (a<<10); \
5017 c -= a; c -= b; c ^= (b>>15); \
5018 }
5019
5020 ub4
5021 hash(k, length, initval)
5022 register ub1 *k; /* the key */
5023 register ub4 length; /* the length of the key */
5024 register ub4 initval; /* the previous hash, or an arbitrary value */
5025 {
5026 register ub4 a, b, c, len;
5027
5028 /* Set up the internal state */
5029 len = length;
5030 a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */
5031 c = initval; /* the previous hash value */
5032
5033 /* handle most of the key */
5034 while (len >= 12) {
5035 a += (k[0] +((ub4)k[1]<<8) +((ub4)k[2]<<16) +((ub4)k[3]<<24));
5036 b += (k[4] +((ub4)k[5]<<8) +((ub4)k[6]<<16) +((ub4)k[7]<<24));
5037 c += (k[8] +((ub4)k[9]<<8) +((ub4)k[10]<<16)+((ub4)k[11]<<24));
5038 mix(a, b, c);
5039 k += 12;
5040 len -= 12;
5041 }
5042
5043 /* handle the last 11 bytes */
5044 c += length;
5045 /* all the case statements fall through */
5046 switch (len) {
5047 /* FALLTHRU */
5048 case 11: c += ((ub4)k[10]<<24);
5049 /* FALLTHRU */
5050 case 10: c += ((ub4)k[9]<<16);
5051 /* FALLTHRU */
5052 case 9 : c += ((ub4)k[8]<<8);
5053 /* the first byte of c is reserved for the length */
5054 /* FALLTHRU */
5055 case 8 : b += ((ub4)k[7]<<24);
5056 /* FALLTHRU */
5057 case 7 : b += ((ub4)k[6]<<16);
5058 /* FALLTHRU */
5059 case 6 : b += ((ub4)k[5]<<8);
5060 /* FALLTHRU */
5061 case 5 : b += k[4];
5062 /* FALLTHRU */
5063 case 4 : a += ((ub4)k[3]<<24);
5064 /* FALLTHRU */
5065 case 3 : a += ((ub4)k[2]<<16);
5066 /* FALLTHRU */
5067 case 2 : a += ((ub4)k[1]<<8);
5068 /* FALLTHRU */
5069 case 1 : a += k[0];
5070 /* case 0: nothing left to add */
5071 }
5072 mix(a, b, c);
5073 /* report the result */
5074 return (c);
5075 }
5076
5077 uint8_t
5078 ql_tx_hashing(qlge_t *qlge, caddr_t bp)
5079 {
5080 struct ip *iphdr = NULL;
5081 struct ether_header *ethhdr;
5082 struct ether_vlan_header *ethvhdr;
5083 struct tcphdr *tcp_hdr;
5084 struct udphdr *udp_hdr;
5085 uint32_t etherType;
5086 int mac_hdr_len, ip_hdr_len;
5087 uint32_t h = 0; /* 0 by default */
5088 uint8_t tx_ring_id = 0;
5089 uint32_t ip_src_addr = 0;
5090 uint32_t ip_desc_addr = 0;
5091 uint16_t src_port = 0;
5092 uint16_t dest_port = 0;
5093 uint8_t key[12];
5094 QL_PRINT(DBG_TX, ("%s(%d) entered \n", __func__, qlge->instance));
5095
5096 ethhdr = (struct ether_header *)((void *)bp);
5097 ethvhdr = (struct ether_vlan_header *)((void *)bp);
5098
5099 if (qlge->tx_ring_count == 1)
5100 return (tx_ring_id);
5101
5102 /* Is this vlan packet? */
5103 if (ntohs(ethvhdr->ether_tpid) == ETHERTYPE_VLAN) {
5104 mac_hdr_len = sizeof (struct ether_vlan_header);
5105 etherType = ntohs(ethvhdr->ether_type);
5106 } else {
5107 mac_hdr_len = sizeof (struct ether_header);
5108 etherType = ntohs(ethhdr->ether_type);
5109 }
5110 /* Is this IPv4 or IPv6 packet? */
5111 if (etherType == ETHERTYPE_IP /* 0800 */) {
5112 if (IPH_HDR_VERSION((ipha_t *)(void *)(bp+mac_hdr_len))
5113 == IPV4_VERSION) {
5114 iphdr = (struct ip *)(void *)(bp+mac_hdr_len);
5115 }
5116 if (((unsigned long)iphdr) & 0x3) {
5117 /* IP hdr not 4-byte aligned */
5118 return (tx_ring_id);
5119 }
5120 }
5121 /* ipV4 packets */
5122 if (iphdr) {
5123
5124 ip_hdr_len = IPH_HDR_LENGTH(iphdr);
5125 ip_src_addr = iphdr->ip_src.s_addr;
5126 ip_desc_addr = iphdr->ip_dst.s_addr;
5127
5128 if (iphdr->ip_p == IPPROTO_TCP) {
5129 tcp_hdr = (struct tcphdr *)(void *)
5130 ((uint8_t *)iphdr + ip_hdr_len);
5131 src_port = tcp_hdr->th_sport;
5132 dest_port = tcp_hdr->th_dport;
5133 } else if (iphdr->ip_p == IPPROTO_UDP) {
5134 udp_hdr = (struct udphdr *)(void *)
5135 ((uint8_t *)iphdr + ip_hdr_len);
5136 src_port = udp_hdr->uh_sport;
5137 dest_port = udp_hdr->uh_dport;
5138 }
5139 key[0] = (uint8_t)((ip_src_addr) &0xFF);
5140 key[1] = (uint8_t)((ip_src_addr >> 8) &0xFF);
5141 key[2] = (uint8_t)((ip_src_addr >> 16) &0xFF);
5142 key[3] = (uint8_t)((ip_src_addr >> 24) &0xFF);
5143 key[4] = (uint8_t)((ip_desc_addr) &0xFF);
5144 key[5] = (uint8_t)((ip_desc_addr >> 8) &0xFF);
5145 key[6] = (uint8_t)((ip_desc_addr >> 16) &0xFF);
5146 key[7] = (uint8_t)((ip_desc_addr >> 24) &0xFF);
5147 key[8] = (uint8_t)((src_port) &0xFF);
5148 key[9] = (uint8_t)((src_port >> 8) &0xFF);
5149 key[10] = (uint8_t)((dest_port) &0xFF);
5150 key[11] = (uint8_t)((dest_port >> 8) &0xFF);
5151 h = hash(key, 12, 0); /* return 32 bit */
5152 tx_ring_id = (h & (qlge->tx_ring_count - 1));
5153 if (tx_ring_id >= qlge->tx_ring_count) {
5154 cmn_err(CE_WARN, "%s bad tx_ring_id %d\n",
5155 __func__, tx_ring_id);
5156 tx_ring_id = 0;
5157 }
5158 }
5159 return (tx_ring_id);
5160 }
5161
5162 /*
5163 * Tell the hardware to do Large Send Offload (LSO)
5164 *
5165 * Some fields in ob_mac_iocb need to be set so hardware can know what is
5166 * the incoming packet, TCP or UDP, whether a VLAN tag needs to be inserted
5167 * in the right place of the packet etc, thus, hardware can process the
5168 * packet correctly.
5169 */
5170 static void
5171 ql_hw_lso_setup(qlge_t *qlge, uint32_t mss, caddr_t bp,
5172 struct ob_mac_iocb_req *mac_iocb_ptr)
5173 {
5174 struct ip *iphdr = NULL;
5175 struct ether_header *ethhdr;
5176 struct ether_vlan_header *ethvhdr;
5177 struct tcphdr *tcp_hdr;
5178 struct udphdr *udp_hdr;
5179 uint32_t etherType;
5180 uint16_t mac_hdr_len, ip_hdr_len, tcp_udp_hdr_len;
5181 uint16_t ip_hdr_off, tcp_udp_hdr_off, hdr_off;
5182
5183 ethhdr = (struct ether_header *)(void *)bp;
5184 ethvhdr = (struct ether_vlan_header *)(void *)bp;
5185
5186 /* Is this vlan packet? */
5187 if (ntohs(ethvhdr->ether_tpid) == ETHERTYPE_VLAN) {
5188 mac_hdr_len = sizeof (struct ether_vlan_header);
5189 etherType = ntohs(ethvhdr->ether_type);
5190 } else {
5191 mac_hdr_len = sizeof (struct ether_header);
5192 etherType = ntohs(ethhdr->ether_type);
5193 }
5194 /* Is this IPv4 or IPv6 packet? */
5195 if (IPH_HDR_VERSION((ipha_t *)(void *)(bp + mac_hdr_len)) ==
5196 IPV4_VERSION) {
5197 if (etherType == ETHERTYPE_IP /* 0800 */) {
5198 iphdr = (struct ip *)(void *)(bp+mac_hdr_len);
5199 } else {
5200 /* EMPTY */
5201 QL_PRINT(DBG_TX, ("%s(%d) : IPv4 None IP packet"
5202 " type 0x%x\n",
5203 __func__, qlge->instance, etherType));
5204 }
5205 }
5206
5207 if (iphdr != NULL) { /* ipV4 packets */
5208 ip_hdr_len = (uint16_t)IPH_HDR_LENGTH(iphdr);
5209 QL_PRINT(DBG_TX,
5210 ("%s(%d) : IPv4 header length using IPH_HDR_LENGTH: %d"
5211 " bytes \n", __func__, qlge->instance, ip_hdr_len));
5212
5213 ip_hdr_off = mac_hdr_len;
5214 QL_PRINT(DBG_TX, ("%s(%d) : ip_hdr_len=%d\n",
5215 __func__, qlge->instance, ip_hdr_len));
5216
5217 mac_iocb_ptr->flag0 = (uint8_t)(mac_iocb_ptr->flag0 |
5218 OB_MAC_IOCB_REQ_IPv4);
5219 if (qlge->cfg_flags & CFG_CKSUM_FULL_IPv4) {
5220 if (iphdr->ip_p == IPPROTO_TCP) {
5221 tcp_hdr = (struct tcphdr *)(void *)
5222 ((uint8_t *)(void *)iphdr +
5223 ip_hdr_len);
5224 QL_PRINT(DBG_TX, ("%s(%d) : Do TSO on TCP "
5225 "packet\n",
5226 __func__, qlge->instance));
5227 mac_iocb_ptr->opcode =
5228 OPCODE_OB_MAC_OFFLOAD_IOCB;
5229 mac_iocb_ptr->flag1 =
5230 (uint8_t)(mac_iocb_ptr->flag1 |
5231 OB_MAC_IOCB_REQ_LSO);
5232 iphdr->ip_sum = 0;
5233 tcp_udp_hdr_off =
5234 (uint16_t)(mac_hdr_len+ip_hdr_len);
5235 tcp_udp_hdr_len =
5236 (uint16_t)(tcp_hdr->th_off*4);
5237 QL_PRINT(DBG_TX, ("%s(%d): tcp header len:%d\n",
5238 __func__, qlge->instance, tcp_udp_hdr_len));
5239 hdr_off = ip_hdr_off;
5240 tcp_udp_hdr_off <<= 6;
5241 hdr_off |= tcp_udp_hdr_off;
5242 mac_iocb_ptr->hdr_off =
5243 (uint16_t)cpu_to_le16(hdr_off);
5244 mac_iocb_ptr->protocol_hdr_len = (uint16_t)
5245 cpu_to_le16(mac_hdr_len + ip_hdr_len +
5246 tcp_udp_hdr_len);
5247 mac_iocb_ptr->mss = (uint16_t)cpu_to_le16(mss);
5248
5249 /*
5250 * if the chip is unable to calculate pseudo
5251 * header checksum, do it in then put the result
5252 * to the data passed to the chip
5253 */
5254 if (qlge->cfg_flags &
5255 CFG_HW_UNABLE_PSEUDO_HDR_CKSUM)
5256 ql_lso_pseudo_cksum((uint8_t *)iphdr);
5257 } else if (iphdr->ip_p == IPPROTO_UDP) {
5258 udp_hdr = (struct udphdr *)(void *)
5259 ((uint8_t *)(void *)iphdr
5260 + ip_hdr_len);
5261 QL_PRINT(DBG_TX, ("%s(%d) : Do TSO on UDP "
5262 "packet\n",
5263 __func__, qlge->instance));
5264 mac_iocb_ptr->opcode =
5265 OPCODE_OB_MAC_OFFLOAD_IOCB;
5266 mac_iocb_ptr->flag1 =
5267 (uint8_t)(mac_iocb_ptr->flag1 |
5268 OB_MAC_IOCB_REQ_LSO);
5269 iphdr->ip_sum = 0;
5270 tcp_udp_hdr_off =
5271 (uint16_t)(mac_hdr_len+ip_hdr_len);
5272 tcp_udp_hdr_len =
5273 (uint16_t)(udp_hdr->uh_ulen*4);
5274 QL_PRINT(DBG_TX, ("%s(%d):udp header len:%d\n",
5275 __func__, qlge->instance, tcp_udp_hdr_len));
5276 hdr_off = ip_hdr_off;
5277 tcp_udp_hdr_off <<= 6;
5278 hdr_off |= tcp_udp_hdr_off;
5279 mac_iocb_ptr->hdr_off =
5280 (uint16_t)cpu_to_le16(hdr_off);
5281 mac_iocb_ptr->protocol_hdr_len = (uint16_t)
5282 cpu_to_le16(mac_hdr_len + ip_hdr_len +
5283 tcp_udp_hdr_len);
5284 mac_iocb_ptr->mss = (uint16_t)cpu_to_le16(mss);
5285
5286 /*
5287 * if the chip is unable to do pseudo header
5288 * checksum calculation, do it here then put the
5289 * result to the data passed to the chip
5290 */
5291 if (qlge->cfg_flags &
5292 CFG_HW_UNABLE_PSEUDO_HDR_CKSUM)
5293 ql_lso_pseudo_cksum((uint8_t *)iphdr);
5294 }
5295 }
5296 }
5297 }
5298
5299 /*
5300 * Generic packet sending function which is used to send one packet.
5301 */
5302 int
5303 ql_send_common(struct tx_ring *tx_ring, mblk_t *mp)
5304 {
5305 struct tx_ring_desc *tx_cb;
5306 struct ob_mac_iocb_req *mac_iocb_ptr;
5307 mblk_t *tp;
5308 size_t msg_len = 0;
5309 size_t off;
5310 caddr_t bp;
5311 size_t nbyte, total_len;
5312 uint_t i = 0;
5313 int j = 0, frags = 0;
5314 uint32_t phy_addr_low, phy_addr_high;
5315 uint64_t phys_addr;
5316 clock_t now;
5317 uint32_t pflags = 0;
5318 uint32_t mss = 0;
5319 enum tx_mode_t tx_mode;
5320 struct oal_entry *oal_entry;
5321 int status;
5322 uint_t ncookies, oal_entries, max_oal_entries;
5323 size_t max_seg_len = 0;
5324 boolean_t use_lso = B_FALSE;
5325 struct oal_entry *tx_entry = NULL;
5326 struct oal_entry *last_oal_entry;
5327 qlge_t *qlge = tx_ring->qlge;
5328 ddi_dma_cookie_t dma_cookie;
5329 size_t tx_buf_len = QL_MAX_COPY_LENGTH;
5330 int force_pullup = 0;
5331
5332 tp = mp;
5333 total_len = msg_len = 0;
5334 max_oal_entries = TX_DESC_PER_IOCB + MAX_SG_ELEMENTS-1;
5335
5336 /* Calculate number of data and segments in the incoming message */
5337 for (tp = mp; tp != NULL; tp = tp->b_cont) {
5338 nbyte = MBLKL(tp);
5339 total_len += nbyte;
5340 max_seg_len = max(nbyte, max_seg_len);
5341 QL_PRINT(DBG_TX, ("Requested sending data in %d segments, "
5342 "total length: %d\n", frags, nbyte));
5343 frags++;
5344 }
5345
5346 if (total_len >= QL_LSO_MAX) {
5347 freemsg(mp);
5348 #ifdef QLGE_LOAD_UNLOAD
5349 cmn_err(CE_NOTE, "%s: quit, packet oversize %d\n",
5350 __func__, (int)total_len);
5351 #endif
5352 return (NULL);
5353 }
5354
5355 bp = (caddr_t)mp->b_rptr;
5356 if (bp[0] & 1) {
5357 if (bcmp(bp, ql_ether_broadcast_addr.ether_addr_octet,
5358 ETHERADDRL) == 0) {
5359 QL_PRINT(DBG_TX, ("Broadcast packet\n"));
5360 tx_ring->brdcstxmt++;
5361 } else {
5362 QL_PRINT(DBG_TX, ("multicast packet\n"));
5363 tx_ring->multixmt++;
5364 }
5365 }
5366
5367 tx_ring->obytes += total_len;
5368 tx_ring->opackets ++;
5369
5370 QL_PRINT(DBG_TX, ("total requested sending data length: %d, in %d segs,"
5371 " max seg len: %d\n", total_len, frags, max_seg_len));
5372
5373 /* claim a free slot in tx ring */
5374 tx_cb = &tx_ring->wq_desc[tx_ring->prod_idx];
5375
5376 /* get the tx descriptor */
5377 mac_iocb_ptr = tx_cb->queue_entry;
5378
5379 bzero((void *)mac_iocb_ptr, 20);
5380
5381 ASSERT(tx_cb->mp == NULL);
5382
5383 /*
5384 * Decide to use DMA map or copy mode.
5385 * DMA map mode must be used when the total msg length is more than the
5386 * tx buffer length.
5387 */
5388
5389 if (total_len > tx_buf_len)
5390 tx_mode = USE_DMA;
5391 else if (max_seg_len > QL_MAX_COPY_LENGTH)
5392 tx_mode = USE_DMA;
5393 else
5394 tx_mode = USE_COPY;
5395
5396 if (qlge->chksum_cap) {
5397 mac_hcksum_get(mp, NULL, NULL, NULL, NULL, &pflags);
5398 QL_PRINT(DBG_TX, ("checksum flag is :0x%x, card capability "
5399 "is 0x%x \n", pflags, qlge->chksum_cap));
5400 if (qlge->lso_enable) {
5401 uint32_t lso_flags = 0;
5402 mac_lso_get(mp, &mss, &lso_flags);
5403 use_lso = (lso_flags == HW_LSO);
5404 }
5405 QL_PRINT(DBG_TX, ("mss :%d, use_lso %x \n",
5406 mss, use_lso));
5407 }
5408
5409 do_pullup:
5410
5411 /* concatenate all frags into one large packet if too fragmented */
5412 if (((tx_mode == USE_DMA)&&(frags > QL_MAX_TX_DMA_HANDLES)) ||
5413 force_pullup) {
5414 mblk_t *mp1;
5415 if ((mp1 = msgpullup(mp, -1)) != NULL) {
5416 freemsg(mp);
5417 mp = mp1;
5418 frags = 1;
5419 } else {
5420 tx_ring->tx_fail_dma_bind++;
5421 goto bad;
5422 }
5423 }
5424
5425 tx_cb->tx_bytes = (uint32_t)total_len;
5426 tx_cb->mp = mp;
5427 tx_cb->tx_dma_handle_used = 0;
5428
5429 if (tx_mode == USE_DMA) {
5430 msg_len = total_len;
5431
5432 mac_iocb_ptr->opcode = OPCODE_OB_MAC_IOCB;
5433 mac_iocb_ptr->tid = tx_ring->prod_idx;
5434 mac_iocb_ptr->frame_len = (uint32_t)cpu_to_le32(msg_len);
5435 mac_iocb_ptr->txq_idx = tx_ring->wq_id;
5436
5437 tx_entry = &mac_iocb_ptr->oal_entry[0];
5438 oal_entry = NULL;
5439
5440 for (tp = mp, oal_entries = j = 0; tp != NULL;
5441 tp = tp->b_cont) {
5442 /* if too many tx dma handles needed */
5443 if (j >= QL_MAX_TX_DMA_HANDLES) {
5444 tx_ring->tx_no_dma_handle++;
5445 if (!force_pullup) {
5446 force_pullup = 1;
5447 goto do_pullup;
5448 } else {
5449 goto bad;
5450 }
5451 }
5452 nbyte = (uint16_t)MBLKL(tp);
5453 if (nbyte == 0)
5454 continue;
5455
5456 status = ddi_dma_addr_bind_handle(
5457 tx_cb->tx_dma_handle[j], NULL,
5458 (caddr_t)tp->b_rptr, nbyte,
5459 DDI_DMA_WRITE | DDI_DMA_STREAMING, DDI_DMA_DONTWAIT,
5460 0, &dma_cookie, &ncookies);
5461
5462 QL_PRINT(DBG_TX, ("map sending data segment: %d, "
5463 "length: %d, spans in %d cookies\n",
5464 j, nbyte, ncookies));
5465
5466 if (status != DDI_DMA_MAPPED) {
5467 goto bad;
5468 }
5469 /*
5470 * Each fragment can span several cookies. One cookie
5471 * will use one tx descriptor to transmit.
5472 */
5473 for (i = ncookies; i > 0; i--, tx_entry++,
5474 oal_entries++) {
5475 /*
5476 * The number of TX descriptors that can be
5477 * saved in tx iocb and oal list is limited
5478 */
5479 if (oal_entries > max_oal_entries) {
5480 tx_ring->tx_no_dma_cookie++;
5481 if (!force_pullup) {
5482 force_pullup = 1;
5483 goto do_pullup;
5484 } else {
5485 goto bad;
5486 }
5487 }
5488
5489 if ((oal_entries == TX_DESC_PER_IOCB) &&
5490 !oal_entry) {
5491 /*
5492 * Time to switch to an oal list
5493 * The last entry should be copied
5494 * to first entry in the oal list
5495 */
5496 oal_entry = tx_cb->oal;
5497 tx_entry =
5498 &mac_iocb_ptr->oal_entry[
5499 TX_DESC_PER_IOCB-1];
5500 bcopy(tx_entry, oal_entry,
5501 sizeof (*oal_entry));
5502
5503 /*
5504 * last entry should be updated to
5505 * point to the extended oal list itself
5506 */
5507 tx_entry->buf_addr_low =
5508 cpu_to_le32(
5509 LS_64BITS(tx_cb->oal_dma_addr));
5510 tx_entry->buf_addr_high =
5511 cpu_to_le32(
5512 MS_64BITS(tx_cb->oal_dma_addr));
5513 /*
5514 * Point tx_entry to the oal list
5515 * second entry
5516 */
5517 tx_entry = &oal_entry[1];
5518 }
5519
5520 tx_entry->buf_len =
5521 (uint32_t)cpu_to_le32(dma_cookie.dmac_size);
5522 phys_addr = dma_cookie.dmac_laddress;
5523 tx_entry->buf_addr_low =
5524 cpu_to_le32(LS_64BITS(phys_addr));
5525 tx_entry->buf_addr_high =
5526 cpu_to_le32(MS_64BITS(phys_addr));
5527
5528 last_oal_entry = tx_entry;
5529
5530 if (i > 1)
5531 ddi_dma_nextcookie(
5532 tx_cb->tx_dma_handle[j],
5533 &dma_cookie);
5534 }
5535 j++;
5536 }
5537 /*
5538 * if OAL is used, the last oal entry in tx iocb indicates
5539 * number of additional address/len pairs in OAL
5540 */
5541 if (oal_entries > TX_DESC_PER_IOCB) {
5542 tx_entry = &mac_iocb_ptr->oal_entry[TX_DESC_PER_IOCB-1];
5543 tx_entry->buf_len = (uint32_t)
5544 (cpu_to_le32((sizeof (struct oal_entry) *
5545 (oal_entries -TX_DESC_PER_IOCB+1))|OAL_CONT_ENTRY));
5546 }
5547 last_oal_entry->buf_len = cpu_to_le32(
5548 le32_to_cpu(last_oal_entry->buf_len)|OAL_LAST_ENTRY);
5549
5550 tx_cb->tx_dma_handle_used = j;
5551 QL_PRINT(DBG_TX, ("total tx_dma_handle_used %d cookies %d \n",
5552 j, oal_entries));
5553
5554 bp = (caddr_t)mp->b_rptr;
5555 }
5556 if (tx_mode == USE_COPY) {
5557 bp = tx_cb->copy_buffer;
5558 off = 0;
5559 nbyte = 0;
5560 frags = 0;
5561 /*
5562 * Copy up to tx_buf_len of the transmit data
5563 * from mp to tx buffer
5564 */
5565 for (tp = mp; tp != NULL; tp = tp->b_cont) {
5566 nbyte = MBLKL(tp);
5567 if ((off + nbyte) <= tx_buf_len) {
5568 bcopy(tp->b_rptr, &bp[off], nbyte);
5569 off += nbyte;
5570 frags ++;
5571 }
5572 }
5573
5574 msg_len = off;
5575
5576 mac_iocb_ptr->opcode = OPCODE_OB_MAC_IOCB;
5577 mac_iocb_ptr->tid = tx_ring->prod_idx;
5578 mac_iocb_ptr->frame_len = (uint32_t)cpu_to_le32(msg_len);
5579 mac_iocb_ptr->txq_idx = tx_ring->wq_id;
5580
5581 QL_PRINT(DBG_TX, ("Copy Mode:actual sent data length is: %d, "
5582 "from %d segaments\n", msg_len, frags));
5583
5584 phys_addr = tx_cb->copy_buffer_dma_addr;
5585 phy_addr_low = cpu_to_le32(LS_64BITS(phys_addr));
5586 phy_addr_high = cpu_to_le32(MS_64BITS(phys_addr));
5587
5588 QL_DUMP(DBG_TX, "\t requested sending data:\n",
5589 (uint8_t *)tx_cb->copy_buffer, 8, total_len);
5590
5591 mac_iocb_ptr->oal_entry[0].buf_len = (uint32_t)
5592 cpu_to_le32(msg_len | OAL_LAST_ENTRY);
5593 mac_iocb_ptr->oal_entry[0].buf_addr_low = phy_addr_low;
5594 mac_iocb_ptr->oal_entry[0].buf_addr_high = phy_addr_high;
5595
5596 freemsg(mp); /* no need, we have copied */
5597 tx_cb->mp = NULL;
5598 } /* End of Copy Mode */
5599
5600 /* Do TSO/LSO on TCP packet? */
5601 if (use_lso && mss) {
5602 ql_hw_lso_setup(qlge, mss, bp, mac_iocb_ptr);
5603 } else if (pflags & qlge->chksum_cap) {
5604 /* Do checksum offloading */
5605 ql_hw_csum_setup(qlge, pflags, bp, mac_iocb_ptr);
5606 }
5607
5608 /* let device know the latest outbound IOCB */
5609 (void) ddi_dma_sync(tx_ring->wq_dma.dma_handle,
5610 (off_t)((uintptr_t)mac_iocb_ptr - (uintptr_t)tx_ring->wq_dma.vaddr),
5611 (size_t)sizeof (*mac_iocb_ptr), DDI_DMA_SYNC_FORDEV);
5612
5613 if (tx_mode == USE_DMA) {
5614 /* let device know the latest outbound OAL if necessary */
5615 if (oal_entries > TX_DESC_PER_IOCB) {
5616 (void) ddi_dma_sync(tx_cb->oal_dma.dma_handle,
5617 (off_t)0,
5618 (sizeof (struct oal_entry) *
5619 (oal_entries -TX_DESC_PER_IOCB+1)),
5620 DDI_DMA_SYNC_FORDEV);
5621 }
5622 } else { /* for USE_COPY mode, tx buffer has changed */
5623 /* let device know the latest change */
5624 (void) ddi_dma_sync(tx_cb->oal_dma.dma_handle,
5625 /* copy buf offset */
5626 (off_t)(sizeof (oal_entry) * MAX_SG_ELEMENTS),
5627 msg_len, DDI_DMA_SYNC_FORDEV);
5628 }
5629
5630 /* save how the packet was sent */
5631 tx_cb->tx_type = tx_mode;
5632
5633 QL_DUMP_REQ_PKT(qlge, mac_iocb_ptr, tx_cb->oal, oal_entries);
5634 /* reduce the number of available tx slot */
5635 atomic_dec_32(&tx_ring->tx_free_count);
5636
5637 tx_ring->prod_idx++;
5638 if (tx_ring->prod_idx >= tx_ring->wq_len)
5639 tx_ring->prod_idx = 0;
5640
5641 now = ddi_get_lbolt();
5642 qlge->last_tx_time = now;
5643
5644 return (DDI_SUCCESS);
5645
5646 bad:
5647 /*
5648 * if for any reason driver can not send, delete
5649 * the message pointer, mp
5650 */
5651 now = ddi_get_lbolt();
5652 freemsg(mp);
5653 mp = NULL;
5654 tx_cb->mp = NULL;
5655 for (i = 0; i < j; i++)
5656 (void) ddi_dma_unbind_handle(tx_cb->tx_dma_handle[i]);
5657
5658 QL_PRINT(DBG_TX, ("%s(%d) failed at 0x%x",
5659 __func__, qlge->instance, (int)now));
5660
5661 return (DDI_SUCCESS);
5662 }
5663
5664
5665 /*
5666 * Initializes hardware and driver software flags before the driver
5667 * is finally ready to work.
5668 */
5669 int
5670 ql_do_start(qlge_t *qlge)
5671 {
5672 int i;
5673 struct rx_ring *rx_ring;
5674 uint16_t lbq_buf_size;
5675 int rings_done;
5676
5677 ASSERT(qlge != NULL);
5678
5679 mutex_enter(&qlge->hw_mutex);
5680
5681 /* Reset adapter */
5682 (void) ql_asic_reset(qlge);
5683
5684 lbq_buf_size = (uint16_t)
5685 ((qlge->mtu == ETHERMTU)? LRG_BUF_NORMAL_SIZE : LRG_BUF_JUMBO_SIZE);
5686 if (qlge->rx_ring[0].lbq_buf_size != lbq_buf_size) {
5687 #ifdef QLGE_LOAD_UNLOAD
5688 cmn_err(CE_NOTE, "realloc buffers old: %d new: %d\n",
5689 qlge->rx_ring[0].lbq_buf_size, lbq_buf_size);
5690 #endif
5691 /*
5692 * Check if any ring has buffers still with upper layers
5693 * If buffers are pending with upper layers, we use the
5694 * existing buffers and don't reallocate new ones
5695 * Unfortunately there is no way to evict buffers from
5696 * upper layers. Using buffers with the current size may
5697 * cause slightly sub-optimal performance, but that seems
5698 * to be the easiest way to handle this situation.
5699 */
5700 rings_done = 0;
5701 for (i = 0; i < qlge->rx_ring_count; i++) {
5702 rx_ring = &qlge->rx_ring[i];
5703 if (rx_ring->rx_indicate == 0)
5704 rings_done++;
5705 else
5706 break;
5707 }
5708 /*
5709 * No buffers pending with upper layers;
5710 * reallocte them for new MTU size
5711 */
5712 if (rings_done >= qlge->rx_ring_count) {
5713 /* free large buffer pool */
5714 for (i = 0; i < qlge->rx_ring_count; i++) {
5715 rx_ring = &qlge->rx_ring[i];
5716 if (rx_ring->type != TX_Q) {
5717 ql_free_sbq_buffers(rx_ring);
5718 ql_free_lbq_buffers(rx_ring);
5719 }
5720 }
5721 /* reallocate large buffer pool */
5722 for (i = 0; i < qlge->rx_ring_count; i++) {
5723 rx_ring = &qlge->rx_ring[i];
5724 if (rx_ring->type != TX_Q) {
5725 (void) ql_alloc_sbufs(qlge, rx_ring);
5726 (void) ql_alloc_lbufs(qlge, rx_ring);
5727 }
5728 }
5729 }
5730 }
5731
5732 if (ql_bringup_adapter(qlge) != DDI_SUCCESS) {
5733 cmn_err(CE_WARN, "qlge bringup adapter failed");
5734 mutex_exit(&qlge->hw_mutex);
5735 if (qlge->fm_enable) {
5736 atomic_or_32(&qlge->flags, ADAPTER_ERROR);
5737 ddi_fm_service_impact(qlge->dip, DDI_SERVICE_LOST);
5738 }
5739 return (DDI_FAILURE);
5740 }
5741
5742 mutex_exit(&qlge->hw_mutex);
5743 /* if adapter is up successfully but was bad before */
5744 if (qlge->flags & ADAPTER_ERROR) {
5745 atomic_and_32(&qlge->flags, ~ADAPTER_ERROR);
5746 if (qlge->fm_enable) {
5747 ddi_fm_service_impact(qlge->dip, DDI_SERVICE_RESTORED);
5748 }
5749 }
5750
5751 /* Get current link state */
5752 qlge->port_link_state = ql_get_link_state(qlge);
5753
5754 if (qlge->port_link_state == LS_UP) {
5755 QL_PRINT(DBG_GLD, ("%s(%d) Link UP !!\n",
5756 __func__, qlge->instance));
5757 /* If driver detects a carrier on */
5758 CARRIER_ON(qlge);
5759 } else {
5760 QL_PRINT(DBG_GLD, ("%s(%d) Link down\n",
5761 __func__, qlge->instance));
5762 /* If driver detects a lack of carrier */
5763 CARRIER_OFF(qlge);
5764 }
5765 qlge->mac_flags = QL_MAC_STARTED;
5766 return (DDI_SUCCESS);
5767 }
5768
5769 /*
5770 * Stop currently running driver
5771 * Driver needs to stop routing new packets to driver and wait until
5772 * all pending tx/rx buffers to be free-ed.
5773 */
5774 int
5775 ql_do_stop(qlge_t *qlge)
5776 {
5777 int rc = DDI_FAILURE;
5778 uint32_t i, j, k;
5779 struct bq_desc *sbq_desc, *lbq_desc;
5780 struct rx_ring *rx_ring;
5781
5782 ASSERT(qlge != NULL);
5783
5784 CARRIER_OFF(qlge);
5785
5786 rc = ql_bringdown_adapter(qlge);
5787 if (rc != DDI_SUCCESS) {
5788 cmn_err(CE_WARN, "qlge bringdown adapter failed.");
5789 } else
5790 rc = DDI_SUCCESS;
5791
5792 for (k = 0; k < qlge->rx_ring_count; k++) {
5793 rx_ring = &qlge->rx_ring[k];
5794 if (rx_ring->type != TX_Q) {
5795 j = rx_ring->lbq_use_head;
5796 #ifdef QLGE_LOAD_UNLOAD
5797 cmn_err(CE_NOTE, "ring %d: move %d lbufs in use list"
5798 " to free list %d\n total %d\n",
5799 k, rx_ring->lbuf_in_use_count,
5800 rx_ring->lbuf_free_count,
5801 rx_ring->lbuf_in_use_count +
5802 rx_ring->lbuf_free_count);
5803 #endif
5804 for (i = 0; i < rx_ring->lbuf_in_use_count; i++) {
5805 lbq_desc = rx_ring->lbuf_in_use[j];
5806 j++;
5807 if (j >= rx_ring->lbq_len) {
5808 j = 0;
5809 }
5810 if (lbq_desc->mp) {
5811 atomic_inc_32(&rx_ring->rx_indicate);
5812 freemsg(lbq_desc->mp);
5813 }
5814 }
5815 rx_ring->lbq_use_head = j;
5816 rx_ring->lbq_use_tail = j;
5817 rx_ring->lbuf_in_use_count = 0;
5818 j = rx_ring->sbq_use_head;
5819 #ifdef QLGE_LOAD_UNLOAD
5820 cmn_err(CE_NOTE, "ring %d: move %d sbufs in use list,"
5821 " to free list %d\n total %d \n",
5822 k, rx_ring->sbuf_in_use_count,
5823 rx_ring->sbuf_free_count,
5824 rx_ring->sbuf_in_use_count +
5825 rx_ring->sbuf_free_count);
5826 #endif
5827 for (i = 0; i < rx_ring->sbuf_in_use_count; i++) {
5828 sbq_desc = rx_ring->sbuf_in_use[j];
5829 j++;
5830 if (j >= rx_ring->sbq_len) {
5831 j = 0;
5832 }
5833 if (sbq_desc->mp) {
5834 atomic_inc_32(&rx_ring->rx_indicate);
5835 freemsg(sbq_desc->mp);
5836 }
5837 }
5838 rx_ring->sbq_use_head = j;
5839 rx_ring->sbq_use_tail = j;
5840 rx_ring->sbuf_in_use_count = 0;
5841 }
5842 }
5843
5844 qlge->mac_flags = QL_MAC_STOPPED;
5845
5846 return (rc);
5847 }
5848
5849 /*
5850 * Support
5851 */
5852
5853 void
5854 ql_disable_isr(qlge_t *qlge)
5855 {
5856 /*
5857 * disable the hardware interrupt
5858 */
5859 ISP_DISABLE_GLOBAL_INTRS(qlge);
5860
5861 qlge->flags &= ~INTERRUPTS_ENABLED;
5862 }
5863
5864
5865
5866 /*
5867 * busy wait for 'usecs' microseconds.
5868 */
5869 void
5870 qlge_delay(clock_t usecs)
5871 {
5872 drv_usecwait(usecs);
5873 }
5874
5875 /*
5876 * retrieve firmware details.
5877 */
5878
5879 pci_cfg_t *
5880 ql_get_pci_config(qlge_t *qlge)
5881 {
5882 return (&(qlge->pci_cfg));
5883 }
5884
5885 /*
5886 * Get current Link status
5887 */
5888 static uint32_t
5889 ql_get_link_state(qlge_t *qlge)
5890 {
5891 uint32_t bitToCheck = 0;
5892 uint32_t temp, linkState;
5893
5894 if (qlge->func_number == qlge->fn0_net) {
5895 bitToCheck = STS_PL0;
5896 } else {
5897 bitToCheck = STS_PL1;
5898 }
5899 temp = ql_read_reg(qlge, REG_STATUS);
5900 QL_PRINT(DBG_GLD, ("%s(%d) chip status reg: 0x%x\n",
5901 __func__, qlge->instance, temp));
5902
5903 if (temp & bitToCheck) {
5904 linkState = LS_UP;
5905 } else {
5906 linkState = LS_DOWN;
5907 }
5908 if (CFG_IST(qlge, CFG_CHIP_8100)) {
5909 /* for Schultz, link Speed is fixed to 10G, full duplex */
5910 qlge->speed = SPEED_10G;
5911 qlge->duplex = 1;
5912 }
5913 return (linkState);
5914 }
5915 /*
5916 * Get current link status and report to OS
5917 */
5918 static void
5919 ql_get_and_report_link_state(qlge_t *qlge)
5920 {
5921 uint32_t cur_link_state;
5922
5923 /* Get current link state */
5924 cur_link_state = ql_get_link_state(qlge);
5925 /* if link state has changed */
5926 if (cur_link_state != qlge->port_link_state) {
5927
5928 qlge->port_link_state = cur_link_state;
5929
5930 if (qlge->port_link_state == LS_UP) {
5931 QL_PRINT(DBG_GLD, ("%s(%d) Link UP !!\n",
5932 __func__, qlge->instance));
5933 /* If driver detects a carrier on */
5934 CARRIER_ON(qlge);
5935 } else {
5936 QL_PRINT(DBG_GLD, ("%s(%d) Link down\n",
5937 __func__, qlge->instance));
5938 /* If driver detects a lack of carrier */
5939 CARRIER_OFF(qlge);
5940 }
5941 }
5942 }
5943
5944 /*
5945 * timer callback function executed after timer expires
5946 */
5947 static void
5948 ql_timer(void* arg)
5949 {
5950 ql_get_and_report_link_state((qlge_t *)arg);
5951 }
5952
5953 /*
5954 * stop the running timer if activated
5955 */
5956 static void
5957 ql_stop_timer(qlge_t *qlge)
5958 {
5959 timeout_id_t timer_id;
5960 /* Disable driver timer */
5961 if (qlge->ql_timer_timeout_id != NULL) {
5962 timer_id = qlge->ql_timer_timeout_id;
5963 qlge->ql_timer_timeout_id = NULL;
5964 (void) untimeout(timer_id);
5965 }
5966 }
5967
5968 /*
5969 * stop then restart timer
5970 */
5971 void
5972 ql_restart_timer(qlge_t *qlge)
5973 {
5974 ql_stop_timer(qlge);
5975 qlge->ql_timer_ticks = TICKS_PER_SEC / 4;
5976 qlge->ql_timer_timeout_id = timeout(ql_timer,
5977 (void *)qlge, qlge->ql_timer_ticks);
5978 }
5979
5980 /* ************************************************************************* */
5981 /*
5982 * Hardware K-Stats Data Structures and Subroutines
5983 */
5984 /* ************************************************************************* */
5985 static const ql_ksindex_t ql_kstats_hw[] = {
5986 /* PCI related hardware information */
5987 { 0, "Vendor Id" },
5988 { 1, "Device Id" },
5989 { 2, "Command" },
5990 { 3, "Status" },
5991 { 4, "Revision Id" },
5992 { 5, "Cache Line Size" },
5993 { 6, "Latency Timer" },
5994 { 7, "Header Type" },
5995 { 9, "I/O base addr" },
5996 { 10, "Control Reg Base addr low" },
5997 { 11, "Control Reg Base addr high" },
5998 { 12, "Doorbell Reg Base addr low" },
5999 { 13, "Doorbell Reg Base addr high" },
6000 { 14, "Subsystem Vendor Id" },
6001 { 15, "Subsystem Device ID" },
6002 { 16, "PCIe Device Control" },
6003 { 17, "PCIe Link Status" },
6004
6005 { -1, NULL },
6006 };
6007
6008 /*
6009 * kstat update function for PCI registers
6010 */
6011 static int
6012 ql_kstats_get_pci_regs(kstat_t *ksp, int flag)
6013 {
6014 qlge_t *qlge;
6015 kstat_named_t *knp;
6016
6017 if (flag != KSTAT_READ)
6018 return (EACCES);
6019
6020 qlge = ksp->ks_private;
6021 knp = ksp->ks_data;
6022 (knp++)->value.ui32 = qlge->pci_cfg.vendor_id;
6023 (knp++)->value.ui32 = qlge->pci_cfg.device_id;
6024 (knp++)->value.ui32 = qlge->pci_cfg.command;
6025 (knp++)->value.ui32 = qlge->pci_cfg.status;
6026 (knp++)->value.ui32 = qlge->pci_cfg.revision;
6027 (knp++)->value.ui32 = qlge->pci_cfg.cache_line_size;
6028 (knp++)->value.ui32 = qlge->pci_cfg.latency_timer;
6029 (knp++)->value.ui32 = qlge->pci_cfg.header_type;
6030 (knp++)->value.ui32 = qlge->pci_cfg.io_base_address;
6031 (knp++)->value.ui32 =
6032 qlge->pci_cfg.pci_cntl_reg_set_mem_base_address_lower;
6033 (knp++)->value.ui32 =
6034 qlge->pci_cfg.pci_cntl_reg_set_mem_base_address_upper;
6035 (knp++)->value.ui32 =
6036 qlge->pci_cfg.pci_doorbell_mem_base_address_lower;
6037 (knp++)->value.ui32 =
6038 qlge->pci_cfg.pci_doorbell_mem_base_address_upper;
6039 (knp++)->value.ui32 = qlge->pci_cfg.sub_vendor_id;
6040 (knp++)->value.ui32 = qlge->pci_cfg.sub_device_id;
6041 (knp++)->value.ui32 = qlge->pci_cfg.pcie_device_control;
6042 (knp++)->value.ui32 = qlge->pci_cfg.link_status;
6043
6044 return (0);
6045 }
6046
6047 static const ql_ksindex_t ql_kstats_mii[] = {
6048 /* MAC/MII related hardware information */
6049 { 0, "mtu"},
6050
6051 { -1, NULL},
6052 };
6053
6054
6055 /*
6056 * kstat update function for MII related information.
6057 */
6058 static int
6059 ql_kstats_mii_update(kstat_t *ksp, int flag)
6060 {
6061 qlge_t *qlge;
6062 kstat_named_t *knp;
6063
6064 if (flag != KSTAT_READ)
6065 return (EACCES);
6066
6067 qlge = ksp->ks_private;
6068 knp = ksp->ks_data;
6069
6070 (knp++)->value.ui32 = qlge->mtu;
6071
6072 return (0);
6073 }
6074
6075 static const ql_ksindex_t ql_kstats_reg[] = {
6076 /* Register information */
6077 { 0, "System (0x08)" },
6078 { 1, "Reset/Fail Over(0x0Ch" },
6079 { 2, "Function Specific Control(0x10)" },
6080 { 3, "Status (0x30)" },
6081 { 4, "Intr Enable (0x34)" },
6082 { 5, "Intr Status1 (0x3C)" },
6083 { 6, "Error Status (0x54)" },
6084 { 7, "XGMAC Flow Control(0x11C)" },
6085 { 8, "XGMAC Tx Pause Frames(0x230)" },
6086 { 9, "XGMAC Rx Pause Frames(0x388)" },
6087 { 10, "XGMAC Rx FIFO Drop Count(0x5B8)" },
6088 { 11, "interrupts actually allocated" },
6089 { 12, "interrupts on rx ring 0" },
6090 { 13, "interrupts on rx ring 1" },
6091 { 14, "interrupts on rx ring 2" },
6092 { 15, "interrupts on rx ring 3" },
6093 { 16, "interrupts on rx ring 4" },
6094 { 17, "interrupts on rx ring 5" },
6095 { 18, "interrupts on rx ring 6" },
6096 { 19, "interrupts on rx ring 7" },
6097 { 20, "polls on rx ring 0" },
6098 { 21, "polls on rx ring 1" },
6099 { 22, "polls on rx ring 2" },
6100 { 23, "polls on rx ring 3" },
6101 { 24, "polls on rx ring 4" },
6102 { 25, "polls on rx ring 5" },
6103 { 26, "polls on rx ring 6" },
6104 { 27, "polls on rx ring 7" },
6105 { 28, "tx no resource on ring 0" },
6106 { 29, "tx dma bind fail on ring 0" },
6107 { 30, "tx dma no handle on ring 0" },
6108 { 31, "tx dma no cookie on ring 0" },
6109 { 32, "MPI firmware major version" },
6110 { 33, "MPI firmware minor version" },
6111 { 34, "MPI firmware sub version" },
6112 { 35, "rx no resource" },
6113
6114 { -1, NULL},
6115 };
6116
6117
6118 /*
6119 * kstat update function for device register set
6120 */
6121 static int
6122 ql_kstats_get_reg_and_dev_stats(kstat_t *ksp, int flag)
6123 {
6124 qlge_t *qlge;
6125 kstat_named_t *knp;
6126 uint32_t val32;
6127 int i = 0;
6128 struct tx_ring *tx_ring;
6129 struct rx_ring *rx_ring;
6130
6131 if (flag != KSTAT_READ)
6132 return (EACCES);
6133
6134 qlge = ksp->ks_private;
6135 knp = ksp->ks_data;
6136
6137 (knp++)->value.ui32 = ql_read_reg(qlge, REG_SYSTEM);
6138 (knp++)->value.ui32 = ql_read_reg(qlge, REG_RESET_FAILOVER);
6139 (knp++)->value.ui32 = ql_read_reg(qlge, REG_FUNCTION_SPECIFIC_CONTROL);
6140 (knp++)->value.ui32 = ql_read_reg(qlge, REG_STATUS);
6141 (knp++)->value.ui32 = ql_read_reg(qlge, REG_INTERRUPT_ENABLE);
6142 (knp++)->value.ui32 = ql_read_reg(qlge, REG_INTERRUPT_STATUS_1);
6143 (knp++)->value.ui32 = ql_read_reg(qlge, REG_ERROR_STATUS);
6144
6145 if (ql_sem_spinlock(qlge, qlge->xgmac_sem_mask)) {
6146 return (0);
6147 }
6148 (void) ql_read_xgmac_reg(qlge, REG_XGMAC_FLOW_CONTROL, &val32);
6149 (knp++)->value.ui32 = val32;
6150
6151 (void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_TX_PAUSE_PKTS, &val32);
6152 (knp++)->value.ui32 = val32;
6153
6154 (void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_RX_PAUSE_PKTS, &val32);
6155 (knp++)->value.ui32 = val32;
6156
6157 (void) ql_read_xgmac_reg(qlge, REG_XGMAC_MAC_RX_FIFO_DROPS, &val32);
6158 (knp++)->value.ui32 = val32;
6159
6160 ql_sem_unlock(qlge, qlge->xgmac_sem_mask);
6161
6162 (knp++)->value.ui32 = qlge->intr_cnt;
6163
6164 for (i = 0; i < 8; i++) {
6165 (knp++)->value.ui32 = qlge->rx_interrupts[i];
6166 }
6167
6168 for (i = 0; i < 8; i++) {
6169 (knp++)->value.ui32 = qlge->rx_polls[i];
6170 }
6171
6172 tx_ring = &qlge->tx_ring[0];
6173 (knp++)->value.ui32 = tx_ring->defer;
6174 (knp++)->value.ui32 = tx_ring->tx_fail_dma_bind;
6175 (knp++)->value.ui32 = tx_ring->tx_no_dma_handle;
6176 (knp++)->value.ui32 = tx_ring->tx_no_dma_cookie;
6177
6178 (knp++)->value.ui32 = qlge->fw_version_info.major_version;
6179 (knp++)->value.ui32 = qlge->fw_version_info.minor_version;
6180 (knp++)->value.ui32 = qlge->fw_version_info.sub_minor_version;
6181
6182 for (i = 0; i < qlge->rx_ring_count; i++) {
6183 rx_ring = &qlge->rx_ring[i];
6184 val32 += rx_ring->rx_packets_dropped_no_buffer;
6185 }
6186 (knp++)->value.ui32 = val32;
6187
6188 return (0);
6189 }
6190
6191
6192 static kstat_t *
6193 ql_setup_named_kstat(qlge_t *qlge, int instance, char *name,
6194 const ql_ksindex_t *ksip, size_t size, int (*update)(kstat_t *, int))
6195 {
6196 kstat_t *ksp;
6197 kstat_named_t *knp;
6198 char *np;
6199 int type;
6200
6201 size /= sizeof (ql_ksindex_t);
6202 ksp = kstat_create(ADAPTER_NAME, instance, name, "net",
6203 KSTAT_TYPE_NAMED, ((uint32_t)size) - 1, KSTAT_FLAG_PERSISTENT);
6204 if (ksp == NULL)
6205 return (NULL);
6206
6207 ksp->ks_private = qlge;
6208 ksp->ks_update = update;
6209 for (knp = ksp->ks_data; (np = ksip->name) != NULL; ++knp, ++ksip) {
6210 switch (*np) {
6211 default:
6212 type = KSTAT_DATA_UINT32;
6213 break;
6214 case '&':
6215 np += 1;
6216 type = KSTAT_DATA_CHAR;
6217 break;
6218 }
6219 kstat_named_init(knp, np, (uint8_t)type);
6220 }
6221 kstat_install(ksp);
6222
6223 return (ksp);
6224 }
6225
6226 /*
6227 * Setup various kstat
6228 */
6229 int
6230 ql_init_kstats(qlge_t *qlge)
6231 {
6232 /* Hardware KStats */
6233 qlge->ql_kstats[QL_KSTAT_CHIP] = ql_setup_named_kstat(qlge,
6234 qlge->instance, "chip", ql_kstats_hw,
6235 sizeof (ql_kstats_hw), ql_kstats_get_pci_regs);
6236 if (qlge->ql_kstats[QL_KSTAT_CHIP] == NULL) {
6237 return (DDI_FAILURE);
6238 }
6239
6240 /* MII KStats */
6241 qlge->ql_kstats[QL_KSTAT_LINK] = ql_setup_named_kstat(qlge,
6242 qlge->instance, "mii", ql_kstats_mii,
6243 sizeof (ql_kstats_mii), ql_kstats_mii_update);
6244 if (qlge->ql_kstats[QL_KSTAT_LINK] == NULL) {
6245 return (DDI_FAILURE);
6246 }
6247
6248 /* REG KStats */
6249 qlge->ql_kstats[QL_KSTAT_REG] = ql_setup_named_kstat(qlge,
6250 qlge->instance, "reg", ql_kstats_reg,
6251 sizeof (ql_kstats_reg), ql_kstats_get_reg_and_dev_stats);
6252 if (qlge->ql_kstats[QL_KSTAT_REG] == NULL) {
6253 return (DDI_FAILURE);
6254 }
6255 return (DDI_SUCCESS);
6256 }
6257
6258 /*
6259 * delete all kstat
6260 */
6261 void
6262 ql_fini_kstats(qlge_t *qlge)
6263 {
6264 int i;
6265
6266 for (i = 0; i < QL_KSTAT_COUNT; i++) {
6267 if (qlge->ql_kstats[i] != NULL)
6268 kstat_delete(qlge->ql_kstats[i]);
6269 }
6270 }
6271
6272 /* ************************************************************************* */
6273 /*
6274 * kstat end
6275 */
6276 /* ************************************************************************* */
6277
6278 /*
6279 * Setup the parameters for receive and transmit rings including buffer sizes
6280 * and completion queue sizes
6281 */
6282 static int
6283 ql_setup_rings(qlge_t *qlge)
6284 {
6285 uint8_t i;
6286 struct rx_ring *rx_ring;
6287 struct tx_ring *tx_ring;
6288 uint16_t lbq_buf_size;
6289
6290 lbq_buf_size = (uint16_t)
6291 ((qlge->mtu == ETHERMTU)? LRG_BUF_NORMAL_SIZE : LRG_BUF_JUMBO_SIZE);
6292
6293 /*
6294 * rx_ring[0] is always the default queue.
6295 */
6296 /*
6297 * qlge->rx_ring_count:
6298 * Total number of rx_rings. This includes a number
6299 * of outbound completion handler rx_rings, and a
6300 * number of inbound completion handler rx_rings.
6301 * rss is only enabled if we have more than 1 rx completion
6302 * queue. If we have a single rx completion queue
6303 * then all rx completions go to this queue and
6304 * the last completion queue
6305 */
6306
6307 qlge->tx_ring_first_cq_id = qlge->rss_ring_count;
6308
6309 for (i = 0; i < qlge->tx_ring_count; i++) {
6310 tx_ring = &qlge->tx_ring[i];
6311 bzero((void *)tx_ring, sizeof (*tx_ring));
6312 tx_ring->qlge = qlge;
6313 tx_ring->wq_id = i;
6314 tx_ring->wq_len = qlge->tx_ring_size;
6315 tx_ring->wq_size = (uint32_t)(
6316 tx_ring->wq_len * sizeof (struct ob_mac_iocb_req));
6317
6318 /*
6319 * The completion queue ID for the tx rings start
6320 * immediately after the last rss completion queue.
6321 */
6322 tx_ring->cq_id = (uint16_t)(i + qlge->tx_ring_first_cq_id);
6323 }
6324
6325 for (i = 0; i < qlge->rx_ring_count; i++) {
6326 rx_ring = &qlge->rx_ring[i];
6327 bzero((void *)rx_ring, sizeof (*rx_ring));
6328 rx_ring->qlge = qlge;
6329 rx_ring->cq_id = i;
6330 if (i != 0)
6331 rx_ring->cpu = (i) % qlge->rx_ring_count;
6332 else
6333 rx_ring->cpu = 0;
6334
6335 if (i < qlge->rss_ring_count) {
6336 /*
6337 * Inbound completions (RSS) queues
6338 * Default queue is queue 0 which handles
6339 * unicast plus bcast/mcast and async events.
6340 * Other inbound queues handle unicast frames only.
6341 */
6342 rx_ring->cq_len = qlge->rx_ring_size;
6343 rx_ring->cq_size = (uint32_t)
6344 (rx_ring->cq_len * sizeof (struct net_rsp_iocb));
6345 rx_ring->lbq_len = NUM_LARGE_BUFFERS;
6346 rx_ring->lbq_size = (uint32_t)
6347 (rx_ring->lbq_len * sizeof (uint64_t));
6348 rx_ring->lbq_buf_size = lbq_buf_size;
6349 rx_ring->sbq_len = NUM_SMALL_BUFFERS;
6350 rx_ring->sbq_size = (uint32_t)
6351 (rx_ring->sbq_len * sizeof (uint64_t));
6352 rx_ring->sbq_buf_size = SMALL_BUFFER_SIZE * 2;
6353 rx_ring->type = RX_Q;
6354
6355 QL_PRINT(DBG_GLD,
6356 ("%s(%d)Allocating rss completion queue %d "
6357 "on cpu %d\n", __func__, qlge->instance,
6358 rx_ring->cq_id, rx_ring->cpu));
6359 } else {
6360 /*
6361 * Outbound queue handles outbound completions only
6362 */
6363 /* outbound cq is same size as tx_ring it services. */
6364 QL_PRINT(DBG_INIT, ("rx_ring 0x%p i %d\n", rx_ring, i));
6365 rx_ring->cq_len = qlge->tx_ring_size;
6366 rx_ring->cq_size = (uint32_t)
6367 (rx_ring->cq_len * sizeof (struct net_rsp_iocb));
6368 rx_ring->lbq_len = 0;
6369 rx_ring->lbq_size = 0;
6370 rx_ring->lbq_buf_size = 0;
6371 rx_ring->sbq_len = 0;
6372 rx_ring->sbq_size = 0;
6373 rx_ring->sbq_buf_size = 0;
6374 rx_ring->type = TX_Q;
6375
6376 QL_PRINT(DBG_GLD,
6377 ("%s(%d)Allocating TX completion queue %d on"
6378 " cpu %d\n", __func__, qlge->instance,
6379 rx_ring->cq_id, rx_ring->cpu));
6380 }
6381 }
6382
6383 return (DDI_SUCCESS);
6384 }
6385
6386 static int
6387 ql_start_rx_ring(qlge_t *qlge, struct rx_ring *rx_ring)
6388 {
6389 struct cqicb_t *cqicb = (struct cqicb_t *)rx_ring->cqicb_dma.vaddr;
6390 void *shadow_reg = (uint8_t *)qlge->host_copy_shadow_dma_attr.vaddr +
6391 (rx_ring->cq_id * sizeof (uint64_t) * RX_TX_RING_SHADOW_SPACE)
6392 /* first shadow area is used by wqicb's host copy of consumer index */
6393 + sizeof (uint64_t);
6394 uint64_t shadow_reg_dma = qlge->host_copy_shadow_dma_attr.dma_addr +
6395 (rx_ring->cq_id * sizeof (uint64_t) * RX_TX_RING_SHADOW_SPACE)
6396 + sizeof (uint64_t);
6397 /* lrg/sml bufq pointers */
6398 uint8_t *buf_q_base_reg =
6399 (uint8_t *)qlge->buf_q_ptr_base_addr_dma_attr.vaddr +
6400 (rx_ring->cq_id * sizeof (uint64_t) * BUF_Q_PTR_SPACE);
6401 uint64_t buf_q_base_reg_dma =
6402 qlge->buf_q_ptr_base_addr_dma_attr.dma_addr +
6403 (rx_ring->cq_id * sizeof (uint64_t) * BUF_Q_PTR_SPACE);
6404 caddr_t doorbell_area =
6405 qlge->doorbell_reg_iobase + (VM_PAGE_SIZE * (128 + rx_ring->cq_id));
6406 int err = 0;
6407 uint16_t bq_len;
6408 uint64_t tmp;
6409 uint64_t *base_indirect_ptr;
6410 int page_entries;
6411
6412 /* Set up the shadow registers for this ring. */
6413 rx_ring->prod_idx_sh_reg = shadow_reg;
6414 rx_ring->prod_idx_sh_reg_dma = shadow_reg_dma;
6415 rx_ring->prod_idx_sh_reg_offset = (off_t)(((rx_ring->cq_id *
6416 sizeof (uint64_t) * RX_TX_RING_SHADOW_SPACE) + sizeof (uint64_t)));
6417
6418 rx_ring->lbq_base_indirect = (uint64_t *)(void *)buf_q_base_reg;
6419 rx_ring->lbq_base_indirect_dma = buf_q_base_reg_dma;
6420
6421 QL_PRINT(DBG_INIT, ("%s rx ring(%d): prod_idx virtual addr = 0x%lx,"
6422 " phys_addr 0x%lx\n", __func__, rx_ring->cq_id,
6423 rx_ring->prod_idx_sh_reg, rx_ring->prod_idx_sh_reg_dma));
6424
6425 buf_q_base_reg += ((BUF_Q_PTR_SPACE / 2) * sizeof (uint64_t));
6426 buf_q_base_reg_dma += ((BUF_Q_PTR_SPACE / 2) * sizeof (uint64_t));
6427 rx_ring->sbq_base_indirect = (uint64_t *)(void *)buf_q_base_reg;
6428 rx_ring->sbq_base_indirect_dma = buf_q_base_reg_dma;
6429
6430 /* PCI doorbell mem area + 0x00 for consumer index register */
6431 rx_ring->cnsmr_idx_db_reg = (uint32_t *)(void *)doorbell_area;
6432 rx_ring->cnsmr_idx = 0;
6433 *rx_ring->prod_idx_sh_reg = 0;
6434 rx_ring->curr_entry = rx_ring->cq_dma.vaddr;
6435
6436 /* PCI doorbell mem area + 0x04 for valid register */
6437 rx_ring->valid_db_reg = (uint32_t *)(void *)
6438 ((uint8_t *)(void *)doorbell_area + 0x04);
6439
6440 /* PCI doorbell mem area + 0x18 for large buffer consumer */
6441 rx_ring->lbq_prod_idx_db_reg = (uint32_t *)(void *)
6442 ((uint8_t *)(void *)doorbell_area + 0x18);
6443
6444 /* PCI doorbell mem area + 0x1c */
6445 rx_ring->sbq_prod_idx_db_reg = (uint32_t *)(void *)
6446 ((uint8_t *)(void *)doorbell_area + 0x1c);
6447
6448 bzero((void *)cqicb, sizeof (*cqicb));
6449
6450 cqicb->msix_vect = (uint8_t)rx_ring->irq;
6451
6452 bq_len = (uint16_t)((rx_ring->cq_len == 65536) ?
6453 (uint16_t)0 : (uint16_t)rx_ring->cq_len);
6454 cqicb->len = (uint16_t)cpu_to_le16(bq_len | LEN_V | LEN_CPP_CONT);
6455
6456 cqicb->cq_base_addr_lo =
6457 cpu_to_le32(LS_64BITS(rx_ring->cq_dma.dma_addr));
6458 cqicb->cq_base_addr_hi =
6459 cpu_to_le32(MS_64BITS(rx_ring->cq_dma.dma_addr));
6460
6461 cqicb->prod_idx_addr_lo =
6462 cpu_to_le32(LS_64BITS(rx_ring->prod_idx_sh_reg_dma));
6463 cqicb->prod_idx_addr_hi =
6464 cpu_to_le32(MS_64BITS(rx_ring->prod_idx_sh_reg_dma));
6465
6466 /*
6467 * Set up the control block load flags.
6468 */
6469 cqicb->flags = FLAGS_LC | /* Load queue base address */
6470 FLAGS_LV | /* Load MSI-X vector */
6471 FLAGS_LI; /* Load irq delay values */
6472 if (rx_ring->lbq_len) {
6473 /* Load lbq values */
6474 cqicb->flags = (uint8_t)(cqicb->flags | FLAGS_LL);
6475 tmp = (uint64_t)rx_ring->lbq_dma.dma_addr;
6476 base_indirect_ptr = (uint64_t *)rx_ring->lbq_base_indirect;
6477 page_entries = 0;
6478 do {
6479 *base_indirect_ptr = cpu_to_le64(tmp);
6480 tmp += VM_PAGE_SIZE;
6481 base_indirect_ptr++;
6482 page_entries++;
6483 } while (page_entries < (int)(
6484 ((rx_ring->lbq_len * sizeof (uint64_t)) / VM_PAGE_SIZE)));
6485
6486 cqicb->lbq_addr_lo =
6487 cpu_to_le32(LS_64BITS(rx_ring->lbq_base_indirect_dma));
6488 cqicb->lbq_addr_hi =
6489 cpu_to_le32(MS_64BITS(rx_ring->lbq_base_indirect_dma));
6490 bq_len = (uint16_t)((rx_ring->lbq_buf_size == 65536) ?
6491 (uint16_t)0 : (uint16_t)rx_ring->lbq_buf_size);
6492 cqicb->lbq_buf_size = (uint16_t)cpu_to_le16(bq_len);
6493 bq_len = (uint16_t)((rx_ring->lbq_len == 65536) ? (uint16_t)0 :
6494 (uint16_t)rx_ring->lbq_len);
6495 cqicb->lbq_len = (uint16_t)cpu_to_le16(bq_len);
6496 rx_ring->lbq_prod_idx = 0;
6497 rx_ring->lbq_curr_idx = 0;
6498 }
6499 if (rx_ring->sbq_len) {
6500 /* Load sbq values */
6501 cqicb->flags = (uint8_t)(cqicb->flags | FLAGS_LS);
6502 tmp = (uint64_t)rx_ring->sbq_dma.dma_addr;
6503 base_indirect_ptr = (uint64_t *)rx_ring->sbq_base_indirect;
6504 page_entries = 0;
6505
6506 do {
6507 *base_indirect_ptr = cpu_to_le64(tmp);
6508 tmp += VM_PAGE_SIZE;
6509 base_indirect_ptr++;
6510 page_entries++;
6511 } while (page_entries < (uint32_t)
6512 (((rx_ring->sbq_len * sizeof (uint64_t)) / VM_PAGE_SIZE)));
6513
6514 cqicb->sbq_addr_lo =
6515 cpu_to_le32(LS_64BITS(rx_ring->sbq_base_indirect_dma));
6516 cqicb->sbq_addr_hi =
6517 cpu_to_le32(MS_64BITS(rx_ring->sbq_base_indirect_dma));
6518 cqicb->sbq_buf_size = (uint16_t)
6519 cpu_to_le16((uint16_t)(rx_ring->sbq_buf_size/2));
6520 bq_len = (uint16_t)((rx_ring->sbq_len == 65536) ?
6521 (uint16_t)0 : (uint16_t)rx_ring->sbq_len);
6522 cqicb->sbq_len = (uint16_t)cpu_to_le16(bq_len);
6523 rx_ring->sbq_prod_idx = 0;
6524 rx_ring->sbq_curr_idx = 0;
6525 }
6526 switch (rx_ring->type) {
6527 case TX_Q:
6528 cqicb->irq_delay = (uint16_t)
6529 cpu_to_le16(qlge->tx_coalesce_usecs);
6530 cqicb->pkt_delay = (uint16_t)
6531 cpu_to_le16(qlge->tx_max_coalesced_frames);
6532 break;
6533
6534 case DEFAULT_Q:
6535 cqicb->irq_delay = (uint16_t)
6536 cpu_to_le16(qlge->rx_coalesce_usecs);
6537 cqicb->pkt_delay = (uint16_t)
6538 cpu_to_le16(qlge->rx_max_coalesced_frames);
6539 break;
6540
6541 case RX_Q:
6542 /*
6543 * Inbound completion handling rx_rings run in
6544 * separate NAPI contexts.
6545 */
6546 cqicb->irq_delay = (uint16_t)
6547 cpu_to_le16(qlge->rx_coalesce_usecs);
6548 cqicb->pkt_delay = (uint16_t)
6549 cpu_to_le16(qlge->rx_max_coalesced_frames);
6550 break;
6551 default:
6552 cmn_err(CE_WARN, "Invalid rx_ring->type = %d.",
6553 rx_ring->type);
6554 }
6555 QL_PRINT(DBG_INIT, ("Initializing rx completion queue %d.\n",
6556 rx_ring->cq_id));
6557 /* QL_DUMP_CQICB(qlge, cqicb); */
6558 err = ql_write_cfg(qlge, CFG_LCQ, rx_ring->cqicb_dma.dma_addr,
6559 rx_ring->cq_id);
6560 if (err) {
6561 cmn_err(CE_WARN, "Failed to load CQICB.");
6562 return (err);
6563 }
6564
6565 rx_ring->rx_packets_dropped_no_buffer = 0;
6566 rx_ring->rx_pkt_dropped_mac_unenabled = 0;
6567 rx_ring->rx_failed_sbq_allocs = 0;
6568 rx_ring->rx_failed_lbq_allocs = 0;
6569 rx_ring->rx_packets = 0;
6570 rx_ring->rx_bytes = 0;
6571 rx_ring->frame_too_long = 0;
6572 rx_ring->frame_too_short = 0;
6573 rx_ring->fcs_err = 0;
6574
6575 return (err);
6576 }
6577
6578 /*
6579 * start RSS
6580 */
6581 static int
6582 ql_start_rss(qlge_t *qlge)
6583 {
6584 struct ricb *ricb = (struct ricb *)qlge->ricb_dma.vaddr;
6585 int status = 0;
6586 int i;
6587 uint8_t *hash_id = (uint8_t *)ricb->hash_cq_id;
6588
6589 bzero((void *)ricb, sizeof (*ricb));
6590
6591 ricb->base_cq = RSS_L4K;
6592 ricb->flags =
6593 (RSS_L6K | RSS_LI | RSS_LB | RSS_LM | RSS_RI4 | RSS_RI6 | RSS_RT4 |
6594 RSS_RT6);
6595 ricb->mask = (uint16_t)cpu_to_le16(RSS_HASH_CQ_ID_MAX - 1);
6596
6597 /*
6598 * Fill out the Indirection Table.
6599 */
6600 for (i = 0; i < RSS_HASH_CQ_ID_MAX; i++)
6601 hash_id[i] = (uint8_t)(i & (qlge->rss_ring_count - 1));
6602
6603 (void) memcpy(&ricb->ipv6_hash_key[0], key_data, 40);
6604 (void) memcpy(&ricb->ipv4_hash_key[0], key_data, 16);
6605
6606 QL_PRINT(DBG_INIT, ("Initializing RSS.\n"));
6607
6608 status = ql_write_cfg(qlge, CFG_LR, qlge->ricb_dma.dma_addr, 0);
6609 if (status) {
6610 cmn_err(CE_WARN, "Failed to load RICB.");
6611 return (status);
6612 }
6613
6614 return (status);
6615 }
6616
6617 /*
6618 * load a tx ring control block to hw and start this ring
6619 */
6620 static int
6621 ql_start_tx_ring(qlge_t *qlge, struct tx_ring *tx_ring)
6622 {
6623 struct wqicb_t *wqicb = (struct wqicb_t *)tx_ring->wqicb_dma.vaddr;
6624 caddr_t doorbell_area =
6625 qlge->doorbell_reg_iobase + (VM_PAGE_SIZE * tx_ring->wq_id);
6626 void *shadow_reg = (uint8_t *)qlge->host_copy_shadow_dma_attr.vaddr +
6627 (tx_ring->wq_id * sizeof (uint64_t)) * RX_TX_RING_SHADOW_SPACE;
6628 uint64_t shadow_reg_dma = qlge->host_copy_shadow_dma_attr.dma_addr +
6629 (tx_ring->wq_id * sizeof (uint64_t)) * RX_TX_RING_SHADOW_SPACE;
6630 int err = 0;
6631
6632 /*
6633 * Assign doorbell registers for this tx_ring.
6634 */
6635
6636 /* TX PCI doorbell mem area for tx producer index */
6637 tx_ring->prod_idx_db_reg = (uint32_t *)(void *)doorbell_area;
6638 tx_ring->prod_idx = 0;
6639 /* TX PCI doorbell mem area + 0x04 */
6640 tx_ring->valid_db_reg = (uint32_t *)(void *)
6641 ((uint8_t *)(void *)doorbell_area + 0x04);
6642
6643 /*
6644 * Assign shadow registers for this tx_ring.
6645 */
6646 tx_ring->cnsmr_idx_sh_reg = shadow_reg;
6647 tx_ring->cnsmr_idx_sh_reg_dma = shadow_reg_dma;
6648 *tx_ring->cnsmr_idx_sh_reg = 0;
6649
6650 QL_PRINT(DBG_INIT, ("%s tx ring(%d): cnsmr_idx virtual addr = 0x%lx,"
6651 " phys_addr 0x%lx\n",
6652 __func__, tx_ring->wq_id, tx_ring->cnsmr_idx_sh_reg,
6653 tx_ring->cnsmr_idx_sh_reg_dma));
6654
6655 wqicb->len =
6656 (uint16_t)cpu_to_le16(tx_ring->wq_len | Q_LEN_V | Q_LEN_CPP_CONT);
6657 wqicb->flags = cpu_to_le16(Q_FLAGS_LC |
6658 Q_FLAGS_LB | Q_FLAGS_LI | Q_FLAGS_LO);
6659 wqicb->cq_id_rss = (uint16_t)cpu_to_le16(tx_ring->cq_id);
6660 wqicb->rid = 0;
6661 wqicb->wq_addr_lo = cpu_to_le32(LS_64BITS(tx_ring->wq_dma.dma_addr));
6662 wqicb->wq_addr_hi = cpu_to_le32(MS_64BITS(tx_ring->wq_dma.dma_addr));
6663 wqicb->cnsmr_idx_addr_lo =
6664 cpu_to_le32(LS_64BITS(tx_ring->cnsmr_idx_sh_reg_dma));
6665 wqicb->cnsmr_idx_addr_hi =
6666 cpu_to_le32(MS_64BITS(tx_ring->cnsmr_idx_sh_reg_dma));
6667
6668 ql_init_tx_ring(tx_ring);
6669 /* QL_DUMP_WQICB(qlge, wqicb); */
6670 err = ql_write_cfg(qlge, CFG_LRQ, tx_ring->wqicb_dma.dma_addr,
6671 tx_ring->wq_id);
6672
6673 if (err) {
6674 cmn_err(CE_WARN, "Failed to load WQICB.");
6675 return (err);
6676 }
6677 return (err);
6678 }
6679
6680 /*
6681 * Set up a MAC, multicast or VLAN address for the
6682 * inbound frame matching.
6683 */
6684 int
6685 ql_set_mac_addr_reg(qlge_t *qlge, uint8_t *addr, uint32_t type,
6686 uint16_t index)
6687 {
6688 uint32_t offset = 0;
6689 int status = DDI_SUCCESS;
6690
6691 switch (type) {
6692 case MAC_ADDR_TYPE_MULTI_MAC:
6693 case MAC_ADDR_TYPE_CAM_MAC: {
6694 uint32_t cam_output;
6695 uint32_t upper = (addr[0] << 8) | addr[1];
6696 uint32_t lower =
6697 (addr[2] << 24) | (addr[3] << 16) | (addr[4] << 8) |
6698 (addr[5]);
6699
6700 QL_PRINT(DBG_INIT, ("Adding %s ", (type ==
6701 MAC_ADDR_TYPE_MULTI_MAC) ?
6702 "MULTICAST" : "UNICAST"));
6703 QL_PRINT(DBG_INIT,
6704 ("addr %02x %02x %02x %02x %02x %02x at index %d in "
6705 "the CAM.\n",
6706 addr[0], addr[1], addr[2], addr[3], addr[4],
6707 addr[5], index));
6708
6709 status = ql_wait_reg_rdy(qlge,
6710 REG_MAC_PROTOCOL_ADDRESS_INDEX, MAC_ADDR_MW, 0);
6711 if (status)
6712 goto exit;
6713 /* offset 0 - lower 32 bits of the MAC address */
6714 ql_write_reg(qlge, REG_MAC_PROTOCOL_ADDRESS_INDEX,
6715 (offset++) |
6716 (index << MAC_ADDR_IDX_SHIFT) | /* index */
6717 type); /* type */
6718 ql_write_reg(qlge, REG_MAC_PROTOCOL_DATA, lower);
6719 status = ql_wait_reg_rdy(qlge,
6720 REG_MAC_PROTOCOL_ADDRESS_INDEX, MAC_ADDR_MW, 0);
6721 if (status)
6722 goto exit;
6723 /* offset 1 - upper 16 bits of the MAC address */
6724 ql_write_reg(qlge, REG_MAC_PROTOCOL_ADDRESS_INDEX,
6725 (offset++) |
6726 (index << MAC_ADDR_IDX_SHIFT) | /* index */
6727 type); /* type */
6728 ql_write_reg(qlge, REG_MAC_PROTOCOL_DATA, upper);
6729 status = ql_wait_reg_rdy(qlge,
6730 REG_MAC_PROTOCOL_ADDRESS_INDEX, MAC_ADDR_MW, 0);
6731 if (status)
6732 goto exit;
6733 /* offset 2 - CQ ID associated with this MAC address */
6734 ql_write_reg(qlge, REG_MAC_PROTOCOL_ADDRESS_INDEX,
6735 (offset) | (index << MAC_ADDR_IDX_SHIFT) | /* index */
6736 type); /* type */
6737 /*
6738 * This field should also include the queue id
6739 * and possibly the function id. Right now we hardcode
6740 * the route field to NIC core.
6741 */
6742 if (type == MAC_ADDR_TYPE_CAM_MAC) {
6743 cam_output = (CAM_OUT_ROUTE_NIC |
6744 (qlge->func_number << CAM_OUT_FUNC_SHIFT) |
6745 (0 <<
6746 CAM_OUT_CQ_ID_SHIFT));
6747
6748 /* route to NIC core */
6749 ql_write_reg(qlge, REG_MAC_PROTOCOL_DATA,
6750 cam_output);
6751 }
6752 break;
6753 }
6754 default:
6755 cmn_err(CE_WARN,
6756 "Address type %d not yet supported.", type);
6757 status = DDI_FAILURE;
6758 }
6759 exit:
6760 return (status);
6761 }
6762
6763 /*
6764 * The NIC function for this chip has 16 routing indexes. Each one can be used
6765 * to route different frame types to various inbound queues. We send broadcast
6766 * multicast/error frames to the default queue for slow handling,
6767 * and CAM hit/RSS frames to the fast handling queues.
6768 */
6769 static int
6770 ql_set_routing_reg(qlge_t *qlge, uint32_t index, uint32_t mask, int enable)
6771 {
6772 int status;
6773 uint32_t value = 0;
6774
6775 QL_PRINT(DBG_INIT,
6776 ("%s %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s mask %s the routing reg.\n",
6777 (enable ? "Adding" : "Removing"),
6778 ((index == RT_IDX_ALL_ERR_SLOT) ? "MAC ERROR/ALL ERROR" : ""),
6779 ((index == RT_IDX_IP_CSUM_ERR_SLOT) ? "IP CSUM ERROR" : ""),
6780 ((index ==
6781 RT_IDX_TCP_UDP_CSUM_ERR_SLOT) ? "TCP/UDP CSUM ERROR" : ""),
6782 ((index == RT_IDX_BCAST_SLOT) ? "BROADCAST" : ""),
6783 ((index == RT_IDX_MCAST_MATCH_SLOT) ? "MULTICAST MATCH" : ""),
6784 ((index == RT_IDX_ALLMULTI_SLOT) ? "ALL MULTICAST MATCH" : ""),
6785 ((index == RT_IDX_UNUSED6_SLOT) ? "UNUSED6" : ""),
6786 ((index == RT_IDX_UNUSED7_SLOT) ? "UNUSED7" : ""),
6787 ((index == RT_IDX_RSS_MATCH_SLOT) ? "RSS ALL/IPV4 MATCH" : ""),
6788 ((index == RT_IDX_RSS_IPV6_SLOT) ? "RSS IPV6" : ""),
6789 ((index == RT_IDX_RSS_TCP4_SLOT) ? "RSS TCP4" : ""),
6790 ((index == RT_IDX_RSS_TCP6_SLOT) ? "RSS TCP6" : ""),
6791 ((index == RT_IDX_CAM_HIT_SLOT) ? "CAM HIT" : ""),
6792 ((index == RT_IDX_UNUSED013) ? "UNUSED13" : ""),
6793 ((index == RT_IDX_UNUSED014) ? "UNUSED14" : ""),
6794 ((index == RT_IDX_PROMISCUOUS_SLOT) ? "PROMISCUOUS" : ""),
6795 (enable ? "to" : "from")));
6796
6797 switch (mask) {
6798 case RT_IDX_CAM_HIT:
6799 value = RT_IDX_DST_CAM_Q | /* dest */
6800 RT_IDX_TYPE_NICQ | /* type */
6801 (RT_IDX_CAM_HIT_SLOT << RT_IDX_IDX_SHIFT); /* index */
6802 break;
6803
6804 case RT_IDX_VALID: /* Promiscuous Mode frames. */
6805 value = RT_IDX_DST_DFLT_Q | /* dest */
6806 RT_IDX_TYPE_NICQ | /* type */
6807 (RT_IDX_PROMISCUOUS_SLOT << RT_IDX_IDX_SHIFT); /* index */
6808 break;
6809
6810 case RT_IDX_ERR: /* Pass up MAC,IP,TCP/UDP error frames. */
6811 value = RT_IDX_DST_DFLT_Q | /* dest */
6812 RT_IDX_TYPE_NICQ | /* type */
6813 (RT_IDX_ALL_ERR_SLOT << RT_IDX_IDX_SHIFT); /* index */
6814 break;
6815
6816 case RT_IDX_BCAST: /* Pass up Broadcast frames to default Q. */
6817 value = RT_IDX_DST_DFLT_Q | /* dest */
6818 RT_IDX_TYPE_NICQ | /* type */
6819 (RT_IDX_BCAST_SLOT << RT_IDX_IDX_SHIFT); /* index */
6820 break;
6821
6822 case RT_IDX_MCAST: /* Pass up All Multicast frames. */
6823 value = RT_IDX_DST_CAM_Q | /* dest */
6824 RT_IDX_TYPE_NICQ | /* type */
6825 (RT_IDX_ALLMULTI_SLOT << RT_IDX_IDX_SHIFT); /* index */
6826 break;
6827
6828 case RT_IDX_MCAST_MATCH: /* Pass up matched Multicast frames. */
6829 value = RT_IDX_DST_CAM_Q | /* dest */
6830 RT_IDX_TYPE_NICQ | /* type */
6831 (RT_IDX_MCAST_MATCH_SLOT << RT_IDX_IDX_SHIFT); /* index */
6832 break;
6833
6834 case RT_IDX_RSS_MATCH: /* Pass up matched RSS frames. */
6835 value = RT_IDX_DST_RSS | /* dest */
6836 RT_IDX_TYPE_NICQ | /* type */
6837 (RT_IDX_RSS_MATCH_SLOT << RT_IDX_IDX_SHIFT); /* index */
6838 break;
6839
6840 case 0: /* Clear the E-bit on an entry. */
6841 value = RT_IDX_DST_DFLT_Q | /* dest */
6842 RT_IDX_TYPE_NICQ | /* type */
6843 (index << RT_IDX_IDX_SHIFT); /* index */
6844 break;
6845
6846 default:
6847 cmn_err(CE_WARN, "Mask type %d not yet supported.",
6848 mask);
6849 status = -EPERM;
6850 goto exit;
6851 }
6852
6853 if (value != 0) {
6854 status = ql_wait_reg_rdy(qlge, REG_ROUTING_INDEX, RT_IDX_MW, 0);
6855 if (status)
6856 goto exit;
6857 value |= (enable ? RT_IDX_E : 0);
6858 ql_write_reg(qlge, REG_ROUTING_INDEX, value);
6859 ql_write_reg(qlge, REG_ROUTING_DATA, enable ? mask : 0);
6860 }
6861
6862 exit:
6863 return (status);
6864 }
6865
6866 /*
6867 * Clear all the entries in the routing table.
6868 * Caller must get semaphore in advance.
6869 */
6870
6871 static int
6872 ql_stop_routing(qlge_t *qlge)
6873 {
6874 int status = 0;
6875 int i;
6876 /* Clear all the entries in the routing table. */
6877 for (i = 0; i < 16; i++) {
6878 status = ql_set_routing_reg(qlge, i, 0, 0);
6879 if (status) {
6880 cmn_err(CE_WARN, "Stop routing failed. ");
6881 }
6882 }
6883 return (status);
6884 }
6885
6886 /* Initialize the frame-to-queue routing. */
6887 int
6888 ql_route_initialize(qlge_t *qlge)
6889 {
6890 int status = 0;
6891
6892 status = ql_sem_spinlock(qlge, SEM_RT_IDX_MASK);
6893 if (status != DDI_SUCCESS)
6894 return (status);
6895
6896 /* Clear all the entries in the routing table. */
6897 status = ql_stop_routing(qlge);
6898 if (status) {
6899 goto exit;
6900 }
6901 status = ql_set_routing_reg(qlge, RT_IDX_BCAST_SLOT, RT_IDX_BCAST, 1);
6902 if (status) {
6903 cmn_err(CE_WARN,
6904 "Failed to init routing register for broadcast packets.");
6905 goto exit;
6906 }
6907 /*
6908 * If we have more than one inbound queue, then turn on RSS in the
6909 * routing block.
6910 */
6911 if (qlge->rss_ring_count > 1) {
6912 status = ql_set_routing_reg(qlge, RT_IDX_RSS_MATCH_SLOT,
6913 RT_IDX_RSS_MATCH, 1);
6914 if (status) {
6915 cmn_err(CE_WARN,
6916 "Failed to init routing register for MATCH RSS "
6917 "packets.");
6918 goto exit;
6919 }
6920 }
6921
6922 status = ql_set_routing_reg(qlge, RT_IDX_CAM_HIT_SLOT,
6923 RT_IDX_CAM_HIT, 1);
6924 if (status) {
6925 cmn_err(CE_WARN,
6926 "Failed to init routing register for CAM packets.");
6927 goto exit;
6928 }
6929
6930 status = ql_set_routing_reg(qlge, RT_IDX_MCAST_MATCH_SLOT,
6931 RT_IDX_MCAST_MATCH, 1);
6932 if (status) {
6933 cmn_err(CE_WARN,
6934 "Failed to init routing register for Multicast "
6935 "packets.");
6936 }
6937
6938 exit:
6939 ql_sem_unlock(qlge, SEM_RT_IDX_MASK);
6940 return (status);
6941 }
6942
6943 /*
6944 * Initialize hardware
6945 */
6946 static int
6947 ql_device_initialize(qlge_t *qlge)
6948 {
6949 uint32_t value, mask;
6950 int i;
6951 int status = 0;
6952 uint16_t pause = PAUSE_MODE_DISABLED;
6953 boolean_t update_port_config = B_FALSE;
6954 uint32_t pause_bit_mask;
6955 boolean_t dcbx_enable = B_FALSE;
6956 uint32_t dcbx_bit_mask = 0x10;
6957 /*
6958 * Set up the System register to halt on errors.
6959 */
6960 value = SYS_EFE | SYS_FAE;
6961 mask = value << 16;
6962 ql_write_reg(qlge, REG_SYSTEM, mask | value);
6963
6964 /* Set the default queue. */
6965 value = NIC_RCV_CFG_DFQ;
6966 mask = NIC_RCV_CFG_DFQ_MASK;
6967
6968 ql_write_reg(qlge, REG_NIC_RECEIVE_CONFIGURATION, mask | value);
6969
6970 /* Enable the MPI interrupt. */
6971 ql_write_reg(qlge, REG_INTERRUPT_MASK, (INTR_MASK_PI << 16)
6972 | INTR_MASK_PI);
6973 /* Enable the function, set pagesize, enable error checking. */
6974 value = FSC_FE | FSC_EPC_INBOUND | FSC_EPC_OUTBOUND |
6975 FSC_EC | FSC_VM_PAGE_4K | FSC_DBRST_1024;
6976 /* Set/clear header splitting. */
6977 if (CFG_IST(qlge, CFG_ENABLE_SPLIT_HEADER)) {
6978 value |= FSC_SH;
6979 ql_write_reg(qlge, REG_SPLIT_HEADER, SMALL_BUFFER_SIZE);
6980 }
6981 mask = FSC_VM_PAGESIZE_MASK |
6982 FSC_DBL_MASK | FSC_DBRST_MASK | (value << 16);
6983 ql_write_reg(qlge, REG_FUNCTION_SPECIFIC_CONTROL, mask | value);
6984 /*
6985 * check current port max frame size, if different from OS setting,
6986 * then we need to change
6987 */
6988 qlge->max_frame_size =
6989 (qlge->mtu == ETHERMTU)? NORMAL_FRAME_SIZE : JUMBO_FRAME_SIZE;
6990
6991 mutex_enter(&qlge->mbx_mutex);
6992 status = ql_get_port_cfg(qlge);
6993 mutex_exit(&qlge->mbx_mutex);
6994
6995 if (status == DDI_SUCCESS) {
6996 /* if current frame size is smaller than required size */
6997 if (qlge->port_cfg_info.max_frame_size <
6998 qlge->max_frame_size) {
6999 QL_PRINT(DBG_MBX,
7000 ("update frame size, current %d, new %d\n",
7001 qlge->port_cfg_info.max_frame_size,
7002 qlge->max_frame_size));
7003 qlge->port_cfg_info.max_frame_size =
7004 qlge->max_frame_size;
7005 qlge->port_cfg_info.link_cfg |= ENABLE_JUMBO;
7006 update_port_config = B_TRUE;
7007 }
7008
7009 if (qlge->port_cfg_info.link_cfg & STD_PAUSE)
7010 pause = PAUSE_MODE_STANDARD;
7011 else if (qlge->port_cfg_info.link_cfg & PP_PAUSE)
7012 pause = PAUSE_MODE_PER_PRIORITY;
7013
7014 if (pause != qlge->pause) {
7015 pause_bit_mask = 0x60; /* bit 5-6 */
7016 /* clear pause bits */
7017 qlge->port_cfg_info.link_cfg &= ~pause_bit_mask;
7018 if (qlge->pause == PAUSE_MODE_STANDARD)
7019 qlge->port_cfg_info.link_cfg |= STD_PAUSE;
7020 else if (qlge->pause == PAUSE_MODE_PER_PRIORITY)
7021 qlge->port_cfg_info.link_cfg |= PP_PAUSE;
7022 update_port_config = B_TRUE;
7023 }
7024
7025 if (qlge->port_cfg_info.link_cfg & DCBX_ENABLE)
7026 dcbx_enable = B_TRUE;
7027 if (dcbx_enable != qlge->dcbx_enable) {
7028 qlge->port_cfg_info.link_cfg &= ~dcbx_bit_mask;
7029 if (qlge->dcbx_enable)
7030 qlge->port_cfg_info.link_cfg |= DCBX_ENABLE;
7031 }
7032
7033 update_port_config = B_TRUE;
7034
7035 /* if need to update port configuration */
7036 if (update_port_config) {
7037 mutex_enter(&qlge->mbx_mutex);
7038 (void) ql_set_mpi_port_config(qlge,
7039 qlge->port_cfg_info);
7040 mutex_exit(&qlge->mbx_mutex);
7041 }
7042 } else
7043 cmn_err(CE_WARN, "ql_get_port_cfg failed");
7044
7045 /* Start up the rx queues. */
7046 for (i = 0; i < qlge->rx_ring_count; i++) {
7047 status = ql_start_rx_ring(qlge, &qlge->rx_ring[i]);
7048 if (status) {
7049 cmn_err(CE_WARN,
7050 "Failed to start rx ring[%d]", i);
7051 return (status);
7052 }
7053 }
7054
7055 /*
7056 * If there is more than one inbound completion queue
7057 * then download a RICB to configure RSS.
7058 */
7059 if (qlge->rss_ring_count > 1) {
7060 status = ql_start_rss(qlge);
7061 if (status) {
7062 cmn_err(CE_WARN, "Failed to start RSS.");
7063 return (status);
7064 }
7065 }
7066
7067 /* Start up the tx queues. */
7068 for (i = 0; i < qlge->tx_ring_count; i++) {
7069 status = ql_start_tx_ring(qlge, &qlge->tx_ring[i]);
7070 if (status) {
7071 cmn_err(CE_WARN,
7072 "Failed to start tx ring[%d]", i);
7073 return (status);
7074 }
7075 }
7076 qlge->selected_tx_ring = 0;
7077 /* Set the frame routing filter. */
7078 status = ql_route_initialize(qlge);
7079 if (status) {
7080 cmn_err(CE_WARN,
7081 "Failed to init CAM/Routing tables.");
7082 return (status);
7083 }
7084
7085 return (status);
7086 }
7087 /*
7088 * Issue soft reset to chip.
7089 */
7090 static int
7091 ql_asic_reset(qlge_t *qlge)
7092 {
7093 int status = DDI_SUCCESS;
7094
7095 ql_write_reg(qlge, REG_RESET_FAILOVER, FUNCTION_RESET_MASK
7096 |FUNCTION_RESET);
7097
7098 if (ql_wait_reg_bit(qlge, REG_RESET_FAILOVER, FUNCTION_RESET,
7099 BIT_RESET, 0) != DDI_SUCCESS) {
7100 cmn_err(CE_WARN,
7101 "TIMEOUT!!! errored out of resetting the chip!");
7102 status = DDI_FAILURE;
7103 }
7104
7105 return (status);
7106 }
7107
7108 /*
7109 * If there are more than MIN_BUFFERS_ARM_COUNT small buffer descriptors in
7110 * its free list, move xMIN_BUFFERS_ARM_COUNT descriptors to its in use list
7111 * to be used by hardware.
7112 */
7113 static void
7114 ql_arm_sbuf(qlge_t *qlge, struct rx_ring *rx_ring)
7115 {
7116 struct bq_desc *sbq_desc;
7117 int i;
7118 uint64_t *sbq_entry = rx_ring->sbq_dma.vaddr;
7119 uint32_t arm_count;
7120
7121 if (rx_ring->sbuf_free_count > rx_ring->sbq_len-MIN_BUFFERS_ARM_COUNT)
7122 arm_count = (rx_ring->sbq_len-MIN_BUFFERS_ARM_COUNT);
7123 else {
7124 /* Adjust to a multiple of 16 */
7125 arm_count = (rx_ring->sbuf_free_count / 16) * 16;
7126 #ifdef QLGE_LOAD_UNLOAD
7127 cmn_err(CE_NOTE, "adjust sbuf arm_count %d\n", arm_count);
7128 #endif
7129 }
7130 for (i = 0; i < arm_count; i++) {
7131 sbq_desc = ql_get_sbuf_from_free_list(rx_ring);
7132 if (sbq_desc == NULL)
7133 break;
7134 /* Arm asic */
7135 *sbq_entry = cpu_to_le64(sbq_desc->bd_dma.dma_addr);
7136 sbq_entry++;
7137
7138 /* link the descriptors to in_use_list */
7139 ql_add_sbuf_to_in_use_list(rx_ring, sbq_desc);
7140 rx_ring->sbq_prod_idx++;
7141 }
7142 ql_update_sbq_prod_idx(qlge, rx_ring);
7143 }
7144
7145 /*
7146 * If there are more than MIN_BUFFERS_ARM_COUNT large buffer descriptors in
7147 * its free list, move xMIN_BUFFERS_ARM_COUNT descriptors to its in use list
7148 * to be used by hardware.
7149 */
7150 static void
7151 ql_arm_lbuf(qlge_t *qlge, struct rx_ring *rx_ring)
7152 {
7153 struct bq_desc *lbq_desc;
7154 int i;
7155 uint64_t *lbq_entry = rx_ring->lbq_dma.vaddr;
7156 uint32_t arm_count;
7157
7158 if (rx_ring->lbuf_free_count > rx_ring->lbq_len-MIN_BUFFERS_ARM_COUNT)
7159 arm_count = (rx_ring->lbq_len-MIN_BUFFERS_ARM_COUNT);
7160 else {
7161 /* Adjust to a multiple of 16 */
7162 arm_count = (rx_ring->lbuf_free_count / 16) * 16;
7163 #ifdef QLGE_LOAD_UNLOAD
7164 cmn_err(CE_NOTE, "adjust lbuf arm_count %d\n", arm_count);
7165 #endif
7166 }
7167 for (i = 0; i < arm_count; i++) {
7168 lbq_desc = ql_get_lbuf_from_free_list(rx_ring);
7169 if (lbq_desc == NULL)
7170 break;
7171 /* Arm asic */
7172 *lbq_entry = cpu_to_le64(lbq_desc->bd_dma.dma_addr);
7173 lbq_entry++;
7174
7175 /* link the descriptors to in_use_list */
7176 ql_add_lbuf_to_in_use_list(rx_ring, lbq_desc);
7177 rx_ring->lbq_prod_idx++;
7178 }
7179 ql_update_lbq_prod_idx(qlge, rx_ring);
7180 }
7181
7182
7183 /*
7184 * Initializes the adapter by configuring request and response queues,
7185 * allocates and ARMs small and large receive buffers to the
7186 * hardware
7187 */
7188 static int
7189 ql_bringup_adapter(qlge_t *qlge)
7190 {
7191 int i;
7192
7193 if (ql_device_initialize(qlge) != DDI_SUCCESS) {
7194 cmn_err(CE_WARN, "?%s(%d): ql_device_initialize failed",
7195 __func__, qlge->instance);
7196 goto err_bringup;
7197 }
7198 qlge->sequence |= INIT_ADAPTER_UP;
7199
7200 #ifdef QLGE_TRACK_BUFFER_USAGE
7201 for (i = 0; i < qlge->rx_ring_count; i++) {
7202 if (qlge->rx_ring[i].type != TX_Q) {
7203 qlge->rx_sb_low_count[i] = NUM_SMALL_BUFFERS;
7204 qlge->rx_lb_low_count[i] = NUM_LARGE_BUFFERS;
7205 }
7206 qlge->cq_low_count[i] = NUM_RX_RING_ENTRIES;
7207 }
7208 #endif
7209 /* Arm buffers */
7210 for (i = 0; i < qlge->rx_ring_count; i++) {
7211 if (qlge->rx_ring[i].type != TX_Q) {
7212 ql_arm_sbuf(qlge, &qlge->rx_ring[i]);
7213 ql_arm_lbuf(qlge, &qlge->rx_ring[i]);
7214 }
7215 }
7216
7217 /* Enable work/request queues */
7218 for (i = 0; i < qlge->tx_ring_count; i++) {
7219 if (qlge->tx_ring[i].valid_db_reg)
7220 ql_write_doorbell_reg(qlge,
7221 qlge->tx_ring[i].valid_db_reg,
7222 REQ_Q_VALID);
7223 }
7224
7225 /* Enable completion queues */
7226 for (i = 0; i < qlge->rx_ring_count; i++) {
7227 if (qlge->rx_ring[i].valid_db_reg)
7228 ql_write_doorbell_reg(qlge,
7229 qlge->rx_ring[i].valid_db_reg,
7230 RSP_Q_VALID);
7231 }
7232
7233 for (i = 0; i < qlge->tx_ring_count; i++) {
7234 mutex_enter(&qlge->tx_ring[i].tx_lock);
7235 qlge->tx_ring[i].mac_flags = QL_MAC_STARTED;
7236 mutex_exit(&qlge->tx_ring[i].tx_lock);
7237 }
7238
7239 for (i = 0; i < qlge->rx_ring_count; i++) {
7240 mutex_enter(&qlge->rx_ring[i].rx_lock);
7241 qlge->rx_ring[i].mac_flags = QL_MAC_STARTED;
7242 mutex_exit(&qlge->rx_ring[i].rx_lock);
7243 }
7244
7245 /* This mutex will get re-acquired in enable_completion interrupt */
7246 mutex_exit(&qlge->hw_mutex);
7247 /* Traffic can start flowing now */
7248 ql_enable_all_completion_interrupts(qlge);
7249 mutex_enter(&qlge->hw_mutex);
7250
7251 ql_enable_global_interrupt(qlge);
7252
7253 qlge->sequence |= ADAPTER_INIT;
7254 return (DDI_SUCCESS);
7255
7256 err_bringup:
7257 (void) ql_asic_reset(qlge);
7258 return (DDI_FAILURE);
7259 }
7260
7261 /*
7262 * Initialize mutexes of each rx/tx rings
7263 */
7264 static int
7265 ql_init_rx_tx_locks(qlge_t *qlge)
7266 {
7267 struct tx_ring *tx_ring;
7268 struct rx_ring *rx_ring;
7269 int i;
7270
7271 for (i = 0; i < qlge->tx_ring_count; i++) {
7272 tx_ring = &qlge->tx_ring[i];
7273 mutex_init(&tx_ring->tx_lock, NULL, MUTEX_DRIVER,
7274 DDI_INTR_PRI(qlge->intr_pri));
7275 }
7276
7277 for (i = 0; i < qlge->rx_ring_count; i++) {
7278 rx_ring = &qlge->rx_ring[i];
7279 mutex_init(&rx_ring->rx_lock, NULL, MUTEX_DRIVER,
7280 DDI_INTR_PRI(qlge->intr_pri));
7281 mutex_init(&rx_ring->sbq_lock, NULL, MUTEX_DRIVER,
7282 DDI_INTR_PRI(qlge->intr_pri));
7283 mutex_init(&rx_ring->lbq_lock, NULL, MUTEX_DRIVER,
7284 DDI_INTR_PRI(qlge->intr_pri));
7285 }
7286
7287 return (DDI_SUCCESS);
7288 }
7289
7290 /*ARGSUSED*/
7291 /*
7292 * Simply call pci_ereport_post which generates ereports for errors
7293 * that occur in the PCI local bus configuration status registers.
7294 */
7295 static int
7296 ql_fm_error_cb(dev_info_t *dip, ddi_fm_error_t *err, const void *impl_data)
7297 {
7298 pci_ereport_post(dip, err, NULL);
7299 return (err->fme_status);
7300 }
7301
7302 static void
7303 ql_fm_init(qlge_t *qlge)
7304 {
7305 ddi_iblock_cookie_t iblk;
7306
7307 QL_PRINT(DBG_INIT, ("ql_fm_init(%d) entered, FMA capability %x\n",
7308 qlge->instance, qlge->fm_capabilities));
7309 /*
7310 * Register capabilities with IO Fault Services. The capabilities
7311 * set above may not be supported by the parent nexus, in that case
7312 * some capability bits may be cleared.
7313 */
7314 if (qlge->fm_capabilities)
7315 ddi_fm_init(qlge->dip, &qlge->fm_capabilities, &iblk);
7316
7317 /*
7318 * Initialize pci ereport capabilities if ereport capable
7319 */
7320 if (DDI_FM_EREPORT_CAP(qlge->fm_capabilities) ||
7321 DDI_FM_ERRCB_CAP(qlge->fm_capabilities)) {
7322 pci_ereport_setup(qlge->dip);
7323 }
7324
7325 /* Register error callback if error callback capable */
7326 if (DDI_FM_ERRCB_CAP(qlge->fm_capabilities)) {
7327 ddi_fm_handler_register(qlge->dip,
7328 ql_fm_error_cb, (void*) qlge);
7329 }
7330
7331 /*
7332 * DDI_FLGERR_ACC indicates:
7333 * Driver will check its access handle(s) for faults on
7334 * a regular basis by calling ddi_fm_acc_err_get
7335 * Driver is able to cope with incorrect results of I/O
7336 * operations resulted from an I/O fault
7337 */
7338 if (DDI_FM_ACC_ERR_CAP(qlge->fm_capabilities)) {
7339 ql_dev_acc_attr.devacc_attr_access = DDI_FLAGERR_ACC;
7340 }
7341
7342 /*
7343 * DDI_DMA_FLAGERR indicates:
7344 * Driver will check its DMA handle(s) for faults on a
7345 * regular basis using ddi_fm_dma_err_get
7346 * Driver is able to cope with incorrect results of DMA
7347 * operations resulted from an I/O fault
7348 */
7349 if (DDI_FM_DMA_ERR_CAP(qlge->fm_capabilities)) {
7350 tx_mapping_dma_attr.dma_attr_flags = DDI_DMA_FLAGERR;
7351 dma_attr.dma_attr_flags = DDI_DMA_FLAGERR;
7352 }
7353 QL_PRINT(DBG_INIT, ("ql_fm_init(%d) done\n",
7354 qlge->instance));
7355 }
7356
7357 static void
7358 ql_fm_fini(qlge_t *qlge)
7359 {
7360 QL_PRINT(DBG_INIT, ("ql_fm_fini(%d) entered\n",
7361 qlge->instance));
7362 /* Only unregister FMA capabilities if we registered some */
7363 if (qlge->fm_capabilities) {
7364
7365 /*
7366 * Release any resources allocated by pci_ereport_setup()
7367 */
7368 if (DDI_FM_EREPORT_CAP(qlge->fm_capabilities) ||
7369 DDI_FM_ERRCB_CAP(qlge->fm_capabilities))
7370 pci_ereport_teardown(qlge->dip);
7371
7372 /*
7373 * Un-register error callback if error callback capable
7374 */
7375 if (DDI_FM_ERRCB_CAP(qlge->fm_capabilities))
7376 ddi_fm_handler_unregister(qlge->dip);
7377
7378 /* Unregister from IO Fault Services */
7379 ddi_fm_fini(qlge->dip);
7380 }
7381 QL_PRINT(DBG_INIT, ("ql_fm_fini(%d) done\n",
7382 qlge->instance));
7383 }
7384 /*
7385 * ql_attach - Driver attach.
7386 */
7387 static int
7388 ql_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
7389 {
7390 int instance;
7391 qlge_t *qlge = NULL;
7392 int rval;
7393 uint16_t w;
7394 mac_register_t *macp = NULL;
7395 uint32_t data;
7396
7397 rval = DDI_FAILURE;
7398
7399 /* first get the instance */
7400 instance = ddi_get_instance(dip);
7401
7402 switch (cmd) {
7403 case DDI_ATTACH:
7404 /*
7405 * Allocate our per-device-instance structure
7406 */
7407 qlge = (qlge_t *)kmem_zalloc(sizeof (*qlge), KM_SLEEP);
7408 ASSERT(qlge != NULL);
7409 qlge->sequence |= INIT_SOFTSTATE_ALLOC;
7410
7411 qlge->dip = dip;
7412 qlge->instance = instance;
7413 /* Set up the coalescing parameters. */
7414 qlge->ql_dbgprnt = 0;
7415 #if QL_DEBUG
7416 qlge->ql_dbgprnt = QL_DEBUG;
7417 #endif /* QL_DEBUG */
7418
7419 /*
7420 * Initialize for fma support
7421 */
7422 /* fault management (fm) capabilities. */
7423 qlge->fm_capabilities =
7424 DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE;
7425 data = ql_get_prop(qlge, "fm-capable");
7426 if (data <= 0xf) {
7427 qlge->fm_capabilities = data;
7428 }
7429 ql_fm_init(qlge);
7430 qlge->sequence |= INIT_FM;
7431 QL_PRINT(DBG_INIT, ("ql_attach(%d): fma init done\n",
7432 qlge->instance));
7433
7434 /*
7435 * Setup the ISP8x00 registers address mapping to be
7436 * accessed by this particular driver.
7437 * 0x0 Configuration Space
7438 * 0x1 I/O Space
7439 * 0x2 1st Memory Space address - Control Register Set
7440 * 0x3 2nd Memory Space address - Doorbell Memory Space
7441 */
7442 w = 2;
7443 if (ddi_regs_map_setup(dip, w, (caddr_t *)&qlge->iobase, 0,
7444 sizeof (dev_reg_t), &ql_dev_acc_attr,
7445 &qlge->dev_handle) != DDI_SUCCESS) {
7446 cmn_err(CE_WARN, "%s(%d): Unable to map device "
7447 "registers", ADAPTER_NAME, instance);
7448 break;
7449 }
7450 QL_PRINT(DBG_GLD, ("ql_attach: I/O base = 0x%x\n",
7451 qlge->iobase));
7452 qlge->sequence |= INIT_REGS_SETUP;
7453
7454 /* map Doorbell memory space */
7455 w = 3;
7456 if (ddi_regs_map_setup(dip, w,
7457 (caddr_t *)&qlge->doorbell_reg_iobase, 0,
7458 0x100000 /* sizeof (dev_doorbell_reg_t) */,
7459 &ql_dev_acc_attr,
7460 &qlge->dev_doorbell_reg_handle) != DDI_SUCCESS) {
7461 cmn_err(CE_WARN, "%s(%d): Unable to map Doorbell "
7462 "registers",
7463 ADAPTER_NAME, instance);
7464 break;
7465 }
7466 QL_PRINT(DBG_GLD, ("ql_attach: Doorbell I/O base = 0x%x\n",
7467 qlge->doorbell_reg_iobase));
7468 qlge->sequence |= INIT_DOORBELL_REGS_SETUP;
7469
7470 /*
7471 * Allocate a macinfo structure for this instance
7472 */
7473 if ((macp = mac_alloc(MAC_VERSION)) == NULL) {
7474 cmn_err(CE_WARN, "%s(%d): mac_alloc failed",
7475 __func__, instance);
7476 break;
7477 }
7478 /* save adapter status to dip private data */
7479 ddi_set_driver_private(dip, qlge);
7480 QL_PRINT(DBG_INIT, ("%s(%d): Allocate macinfo structure done\n",
7481 ADAPTER_NAME, instance));
7482 qlge->sequence |= INIT_MAC_ALLOC;
7483
7484 /*
7485 * Attach this instance of the device
7486 */
7487 /* Setup PCI Local Bus Configuration resource. */
7488 if (pci_config_setup(dip, &qlge->pci_handle) != DDI_SUCCESS) {
7489 cmn_err(CE_WARN, "%s(%d):Unable to get PCI resources",
7490 ADAPTER_NAME, instance);
7491 if (qlge->fm_enable) {
7492 ql_fm_ereport(qlge, DDI_FM_DEVICE_INVAL_STATE);
7493 ddi_fm_service_impact(qlge->dip,
7494 DDI_SERVICE_LOST);
7495 }
7496 break;
7497 }
7498 qlge->sequence |= INIT_PCI_CONFIG_SETUP;
7499 QL_PRINT(DBG_GLD, ("ql_attach(%d): pci_config_setup done\n",
7500 instance));
7501
7502 if (ql_init_instance(qlge) != DDI_SUCCESS) {
7503 cmn_err(CE_WARN, "%s(%d): Unable to initialize device "
7504 "instance", ADAPTER_NAME, instance);
7505 if (qlge->fm_enable) {
7506 ql_fm_ereport(qlge, DDI_FM_DEVICE_INVAL_STATE);
7507 ddi_fm_service_impact(qlge->dip,
7508 DDI_SERVICE_LOST);
7509 }
7510 break;
7511 }
7512 QL_PRINT(DBG_GLD, ("ql_attach(%d): ql_init_instance done\n",
7513 instance));
7514
7515 /* Setup interrupt vectors */
7516 if (ql_alloc_irqs(qlge) != DDI_SUCCESS) {
7517 break;
7518 }
7519 qlge->sequence |= INIT_INTR_ALLOC;
7520 QL_PRINT(DBG_GLD, ("ql_attach(%d): ql_alloc_irqs done\n",
7521 instance));
7522
7523 /* Configure queues */
7524 if (ql_setup_rings(qlge) != DDI_SUCCESS) {
7525 break;
7526 }
7527 qlge->sequence |= INIT_SETUP_RINGS;
7528 QL_PRINT(DBG_GLD, ("ql_attach(%d): setup rings done\n",
7529 instance));
7530
7531 /*
7532 * Allocate memory resources
7533 */
7534 if (ql_alloc_mem_resources(qlge) != DDI_SUCCESS) {
7535 cmn_err(CE_WARN, "%s(%d): memory allocation failed",
7536 __func__, qlge->instance);
7537 break;
7538 }
7539 qlge->sequence |= INIT_MEMORY_ALLOC;
7540 QL_PRINT(DBG_GLD, ("ql_alloc_mem_resources(%d) done\n",
7541 instance));
7542
7543 /*
7544 * Map queues to interrupt vectors
7545 */
7546 ql_resolve_queues_to_irqs(qlge);
7547
7548 /* Initialize mutex, need the interrupt priority */
7549 (void) ql_init_rx_tx_locks(qlge);
7550 qlge->sequence |= INIT_LOCKS_CREATED;
7551 QL_PRINT(DBG_INIT, ("%s(%d): ql_init_rx_tx_locks done\n",
7552 ADAPTER_NAME, instance));
7553
7554 /*
7555 * Use a soft interrupt to do something that we do not want
7556 * to do in regular network functions or with mutexs being held
7557 */
7558 if (ddi_intr_add_softint(qlge->dip, &qlge->mpi_event_intr_hdl,
7559 DDI_INTR_SOFTPRI_MIN, ql_mpi_event_work, (caddr_t)qlge)
7560 != DDI_SUCCESS) {
7561 break;
7562 }
7563
7564 if (ddi_intr_add_softint(qlge->dip, &qlge->asic_reset_intr_hdl,
7565 DDI_INTR_SOFTPRI_MIN, ql_asic_reset_work, (caddr_t)qlge)
7566 != DDI_SUCCESS) {
7567 break;
7568 }
7569
7570 if (ddi_intr_add_softint(qlge->dip, &qlge->mpi_reset_intr_hdl,
7571 DDI_INTR_SOFTPRI_MIN, ql_mpi_reset_work, (caddr_t)qlge)
7572 != DDI_SUCCESS) {
7573 break;
7574 }
7575 qlge->sequence |= INIT_ADD_SOFT_INTERRUPT;
7576 QL_PRINT(DBG_INIT, ("%s(%d): ddi_intr_add_softint done\n",
7577 ADAPTER_NAME, instance));
7578
7579 /*
7580 * mutex to protect the adapter state structure.
7581 * initialize mutexes according to the interrupt priority
7582 */
7583 mutex_init(&qlge->gen_mutex, NULL, MUTEX_DRIVER,
7584 DDI_INTR_PRI(qlge->intr_pri));
7585 mutex_init(&qlge->hw_mutex, NULL, MUTEX_DRIVER,
7586 DDI_INTR_PRI(qlge->intr_pri));
7587 mutex_init(&qlge->mbx_mutex, NULL, MUTEX_DRIVER,
7588 DDI_INTR_PRI(qlge->intr_pri));
7589
7590 /* Mailbox wait and interrupt conditional variable. */
7591 cv_init(&qlge->cv_mbx_intr, NULL, CV_DRIVER, NULL);
7592 qlge->sequence |= INIT_MUTEX;
7593 QL_PRINT(DBG_INIT, ("%s(%d): mutex_init done\n",
7594 ADAPTER_NAME, instance));
7595
7596 /*
7597 * KStats
7598 */
7599 if (ql_init_kstats(qlge) != DDI_SUCCESS) {
7600 cmn_err(CE_WARN, "%s(%d): KState initialization failed",
7601 ADAPTER_NAME, instance);
7602 break;
7603 }
7604 qlge->sequence |= INIT_KSTATS;
7605 QL_PRINT(DBG_INIT, ("%s(%d): ql_init_kstats done\n",
7606 ADAPTER_NAME, instance));
7607
7608 /*
7609 * Initialize gld macinfo structure
7610 */
7611 ql_gld3_init(qlge, macp);
7612 /*
7613 * Add interrupt handlers
7614 */
7615 if (ql_add_intr_handlers(qlge) != DDI_SUCCESS) {
7616 cmn_err(CE_WARN, "Failed to add interrupt "
7617 "handlers");
7618 break;
7619 }
7620 qlge->sequence |= INIT_ADD_INTERRUPT;
7621 QL_PRINT(DBG_INIT, ("%s(%d): Add interrupt handler done\n",
7622 ADAPTER_NAME, instance));
7623
7624 /*
7625 * MAC Register
7626 */
7627 if (mac_register(macp, &qlge->mh) != DDI_SUCCESS) {
7628 cmn_err(CE_WARN, "%s(%d): mac_register failed",
7629 __func__, instance);
7630 break;
7631 }
7632 qlge->sequence |= INIT_MAC_REGISTERED;
7633 QL_PRINT(DBG_GLD, ("%s(%d): mac_register done\n",
7634 ADAPTER_NAME, instance));
7635
7636 mac_free(macp);
7637 macp = NULL;
7638
7639 qlge->mac_flags = QL_MAC_ATTACHED;
7640
7641 ddi_report_dev(dip);
7642
7643 rval = DDI_SUCCESS;
7644
7645 break;
7646 /*
7647 * DDI_RESUME
7648 * When called with cmd set to DDI_RESUME, attach() must
7649 * restore the hardware state of a device (power may have been
7650 * removed from the device), allow pending requests to con-
7651 * tinue, and service new requests. In this case, the driver
7652 * must not make any assumptions about the state of the
7653 * hardware, but must restore the state of the device except
7654 * for the power level of components.
7655 *
7656 */
7657 case DDI_RESUME:
7658
7659 if ((qlge = (qlge_t *)QL_GET_DEV(dip)) == NULL)
7660 return (DDI_FAILURE);
7661
7662 QL_PRINT(DBG_GLD, ("%s(%d)-DDI_RESUME\n",
7663 __func__, qlge->instance));
7664
7665 mutex_enter(&qlge->gen_mutex);
7666 rval = ql_do_start(qlge);
7667 mutex_exit(&qlge->gen_mutex);
7668 break;
7669
7670 default:
7671 break;
7672 }
7673
7674 /* if failed to attach */
7675 if ((cmd == DDI_ATTACH) && (rval != DDI_SUCCESS) && (qlge != NULL)) {
7676 cmn_err(CE_WARN, "qlge driver attach failed, sequence %x",
7677 qlge->sequence);
7678 ql_free_resources(qlge);
7679 }
7680
7681 return (rval);
7682 }
7683
7684 /*
7685 * Unbind all pending tx dma handles during driver bring down
7686 */
7687 static void
7688 ql_unbind_pending_tx_dma_handle(struct tx_ring *tx_ring)
7689 {
7690 struct tx_ring_desc *tx_ring_desc;
7691 int i, j;
7692
7693 if (tx_ring->wq_desc) {
7694 tx_ring_desc = tx_ring->wq_desc;
7695 for (i = 0; i < tx_ring->wq_len; i++, tx_ring_desc++) {
7696 for (j = 0; j < tx_ring_desc->tx_dma_handle_used; j++) {
7697 if (tx_ring_desc->tx_dma_handle[j]) {
7698 (void) ddi_dma_unbind_handle(
7699 tx_ring_desc->tx_dma_handle[j]);
7700 }
7701 }
7702 tx_ring_desc->tx_dma_handle_used = 0;
7703 } /* end of for loop */
7704 }
7705 }
7706 /*
7707 * Wait for all the packets sent to the chip to finish transmission
7708 * to prevent buffers to be unmapped before or during a transmit operation
7709 */
7710 static int
7711 ql_wait_tx_quiesce(qlge_t *qlge)
7712 {
7713 int count = MAX_TX_WAIT_COUNT, i;
7714 int rings_done;
7715 volatile struct tx_ring *tx_ring;
7716 uint32_t consumer_idx;
7717 uint32_t producer_idx;
7718 uint32_t temp;
7719 int done = 0;
7720 int rval = DDI_FAILURE;
7721
7722 while (!done) {
7723 rings_done = 0;
7724
7725 for (i = 0; i < qlge->tx_ring_count; i++) {
7726 tx_ring = &qlge->tx_ring[i];
7727 temp = ql_read_doorbell_reg(qlge,
7728 tx_ring->prod_idx_db_reg);
7729 producer_idx = temp & 0x0000ffff;
7730 consumer_idx = (temp >> 16);
7731
7732 if (qlge->isr_stride) {
7733 struct rx_ring *ob_ring;
7734 ob_ring = &qlge->rx_ring[tx_ring->cq_id];
7735 if (producer_idx != ob_ring->cnsmr_idx) {
7736 cmn_err(CE_NOTE, " force clean \n");
7737 (void) ql_clean_outbound_rx_ring(
7738 ob_ring);
7739 }
7740 }
7741 /*
7742 * Get the pending iocb count, ones which have not been
7743 * pulled down by the chip
7744 */
7745 if (producer_idx >= consumer_idx)
7746 temp = (producer_idx - consumer_idx);
7747 else
7748 temp = (tx_ring->wq_len - consumer_idx) +
7749 producer_idx;
7750
7751 if ((tx_ring->tx_free_count + temp) >= tx_ring->wq_len)
7752 rings_done++;
7753 else {
7754 done = 1;
7755 break;
7756 }
7757 }
7758
7759 /* If all the rings are done */
7760 if (rings_done >= qlge->tx_ring_count) {
7761 #ifdef QLGE_LOAD_UNLOAD
7762 cmn_err(CE_NOTE, "%s(%d) done successfully \n",
7763 __func__, qlge->instance);
7764 #endif
7765 rval = DDI_SUCCESS;
7766 break;
7767 }
7768
7769 qlge_delay(100);
7770
7771 count--;
7772 if (!count) {
7773
7774 count = MAX_TX_WAIT_COUNT;
7775 #ifdef QLGE_LOAD_UNLOAD
7776 volatile struct rx_ring *rx_ring;
7777 cmn_err(CE_NOTE, "%s(%d): Waiting for %d pending"
7778 " Transmits on queue %d to complete .\n",
7779 __func__, qlge->instance,
7780 (qlge->tx_ring[i].wq_len -
7781 qlge->tx_ring[i].tx_free_count),
7782 i);
7783
7784 rx_ring = &qlge->rx_ring[i+1];
7785 temp = ql_read_doorbell_reg(qlge,
7786 rx_ring->cnsmr_idx_db_reg);
7787 consumer_idx = temp & 0x0000ffff;
7788 producer_idx = (temp >> 16);
7789 cmn_err(CE_NOTE, "%s(%d): Transmit completion queue %d,"
7790 " Producer %d, Consumer %d\n",
7791 __func__, qlge->instance,
7792 i+1,
7793 producer_idx, consumer_idx);
7794
7795 temp = ql_read_doorbell_reg(qlge,
7796 tx_ring->prod_idx_db_reg);
7797 producer_idx = temp & 0x0000ffff;
7798 consumer_idx = (temp >> 16);
7799 cmn_err(CE_NOTE, "%s(%d): Transmit request queue %d,"
7800 " Producer %d, Consumer %d\n",
7801 __func__, qlge->instance, i,
7802 producer_idx, consumer_idx);
7803 #endif
7804
7805 /* For now move on */
7806 break;
7807 }
7808 }
7809 /* Stop the request queue */
7810 mutex_enter(&qlge->hw_mutex);
7811 for (i = 0; i < qlge->tx_ring_count; i++) {
7812 if (qlge->tx_ring[i].valid_db_reg) {
7813 ql_write_doorbell_reg(qlge,
7814 qlge->tx_ring[i].valid_db_reg, 0);
7815 }
7816 }
7817 mutex_exit(&qlge->hw_mutex);
7818 return (rval);
7819 }
7820
7821 /*
7822 * Wait for all the receives indicated to the stack to come back
7823 */
7824 static int
7825 ql_wait_rx_complete(qlge_t *qlge)
7826 {
7827 int i;
7828 /* Disable all the completion queues */
7829 mutex_enter(&qlge->hw_mutex);
7830 for (i = 0; i < qlge->rx_ring_count; i++) {
7831 if (qlge->rx_ring[i].valid_db_reg) {
7832 ql_write_doorbell_reg(qlge,
7833 qlge->rx_ring[i].valid_db_reg, 0);
7834 }
7835 }
7836 mutex_exit(&qlge->hw_mutex);
7837
7838 /* Wait for OS to return all rx buffers */
7839 qlge_delay(QL_ONE_SEC_DELAY);
7840 return (DDI_SUCCESS);
7841 }
7842
7843 /*
7844 * stop the driver
7845 */
7846 static int
7847 ql_bringdown_adapter(qlge_t *qlge)
7848 {
7849 int i;
7850 int status = DDI_SUCCESS;
7851
7852 qlge->mac_flags = QL_MAC_BRINGDOWN;
7853 if (qlge->sequence & ADAPTER_INIT) {
7854 /* stop forwarding external packets to driver */
7855 status = ql_sem_spinlock(qlge, SEM_RT_IDX_MASK);
7856 if (status)
7857 return (status);
7858 (void) ql_stop_routing(qlge);
7859 ql_sem_unlock(qlge, SEM_RT_IDX_MASK);
7860 /*
7861 * Set the flag for receive and transmit
7862 * operations to cease
7863 */
7864 for (i = 0; i < qlge->tx_ring_count; i++) {
7865 mutex_enter(&qlge->tx_ring[i].tx_lock);
7866 qlge->tx_ring[i].mac_flags = QL_MAC_STOPPED;
7867 mutex_exit(&qlge->tx_ring[i].tx_lock);
7868 }
7869
7870 for (i = 0; i < qlge->rx_ring_count; i++) {
7871 mutex_enter(&qlge->rx_ring[i].rx_lock);
7872 qlge->rx_ring[i].mac_flags = QL_MAC_STOPPED;
7873 mutex_exit(&qlge->rx_ring[i].rx_lock);
7874 }
7875
7876 /*
7877 * Need interrupts to be running while the transmit
7878 * completions are cleared. Wait for the packets
7879 * queued to the chip to be sent out
7880 */
7881 (void) ql_wait_tx_quiesce(qlge);
7882 /* Interrupts not needed from now */
7883 ql_disable_all_completion_interrupts(qlge);
7884
7885 mutex_enter(&qlge->hw_mutex);
7886 /* Disable Global interrupt */
7887 ql_disable_global_interrupt(qlge);
7888 mutex_exit(&qlge->hw_mutex);
7889
7890 /* Wait for all the indicated packets to come back */
7891 status = ql_wait_rx_complete(qlge);
7892
7893 mutex_enter(&qlge->hw_mutex);
7894 /* Reset adapter */
7895 (void) ql_asic_reset(qlge);
7896 /*
7897 * Unbind all tx dma handles to prevent pending tx descriptors'
7898 * dma handles from being re-used.
7899 */
7900 for (i = 0; i < qlge->tx_ring_count; i++) {
7901 ql_unbind_pending_tx_dma_handle(&qlge->tx_ring[i]);
7902 }
7903
7904 qlge->sequence &= ~ADAPTER_INIT;
7905
7906 mutex_exit(&qlge->hw_mutex);
7907 }
7908 return (status);
7909 }
7910
7911 /*
7912 * ql_detach
7913 * Used to remove all the states associated with a given
7914 * instances of a device node prior to the removal of that
7915 * instance from the system.
7916 */
7917 static int
7918 ql_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
7919 {
7920 qlge_t *qlge;
7921 int rval;
7922
7923 rval = DDI_SUCCESS;
7924
7925 switch (cmd) {
7926 case DDI_DETACH:
7927
7928 if ((qlge = QL_GET_DEV(dip)) == NULL)
7929 return (DDI_FAILURE);
7930 rval = ql_bringdown_adapter(qlge);
7931 if (rval != DDI_SUCCESS)
7932 break;
7933
7934 qlge->mac_flags = QL_MAC_DETACH;
7935
7936 /* free memory resources */
7937 if (qlge->sequence & INIT_MEMORY_ALLOC) {
7938 ql_free_mem_resources(qlge);
7939 qlge->sequence &= ~INIT_MEMORY_ALLOC;
7940 }
7941 ql_free_resources(qlge);
7942
7943 break;
7944
7945 case DDI_SUSPEND:
7946 if ((qlge = QL_GET_DEV(dip)) == NULL)
7947 return (DDI_FAILURE);
7948
7949 mutex_enter(&qlge->gen_mutex);
7950 if ((qlge->mac_flags == QL_MAC_ATTACHED) ||
7951 (qlge->mac_flags == QL_MAC_STARTED)) {
7952 (void) ql_do_stop(qlge);
7953 }
7954 qlge->mac_flags = QL_MAC_SUSPENDED;
7955 mutex_exit(&qlge->gen_mutex);
7956
7957 break;
7958 default:
7959 rval = DDI_FAILURE;
7960 break;
7961 }
7962
7963 return (rval);
7964 }
7965
7966 /*
7967 * quiesce(9E) entry point.
7968 *
7969 * This function is called when the system is single-threaded at high
7970 * PIL with preemption disabled. Therefore, this function must not be
7971 * blocked.
7972 *
7973 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
7974 */
7975 int
7976 ql_quiesce(dev_info_t *dip)
7977 {
7978 qlge_t *qlge;
7979 int i;
7980
7981 if ((qlge = QL_GET_DEV(dip)) == NULL)
7982 return (DDI_FAILURE);
7983
7984 if (CFG_IST(qlge, CFG_CHIP_8100)) {
7985 /* stop forwarding external packets to driver */
7986 (void) ql_sem_spinlock(qlge, SEM_RT_IDX_MASK);
7987 (void) ql_stop_routing(qlge);
7988 ql_sem_unlock(qlge, SEM_RT_IDX_MASK);
7989 /* Stop all the request queues */
7990 for (i = 0; i < qlge->tx_ring_count; i++) {
7991 if (qlge->tx_ring[i].valid_db_reg) {
7992 ql_write_doorbell_reg(qlge,
7993 qlge->tx_ring[i].valid_db_reg, 0);
7994 }
7995 }
7996 qlge_delay(QL_ONE_SEC_DELAY/4);
7997 /* Interrupts not needed from now */
7998 /* Disable MPI interrupt */
7999 ql_write_reg(qlge, REG_INTERRUPT_MASK,
8000 (INTR_MASK_PI << 16));
8001 ql_disable_global_interrupt(qlge);
8002
8003 /* Disable all the rx completion queues */
8004 for (i = 0; i < qlge->rx_ring_count; i++) {
8005 if (qlge->rx_ring[i].valid_db_reg) {
8006 ql_write_doorbell_reg(qlge,
8007 qlge->rx_ring[i].valid_db_reg, 0);
8008 }
8009 }
8010 qlge_delay(QL_ONE_SEC_DELAY/4);
8011 qlge->mac_flags = QL_MAC_STOPPED;
8012 /* Reset adapter */
8013 (void) ql_asic_reset(qlge);
8014 qlge_delay(100);
8015 }
8016
8017 return (DDI_SUCCESS);
8018 }
8019
8020 QL_STREAM_OPS(ql_ops, ql_attach, ql_detach);
8021
8022 /*
8023 * Loadable Driver Interface Structures.
8024 * Declare and initialize the module configuration section...
8025 */
8026 static struct modldrv modldrv = {
8027 &mod_driverops, /* type of module: driver */
8028 version, /* name of module */
8029 &ql_ops /* driver dev_ops */
8030 };
8031
8032 static struct modlinkage modlinkage = {
8033 MODREV_1, &modldrv, NULL
8034 };
8035
8036 /*
8037 * Loadable Module Routines
8038 */
8039
8040 /*
8041 * _init
8042 * Initializes a loadable module. It is called before any other
8043 * routine in a loadable module.
8044 */
8045 int
8046 _init(void)
8047 {
8048 int rval;
8049
8050 mac_init_ops(&ql_ops, ADAPTER_NAME);
8051 rval = mod_install(&modlinkage);
8052 if (rval != DDI_SUCCESS) {
8053 mac_fini_ops(&ql_ops);
8054 cmn_err(CE_WARN, "?Unable to install/attach driver '%s'",
8055 ADAPTER_NAME);
8056 }
8057
8058 return (rval);
8059 }
8060
8061 /*
8062 * _fini
8063 * Prepares a module for unloading. It is called when the system
8064 * wants to unload a module. If the module determines that it can
8065 * be unloaded, then _fini() returns the value returned by
8066 * mod_remove(). Upon successful return from _fini() no other
8067 * routine in the module will be called before _init() is called.
8068 */
8069 int
8070 _fini(void)
8071 {
8072 int rval;
8073
8074 rval = mod_remove(&modlinkage);
8075 if (rval == DDI_SUCCESS) {
8076 mac_fini_ops(&ql_ops);
8077 }
8078
8079 return (rval);
8080 }
8081
8082 /*
8083 * _info
8084 * Returns information about loadable module.
8085 */
8086 int
8087 _info(struct modinfo *modinfop)
8088 {
8089 return (mod_info(&modlinkage, modinfop));
8090 }