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 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright (c) 2002-2009 Neterion, Inc. 29 * All right Reserved. 30 * 31 * FileName : xgell.c 32 * 33 * Description: Xge Link Layer data path implementation 34 * 35 */ 36 37 #include "xgell.h" 38 39 #include <netinet/ip.h> 40 #include <netinet/tcp.h> 41 #include <netinet/udp.h> 42 43 #define XGELL_MAX_FRAME_SIZE(hldev) ((hldev)->config.mtu + \ 44 sizeof (struct ether_vlan_header)) 45 46 #define HEADROOM 2 /* for DIX-only packets */ 47 48 void header_free_func(void *arg) { } 49 frtn_t header_frtn = {header_free_func, NULL}; 50 51 /* DMA attributes used for Tx side */ 52 static struct ddi_dma_attr tx_dma_attr = { 53 DMA_ATTR_V0, /* dma_attr_version */ 54 0x0ULL, /* dma_attr_addr_lo */ 55 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_addr_hi */ 56 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_count_max */ 57 #if defined(__sparc) 58 0x2000, /* dma_attr_align */ 59 #else 60 0x1000, /* dma_attr_align */ 61 #endif 62 0xFC00FC, /* dma_attr_burstsizes */ 63 0x1, /* dma_attr_minxfer */ 64 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_maxxfer */ 65 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_seg */ 66 18, /* dma_attr_sgllen */ 67 (unsigned int)1, /* dma_attr_granular */ 68 0 /* dma_attr_flags */ 69 }; 70 71 /* 72 * DMA attributes used when using ddi_dma_mem_alloc to 73 * allocat HAL descriptors and Rx buffers during replenish 74 */ 75 static struct ddi_dma_attr hal_dma_attr = { 76 DMA_ATTR_V0, /* dma_attr_version */ 77 0x0ULL, /* dma_attr_addr_lo */ 78 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_addr_hi */ 79 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_count_max */ 80 #if defined(__sparc) 81 0x2000, /* dma_attr_align */ 82 #else 83 0x1000, /* dma_attr_align */ 84 #endif 85 0xFC00FC, /* dma_attr_burstsizes */ 86 0x1, /* dma_attr_minxfer */ 87 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_maxxfer */ 88 0xFFFFFFFFFFFFFFFFULL, /* dma_attr_seg */ 89 1, /* dma_attr_sgllen */ 90 (unsigned int)1, /* dma_attr_sgllen */ 91 DDI_DMA_RELAXED_ORDERING /* dma_attr_flags */ 92 }; 93 94 struct ddi_dma_attr *p_hal_dma_attr = &hal_dma_attr; 95 96 static int xgell_m_stat(void *, uint_t, uint64_t *); 97 static int xgell_m_start(void *); 98 static void xgell_m_stop(void *); 99 static int xgell_m_promisc(void *, boolean_t); 100 static int xgell_m_multicst(void *, boolean_t, const uint8_t *); 101 static void xgell_m_ioctl(void *, queue_t *, mblk_t *); 102 static boolean_t xgell_m_getcapab(void *, mac_capab_t, void *); 103 104 #define XGELL_M_CALLBACK_FLAGS (MC_IOCTL | MC_GETCAPAB) 105 106 static mac_callbacks_t xgell_m_callbacks = { 107 XGELL_M_CALLBACK_FLAGS, 108 xgell_m_stat, 109 xgell_m_start, 110 xgell_m_stop, 111 xgell_m_promisc, 112 xgell_m_multicst, 113 NULL, 114 NULL, 115 NULL, 116 xgell_m_ioctl, 117 xgell_m_getcapab 118 }; 119 120 /* 121 * xge_device_poll 122 * 123 * Timeout should call me every 1s. xge_callback_event_queued should call me 124 * when HAL hope event was rescheduled. 125 */ 126 /*ARGSUSED*/ 127 void 128 xge_device_poll(void *data) 129 { 130 xgelldev_t *lldev = xge_hal_device_private(data); 131 132 mutex_enter(&lldev->genlock); 133 if (lldev->is_initialized) { 134 xge_hal_device_poll(data); 135 lldev->timeout_id = timeout(xge_device_poll, data, 136 XGE_DEV_POLL_TICKS); 137 } else if (lldev->in_reset == 1) { 138 lldev->timeout_id = timeout(xge_device_poll, data, 139 XGE_DEV_POLL_TICKS); 140 } else { 141 lldev->timeout_id = 0; 142 } 143 mutex_exit(&lldev->genlock); 144 } 145 146 /* 147 * xge_device_poll_now 148 * 149 * Will call xge_device_poll() immediately 150 */ 151 void 152 xge_device_poll_now(void *data) 153 { 154 xgelldev_t *lldev = xge_hal_device_private(data); 155 156 mutex_enter(&lldev->genlock); 157 if (lldev->is_initialized) { 158 xge_hal_device_poll(data); 159 } 160 mutex_exit(&lldev->genlock); 161 } 162 163 /* 164 * xgell_callback_link_up 165 * 166 * This function called by HAL to notify HW link up state change. 167 */ 168 void 169 xgell_callback_link_up(void *userdata) 170 { 171 xgelldev_t *lldev = (xgelldev_t *)userdata; 172 173 mac_link_update(lldev->mh, LINK_STATE_UP); 174 } 175 176 /* 177 * xgell_callback_link_down 178 * 179 * This function called by HAL to notify HW link down state change. 180 */ 181 void 182 xgell_callback_link_down(void *userdata) 183 { 184 xgelldev_t *lldev = (xgelldev_t *)userdata; 185 186 mac_link_update(lldev->mh, LINK_STATE_DOWN); 187 } 188 189 /* 190 * xgell_rx_buffer_replenish_all 191 * 192 * To replenish all freed dtr(s) with buffers in free pool. It's called by 193 * xgell_rx_buffer_recycle() or xgell_rx_1b_callback(). 194 * Must be called with pool_lock held. 195 */ 196 static void 197 xgell_rx_buffer_replenish_all(xgell_rx_ring_t *ring) 198 { 199 xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool; 200 xge_hal_dtr_h dtr; 201 xgell_rx_buffer_t *rx_buffer; 202 xgell_rxd_priv_t *rxd_priv; 203 204 xge_assert(mutex_owned(&bf_pool->pool_lock)); 205 206 while ((bf_pool->free > 0) && 207 (xge_hal_ring_dtr_reserve(ring->channelh, &dtr) == XGE_HAL_OK)) { 208 xge_assert(bf_pool->head); 209 210 rx_buffer = bf_pool->head; 211 212 bf_pool->head = rx_buffer->next; 213 bf_pool->free--; 214 215 xge_assert(rx_buffer->dma_addr); 216 217 rxd_priv = (xgell_rxd_priv_t *) 218 xge_hal_ring_dtr_private(ring->channelh, dtr); 219 xge_hal_ring_dtr_1b_set(dtr, rx_buffer->dma_addr, 220 bf_pool->size); 221 222 rxd_priv->rx_buffer = rx_buffer; 223 xge_hal_ring_dtr_post(ring->channelh, dtr); 224 } 225 } 226 227 /* 228 * xgell_rx_buffer_release 229 * 230 * The only thing done here is to put the buffer back to the pool. 231 * Calling this function need be protected by mutex, bf_pool.pool_lock. 232 */ 233 static void 234 xgell_rx_buffer_release(xgell_rx_buffer_t *rx_buffer) 235 { 236 xgell_rx_ring_t *ring = rx_buffer->ring; 237 xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool; 238 239 xge_assert(mutex_owned(&bf_pool->pool_lock)); 240 241 /* Put the buffer back to pool */ 242 rx_buffer->next = bf_pool->head; 243 bf_pool->head = rx_buffer; 244 245 bf_pool->free++; 246 } 247 248 /* 249 * xgell_rx_buffer_recycle 250 * 251 * Called by desballoc() to "free" the resource. 252 * We will try to replenish all descripters. 253 */ 254 255 /* 256 * Previously there were much lock contention between xgell_rx_1b_compl() and 257 * xgell_rx_buffer_recycle(), which consumed a lot of CPU resources and had bad 258 * effect on rx performance. A separate recycle list is introduced to overcome 259 * this. The recycle list is used to record the rx buffer that has been recycled 260 * and these buffers will be retuned back to the free list in bulk instead of 261 * one-by-one. 262 */ 263 264 static void 265 xgell_rx_buffer_recycle(char *arg) 266 { 267 xgell_rx_buffer_t *rx_buffer = (xgell_rx_buffer_t *)arg; 268 xgell_rx_ring_t *ring = rx_buffer->ring; 269 xgelldev_t *lldev = ring->lldev; 270 xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool; 271 272 mutex_enter(&bf_pool->recycle_lock); 273 274 rx_buffer->next = bf_pool->recycle_head; 275 bf_pool->recycle_head = rx_buffer; 276 if (bf_pool->recycle_tail == NULL) 277 bf_pool->recycle_tail = rx_buffer; 278 bf_pool->recycle++; 279 280 /* 281 * Before finding a good way to set this hiwat, just always call to 282 * replenish_all. *TODO* 283 */ 284 if ((lldev->is_initialized != 0) && (ring->live) && 285 (bf_pool->recycle >= XGELL_RX_BUFFER_RECYCLE_CACHE)) { 286 mutex_enter(&bf_pool->pool_lock); 287 bf_pool->recycle_tail->next = bf_pool->head; 288 bf_pool->head = bf_pool->recycle_head; 289 bf_pool->recycle_head = bf_pool->recycle_tail = NULL; 290 bf_pool->post -= bf_pool->recycle; 291 bf_pool->free += bf_pool->recycle; 292 bf_pool->recycle = 0; 293 xgell_rx_buffer_replenish_all(ring); 294 mutex_exit(&bf_pool->pool_lock); 295 } 296 297 mutex_exit(&bf_pool->recycle_lock); 298 } 299 300 /* 301 * xgell_rx_buffer_alloc 302 * 303 * Allocate one rx buffer and return with the pointer to the buffer. 304 * Return NULL if failed. 305 */ 306 static xgell_rx_buffer_t * 307 xgell_rx_buffer_alloc(xgell_rx_ring_t *ring) 308 { 309 xgelldev_t *lldev = ring->lldev; 310 xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool; 311 xge_hal_device_t *hldev; 312 void *vaddr; 313 ddi_dma_handle_t dma_handle; 314 ddi_acc_handle_t dma_acch; 315 dma_addr_t dma_addr; 316 uint_t ncookies; 317 ddi_dma_cookie_t dma_cookie; 318 size_t real_size; 319 extern ddi_device_acc_attr_t *p_xge_dev_attr; 320 xgell_rx_buffer_t *rx_buffer; 321 322 hldev = (xge_hal_device_t *)lldev->devh; 323 324 if (ddi_dma_alloc_handle(hldev->pdev, p_hal_dma_attr, DDI_DMA_SLEEP, 325 0, &dma_handle) != DDI_SUCCESS) { 326 xge_debug_ll(XGE_ERR, "%s%d: can not allocate DMA handle", 327 XGELL_IFNAME, lldev->instance); 328 goto handle_failed; 329 } 330 331 /* reserve some space at the end of the buffer for recycling */ 332 if (ddi_dma_mem_alloc(dma_handle, HEADROOM + bf_pool->size + 333 sizeof (xgell_rx_buffer_t), p_xge_dev_attr, DDI_DMA_STREAMING, 334 DDI_DMA_SLEEP, 0, (caddr_t *)&vaddr, &real_size, &dma_acch) != 335 DDI_SUCCESS) { 336 xge_debug_ll(XGE_ERR, "%s%d: can not allocate DMA-able memory", 337 XGELL_IFNAME, lldev->instance); 338 goto mem_failed; 339 } 340 341 if (HEADROOM + bf_pool->size + sizeof (xgell_rx_buffer_t) > 342 real_size) { 343 xge_debug_ll(XGE_ERR, "%s%d: can not allocate DMA-able memory", 344 XGELL_IFNAME, lldev->instance); 345 goto bind_failed; 346 } 347 348 if (ddi_dma_addr_bind_handle(dma_handle, NULL, (char *)vaddr + HEADROOM, 349 bf_pool->size, DDI_DMA_READ | DDI_DMA_STREAMING, 350 DDI_DMA_SLEEP, 0, &dma_cookie, &ncookies) != DDI_SUCCESS) { 351 xge_debug_ll(XGE_ERR, "%s%d: out of mapping for mblk", 352 XGELL_IFNAME, lldev->instance); 353 goto bind_failed; 354 } 355 356 if (ncookies != 1 || dma_cookie.dmac_size < bf_pool->size) { 357 xge_debug_ll(XGE_ERR, "%s%d: can not handle partial DMA", 358 XGELL_IFNAME, lldev->instance); 359 goto check_failed; 360 } 361 362 dma_addr = dma_cookie.dmac_laddress; 363 364 rx_buffer = (xgell_rx_buffer_t *)((char *)vaddr + real_size - 365 sizeof (xgell_rx_buffer_t)); 366 rx_buffer->next = NULL; 367 rx_buffer->vaddr = vaddr; 368 rx_buffer->dma_addr = dma_addr; 369 rx_buffer->dma_handle = dma_handle; 370 rx_buffer->dma_acch = dma_acch; 371 rx_buffer->ring = ring; 372 rx_buffer->frtn.free_func = xgell_rx_buffer_recycle; 373 rx_buffer->frtn.free_arg = (void *)rx_buffer; 374 375 return (rx_buffer); 376 377 check_failed: 378 (void) ddi_dma_unbind_handle(dma_handle); 379 bind_failed: 380 XGE_OS_MEMORY_CHECK_FREE(vaddr, 0); 381 ddi_dma_mem_free(&dma_acch); 382 mem_failed: 383 ddi_dma_free_handle(&dma_handle); 384 handle_failed: 385 386 return (NULL); 387 } 388 389 /* 390 * xgell_rx_destroy_buffer_pool 391 * 392 * Destroy buffer pool. If there is still any buffer hold by upper layer, 393 * recorded by bf_pool.post, return DDI_FAILURE to reject to be unloaded. 394 */ 395 static boolean_t 396 xgell_rx_destroy_buffer_pool(xgell_rx_ring_t *ring) 397 { 398 xgelldev_t *lldev = ring->lldev; 399 xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool; 400 xgell_rx_buffer_t *rx_buffer; 401 ddi_dma_handle_t dma_handle; 402 ddi_acc_handle_t dma_acch; 403 int i; 404 405 /* 406 * If the pool has been destroied, just return B_TRUE 407 */ 408 if (!bf_pool->live) 409 return (B_TRUE); 410 411 mutex_enter(&bf_pool->recycle_lock); 412 if (bf_pool->recycle > 0) { 413 mutex_enter(&bf_pool->pool_lock); 414 bf_pool->recycle_tail->next = bf_pool->head; 415 bf_pool->head = bf_pool->recycle_head; 416 bf_pool->recycle_tail = bf_pool->recycle_head = NULL; 417 bf_pool->post -= bf_pool->recycle; 418 bf_pool->free += bf_pool->recycle; 419 bf_pool->recycle = 0; 420 mutex_exit(&bf_pool->pool_lock); 421 } 422 mutex_exit(&bf_pool->recycle_lock); 423 424 /* 425 * If there is any posted buffer, the driver should reject to be 426 * detached. Need notice upper layer to release them. 427 */ 428 if (bf_pool->post != 0) { 429 xge_debug_ll(XGE_ERR, 430 "%s%d has some buffers not be recycled, try later!", 431 XGELL_IFNAME, lldev->instance); 432 return (B_FALSE); 433 } 434 435 /* 436 * Release buffers one by one. 437 */ 438 for (i = bf_pool->total; i > 0; i--) { 439 rx_buffer = bf_pool->head; 440 xge_assert(rx_buffer != NULL); 441 442 bf_pool->head = rx_buffer->next; 443 444 dma_handle = rx_buffer->dma_handle; 445 dma_acch = rx_buffer->dma_acch; 446 447 if (ddi_dma_unbind_handle(dma_handle) != DDI_SUCCESS) { 448 xge_debug_ll(XGE_ERR, "failed to unbind DMA handle!"); 449 bf_pool->head = rx_buffer; 450 return (B_FALSE); 451 } 452 ddi_dma_mem_free(&dma_acch); 453 ddi_dma_free_handle(&dma_handle); 454 455 bf_pool->total--; 456 bf_pool->free--; 457 } 458 459 xge_assert(!mutex_owned(&bf_pool->pool_lock)); 460 461 mutex_destroy(&bf_pool->recycle_lock); 462 mutex_destroy(&bf_pool->pool_lock); 463 bf_pool->live = B_FALSE; 464 465 return (B_TRUE); 466 } 467 468 /* 469 * xgell_rx_create_buffer_pool 470 * 471 * Initialize RX buffer pool for all RX rings. Refer to rx_buffer_pool_t. 472 */ 473 static boolean_t 474 xgell_rx_create_buffer_pool(xgell_rx_ring_t *ring) 475 { 476 xgelldev_t *lldev = ring->lldev; 477 xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool; 478 xge_hal_device_t *hldev; 479 xgell_rx_buffer_t *rx_buffer; 480 int i; 481 482 if (bf_pool->live) 483 return (B_TRUE); 484 485 hldev = (xge_hal_device_t *)lldev->devh; 486 487 bf_pool->total = 0; 488 bf_pool->size = XGELL_MAX_FRAME_SIZE(hldev); 489 bf_pool->head = NULL; 490 bf_pool->free = 0; 491 bf_pool->post = 0; 492 bf_pool->post_hiwat = lldev->config.rx_buffer_post_hiwat; 493 bf_pool->recycle = 0; 494 bf_pool->recycle_head = NULL; 495 bf_pool->recycle_tail = NULL; 496 bf_pool->live = B_TRUE; 497 498 mutex_init(&bf_pool->pool_lock, NULL, MUTEX_DRIVER, 499 DDI_INTR_PRI(hldev->irqh)); 500 mutex_init(&bf_pool->recycle_lock, NULL, MUTEX_DRIVER, 501 DDI_INTR_PRI(hldev->irqh)); 502 503 /* 504 * Allocate buffers one by one. If failed, destroy whole pool by 505 * call to xgell_rx_destroy_buffer_pool(). 506 */ 507 508 for (i = 0; i < lldev->config.rx_buffer_total; i++) { 509 if ((rx_buffer = xgell_rx_buffer_alloc(ring)) == NULL) { 510 (void) xgell_rx_destroy_buffer_pool(ring); 511 return (B_FALSE); 512 } 513 514 rx_buffer->next = bf_pool->head; 515 bf_pool->head = rx_buffer; 516 517 bf_pool->total++; 518 bf_pool->free++; 519 } 520 521 return (B_TRUE); 522 } 523 524 /* 525 * xgell_rx_dtr_replenish 526 * 527 * Replenish descriptor with rx_buffer in RX buffer pool. 528 * The dtr should be post right away. 529 */ 530 xge_hal_status_e 531 xgell_rx_dtr_replenish(xge_hal_channel_h channelh, xge_hal_dtr_h dtr, int index, 532 void *userdata, xge_hal_channel_reopen_e reopen) 533 { 534 xgell_rx_ring_t *ring = userdata; 535 xgell_rx_buffer_pool_t *bf_pool = &ring->bf_pool; 536 xgell_rx_buffer_t *rx_buffer; 537 xgell_rxd_priv_t *rxd_priv; 538 539 mutex_enter(&bf_pool->pool_lock); 540 if (bf_pool->head == NULL) { 541 xge_debug_ll(XGE_ERR, "no more available rx DMA buffer!"); 542 return (XGE_HAL_FAIL); 543 } 544 rx_buffer = bf_pool->head; 545 xge_assert(rx_buffer); 546 xge_assert(rx_buffer->dma_addr); 547 548 bf_pool->head = rx_buffer->next; 549 bf_pool->free--; 550 mutex_exit(&bf_pool->pool_lock); 551 552 rxd_priv = (xgell_rxd_priv_t *)xge_hal_ring_dtr_private(channelh, dtr); 553 xge_hal_ring_dtr_1b_set(dtr, rx_buffer->dma_addr, bf_pool->size); 554 555 rxd_priv->rx_buffer = rx_buffer; 556 557 return (XGE_HAL_OK); 558 } 559 560 /* 561 * xgell_get_ip_offset 562 * 563 * Calculate the offset to IP header. 564 */ 565 static inline int 566 xgell_get_ip_offset(xge_hal_dtr_info_t *ext_info) 567 { 568 int ip_off; 569 570 /* get IP-header offset */ 571 switch (ext_info->frame) { 572 case XGE_HAL_FRAME_TYPE_DIX: 573 ip_off = XGE_HAL_HEADER_ETHERNET_II_802_3_SIZE; 574 break; 575 case XGE_HAL_FRAME_TYPE_IPX: 576 ip_off = (XGE_HAL_HEADER_ETHERNET_II_802_3_SIZE + 577 XGE_HAL_HEADER_802_2_SIZE + 578 XGE_HAL_HEADER_SNAP_SIZE); 579 break; 580 case XGE_HAL_FRAME_TYPE_LLC: 581 ip_off = (XGE_HAL_HEADER_ETHERNET_II_802_3_SIZE + 582 XGE_HAL_HEADER_802_2_SIZE); 583 break; 584 case XGE_HAL_FRAME_TYPE_SNAP: 585 ip_off = (XGE_HAL_HEADER_ETHERNET_II_802_3_SIZE + 586 XGE_HAL_HEADER_SNAP_SIZE); 587 break; 588 default: 589 ip_off = 0; 590 break; 591 } 592 593 if ((ext_info->proto & XGE_HAL_FRAME_PROTO_IPV4 || 594 ext_info->proto & XGE_HAL_FRAME_PROTO_IPV6) && 595 (ext_info->proto & XGE_HAL_FRAME_PROTO_VLAN_TAGGED)) { 596 ip_off += XGE_HAL_HEADER_VLAN_SIZE; 597 } 598 599 return (ip_off); 600 } 601 602 /* 603 * xgell_rx_hcksum_assoc 604 * 605 * Judge the packet type and then call to hcksum_assoc() to associate 606 * h/w checksum information. 607 */ 608 static inline void 609 xgell_rx_hcksum_assoc(mblk_t *mp, char *vaddr, int pkt_length, 610 xge_hal_dtr_info_t *ext_info) 611 { 612 int cksum_flags = 0; 613 614 if (!(ext_info->proto & XGE_HAL_FRAME_PROTO_IP_FRAGMENTED)) { 615 if (ext_info->proto & XGE_HAL_FRAME_PROTO_TCP_OR_UDP) { 616 if (ext_info->l3_cksum == XGE_HAL_L3_CKSUM_OK) { 617 cksum_flags |= HCK_IPV4_HDRCKSUM_OK; 618 } 619 if (ext_info->l4_cksum == XGE_HAL_L4_CKSUM_OK) { 620 cksum_flags |= HCK_FULLCKSUM_OK; 621 } 622 if (cksum_flags != 0) { 623 mac_hcksum_set(mp, 0, 0, 0, 0, cksum_flags); 624 } 625 } 626 } else if (ext_info->proto & 627 (XGE_HAL_FRAME_PROTO_IPV4 | XGE_HAL_FRAME_PROTO_IPV6)) { 628 /* 629 * Just pass the partial cksum up to IP. 630 */ 631 int ip_off = xgell_get_ip_offset(ext_info); 632 int start, end = pkt_length - ip_off; 633 634 if (ext_info->proto & XGE_HAL_FRAME_PROTO_IPV4) { 635 struct ip *ip = 636 (struct ip *)(vaddr + ip_off); 637 start = ip->ip_hl * 4; 638 } else { 639 start = 40; 640 } 641 cksum_flags |= HCK_PARTIALCKSUM; 642 mac_hcksum_set(mp, start, 0, end, 643 ntohs(ext_info->l4_cksum), cksum_flags); 644 } 645 } 646 647 /* 648 * xgell_rx_1b_msg_alloc 649 * 650 * Allocate message header for data buffer, and decide if copy the packet to 651 * new data buffer to release big rx_buffer to save memory. 652 * 653 * If the pkt_length <= XGELL_RX_DMA_LOWAT, call allocb() to allocate 654 * new message and copy the payload in. 655 */ 656 static mblk_t * 657 xgell_rx_1b_msg_alloc(xgell_rx_ring_t *ring, xgell_rx_buffer_t *rx_buffer, 658 int pkt_length, xge_hal_dtr_info_t *ext_info, boolean_t *copyit) 659 { 660 xgelldev_t *lldev = ring->lldev; 661 mblk_t *mp; 662 char *vaddr; 663 664 vaddr = (char *)rx_buffer->vaddr + HEADROOM; 665 /* 666 * Copy packet into new allocated message buffer, if pkt_length 667 * is less than XGELL_RX_DMA_LOWAT 668 */ 669 if (*copyit || pkt_length <= lldev->config.rx_dma_lowat) { 670 if ((mp = allocb(pkt_length + HEADROOM, 0)) == NULL) { 671 return (NULL); 672 } 673 mp->b_rptr += HEADROOM; 674 bcopy(vaddr, mp->b_rptr, pkt_length); 675 mp->b_wptr = mp->b_rptr + pkt_length; 676 *copyit = B_TRUE; 677 return (mp); 678 } 679 680 /* 681 * Just allocate mblk for current data buffer 682 */ 683 if ((mp = (mblk_t *)desballoc((unsigned char *)vaddr, pkt_length, 0, 684 &rx_buffer->frtn)) == NULL) { 685 /* Drop it */ 686 return (NULL); 687 } 688 /* 689 * Adjust the b_rptr/b_wptr in the mblk_t structure. 690 */ 691 mp->b_wptr += pkt_length; 692 693 return (mp); 694 } 695 696 /* 697 * xgell_rx_1b_callback 698 * 699 * If the interrupt is because of a received frame or if the receive ring 700 * contains fresh as yet un-processed frames, this function is called. 701 */ 702 static xge_hal_status_e 703 xgell_rx_1b_callback(xge_hal_channel_h channelh, xge_hal_dtr_h dtr, u8 t_code, 704 void *userdata) 705 { 706 xgell_rx_ring_t *ring = (xgell_rx_ring_t *)userdata; 707 xgelldev_t *lldev = ring->lldev; 708 xgell_rx_buffer_t *rx_buffer; 709 mblk_t *mp_head = NULL; 710 mblk_t *mp_end = NULL; 711 int pkt_burst = 0; 712 713 xge_debug_ll(XGE_TRACE, "xgell_rx_1b_callback on ring %d", ring->index); 714 715 mutex_enter(&ring->bf_pool.pool_lock); 716 do { 717 int pkt_length; 718 dma_addr_t dma_data; 719 mblk_t *mp; 720 boolean_t copyit = B_FALSE; 721 722 xgell_rxd_priv_t *rxd_priv = ((xgell_rxd_priv_t *) 723 xge_hal_ring_dtr_private(channelh, dtr)); 724 xge_hal_dtr_info_t ext_info; 725 726 rx_buffer = rxd_priv->rx_buffer; 727 728 xge_hal_ring_dtr_1b_get(channelh, dtr, &dma_data, &pkt_length); 729 xge_hal_ring_dtr_info_get(channelh, dtr, &ext_info); 730 731 xge_assert(dma_data == rx_buffer->dma_addr); 732 733 if (t_code != 0) { 734 xge_debug_ll(XGE_ERR, "%s%d: rx: dtr 0x%"PRIx64 735 " completed due to error t_code %01x", XGELL_IFNAME, 736 lldev->instance, (uint64_t)(uintptr_t)dtr, t_code); 737 738 (void) xge_hal_device_handle_tcode(channelh, dtr, 739 t_code); 740 xge_hal_ring_dtr_free(channelh, dtr); /* drop it */ 741 xgell_rx_buffer_release(rx_buffer); 742 continue; 743 } 744 745 /* 746 * Sync the DMA memory 747 */ 748 if (ddi_dma_sync(rx_buffer->dma_handle, 0, pkt_length, 749 DDI_DMA_SYNC_FORKERNEL) != DDI_SUCCESS) { 750 xge_debug_ll(XGE_ERR, "%s%d: rx: can not do DMA sync", 751 XGELL_IFNAME, lldev->instance); 752 xge_hal_ring_dtr_free(channelh, dtr); /* drop it */ 753 xgell_rx_buffer_release(rx_buffer); 754 continue; 755 } 756 757 /* 758 * Allocate message for the packet. 759 */ 760 if (ring->bf_pool.post > ring->bf_pool.post_hiwat) { 761 copyit = B_TRUE; 762 } else { 763 copyit = B_FALSE; 764 } 765 766 mp = xgell_rx_1b_msg_alloc(ring, rx_buffer, pkt_length, 767 &ext_info, ©it); 768 769 xge_hal_ring_dtr_free(channelh, dtr); 770 771 /* 772 * Release the buffer and recycle it later 773 */ 774 if ((mp == NULL) || copyit) { 775 xgell_rx_buffer_release(rx_buffer); 776 } else { 777 /* 778 * Count it since the buffer should be loaned up. 779 */ 780 ring->bf_pool.post++; 781 } 782 if (mp == NULL) { 783 xge_debug_ll(XGE_ERR, 784 "%s%d: rx: can not allocate mp mblk", 785 XGELL_IFNAME, lldev->instance); 786 continue; 787 } 788 789 /* 790 * Associate cksum_flags per packet type and h/w 791 * cksum flags. 792 */ 793 xgell_rx_hcksum_assoc(mp, (char *)rx_buffer->vaddr + HEADROOM, 794 pkt_length, &ext_info); 795 796 ring->rx_pkts++; 797 ring->rx_bytes += pkt_length; 798 799 if (mp_head == NULL) { 800 mp_head = mp; 801 mp_end = mp; 802 } else { 803 mp_end->b_next = mp; 804 mp_end = mp; 805 } 806 807 /* 808 * Inlined implemented polling function. 809 */ 810 if ((ring->poll_mp == NULL) && (ring->poll_bytes > 0)) { 811 ring->poll_mp = mp_head; 812 } 813 if (ring->poll_mp != NULL) { 814 if ((ring->poll_bytes -= pkt_length) <= 0) { 815 /* have polled enough packets. */ 816 break; 817 } else { 818 /* continue polling packets. */ 819 continue; 820 } 821 } 822 823 /* 824 * We're not in polling mode, so try to chain more messages 825 * or send the chain up according to pkt_burst. 826 */ 827 if (++pkt_burst < lldev->config.rx_pkt_burst) 828 continue; 829 830 if (ring->bf_pool.post > ring->bf_pool.post_hiwat) { 831 /* Replenish rx buffers */ 832 xgell_rx_buffer_replenish_all(ring); 833 } 834 mutex_exit(&ring->bf_pool.pool_lock); 835 if (mp_head != NULL) { 836 mac_rx_ring(lldev->mh, ring->ring_handle, mp_head, 837 ring->ring_gen_num); 838 } 839 mp_head = mp_end = NULL; 840 pkt_burst = 0; 841 mutex_enter(&ring->bf_pool.pool_lock); 842 843 } while (xge_hal_ring_dtr_next_completed(channelh, &dtr, &t_code) == 844 XGE_HAL_OK); 845 846 /* 847 * Always call replenish_all to recycle rx_buffers. 848 */ 849 xgell_rx_buffer_replenish_all(ring); 850 mutex_exit(&ring->bf_pool.pool_lock); 851 852 /* 853 * If we're not in polling cycle, call mac_rx(), otherwise 854 * just return while leaving packets chained to ring->poll_mp. 855 */ 856 if ((ring->poll_mp == NULL) && (mp_head != NULL)) { 857 mac_rx_ring(lldev->mh, ring->ring_handle, mp_head, 858 ring->ring_gen_num); 859 } 860 861 return (XGE_HAL_OK); 862 } 863 864 mblk_t * 865 xgell_rx_poll(void *arg, int bytes_to_pickup) 866 { 867 xgell_rx_ring_t *ring = (xgell_rx_ring_t *)arg; 868 int got_rx = 0; 869 mblk_t *mp; 870 871 xge_debug_ll(XGE_TRACE, "xgell_rx_poll on ring %d", ring->index); 872 873 ring->poll_mp = NULL; 874 ring->poll_bytes = bytes_to_pickup; 875 (void) xge_hal_device_poll_rx_channel(ring->channelh, &got_rx); 876 877 mp = ring->poll_mp; 878 ring->poll_bytes = -1; 879 ring->polled_bytes += got_rx; 880 ring->poll_mp = NULL; 881 882 return (mp); 883 } 884 885 /* 886 * xgell_xmit_compl 887 * 888 * If an interrupt was raised to indicate DMA complete of the Tx packet, 889 * this function is called. It identifies the last TxD whose buffer was 890 * freed and frees all skbs whose data have already DMA'ed into the NICs 891 * internal memory. 892 */ 893 static xge_hal_status_e 894 xgell_xmit_compl(xge_hal_channel_h channelh, xge_hal_dtr_h dtr, u8 t_code, 895 void *userdata) 896 { 897 xgell_tx_ring_t *ring = userdata; 898 xgelldev_t *lldev = ring->lldev; 899 900 do { 901 xgell_txd_priv_t *txd_priv = ((xgell_txd_priv_t *) 902 xge_hal_fifo_dtr_private(dtr)); 903 int i; 904 905 if (t_code) { 906 xge_debug_ll(XGE_TRACE, "%s%d: tx: dtr 0x%"PRIx64 907 " completed due to error t_code %01x", XGELL_IFNAME, 908 lldev->instance, (uint64_t)(uintptr_t)dtr, t_code); 909 910 (void) xge_hal_device_handle_tcode(channelh, dtr, 911 t_code); 912 } 913 914 for (i = 0; i < txd_priv->handle_cnt; i++) { 915 if (txd_priv->dma_handles[i] != NULL) { 916 xge_assert(txd_priv->dma_handles[i]); 917 (void) ddi_dma_unbind_handle( 918 txd_priv->dma_handles[i]); 919 ddi_dma_free_handle(&txd_priv->dma_handles[i]); 920 txd_priv->dma_handles[i] = 0; 921 } 922 } 923 txd_priv->handle_cnt = 0; 924 925 xge_hal_fifo_dtr_free(channelh, dtr); 926 927 if (txd_priv->mblk != NULL) { 928 freemsg(txd_priv->mblk); 929 txd_priv->mblk = NULL; 930 } 931 932 } while (xge_hal_fifo_dtr_next_completed(channelh, &dtr, &t_code) == 933 XGE_HAL_OK); 934 935 if (ring->need_resched) 936 mac_tx_ring_update(lldev->mh, ring->ring_handle); 937 938 return (XGE_HAL_OK); 939 } 940 941 mblk_t * 942 xgell_ring_tx(void *arg, mblk_t *mp) 943 { 944 xgell_tx_ring_t *ring = (xgell_tx_ring_t *)arg; 945 mblk_t *bp; 946 xgelldev_t *lldev = ring->lldev; 947 xge_hal_device_t *hldev = lldev->devh; 948 xge_hal_status_e status; 949 xge_hal_dtr_h dtr; 950 xgell_txd_priv_t *txd_priv; 951 uint32_t hckflags; 952 uint32_t lsoflags; 953 uint32_t mss; 954 int handle_cnt, frag_cnt, ret, i, copied; 955 boolean_t used_copy; 956 uint64_t sent_bytes; 957 958 _begin: 959 handle_cnt = frag_cnt = 0; 960 sent_bytes = 0; 961 962 if (!lldev->is_initialized || lldev->in_reset) 963 return (mp); 964 965 /* 966 * If the free Tx dtrs count reaches the lower threshold, 967 * inform the gld to stop sending more packets till the free 968 * dtrs count exceeds higher threshold. Driver informs the 969 * gld through gld_sched call, when the free dtrs count exceeds 970 * the higher threshold. 971 */ 972 if (xge_hal_channel_dtr_count(ring->channelh) 973 <= XGELL_TX_LEVEL_LOW) { 974 xge_debug_ll(XGE_TRACE, "%s%d: queue %d: err on xmit," 975 "free descriptors count at low threshold %d", 976 XGELL_IFNAME, lldev->instance, 977 ((xge_hal_channel_t *)ring->channelh)->post_qid, 978 XGELL_TX_LEVEL_LOW); 979 goto _exit; 980 } 981 982 status = xge_hal_fifo_dtr_reserve(ring->channelh, &dtr); 983 if (status != XGE_HAL_OK) { 984 switch (status) { 985 case XGE_HAL_INF_CHANNEL_IS_NOT_READY: 986 xge_debug_ll(XGE_ERR, 987 "%s%d: channel %d is not ready.", XGELL_IFNAME, 988 lldev->instance, 989 ((xge_hal_channel_t *) 990 ring->channelh)->post_qid); 991 goto _exit; 992 case XGE_HAL_INF_OUT_OF_DESCRIPTORS: 993 xge_debug_ll(XGE_TRACE, "%s%d: queue %d: error in xmit," 994 " out of descriptors.", XGELL_IFNAME, 995 lldev->instance, 996 ((xge_hal_channel_t *) 997 ring->channelh)->post_qid); 998 goto _exit; 999 default: 1000 return (mp); 1001 } 1002 } 1003 1004 txd_priv = xge_hal_fifo_dtr_private(dtr); 1005 txd_priv->mblk = mp; 1006 1007 /* 1008 * VLAN tag should be passed down along with MAC header, so h/w needn't 1009 * do insertion. 1010 * 1011 * For NIC driver that has to strip and re-insert VLAN tag, the example 1012 * is the other implementation for xge. The driver can simple bcopy() 1013 * ether_vlan_header to overwrite VLAN tag and let h/w insert the tag 1014 * automatically, since it's impossible that GLD sends down mp(s) with 1015 * splited ether_vlan_header. 1016 * 1017 * struct ether_vlan_header *evhp; 1018 * uint16_t tci; 1019 * 1020 * evhp = (struct ether_vlan_header *)mp->b_rptr; 1021 * if (evhp->ether_tpid == htons(VLAN_TPID)) { 1022 * tci = ntohs(evhp->ether_tci); 1023 * (void) bcopy(mp->b_rptr, mp->b_rptr + VLAN_TAGSZ, 1024 * 2 * ETHERADDRL); 1025 * mp->b_rptr += VLAN_TAGSZ; 1026 * 1027 * xge_hal_fifo_dtr_vlan_set(dtr, tci); 1028 * } 1029 */ 1030 1031 copied = 0; 1032 used_copy = B_FALSE; 1033 for (bp = mp; bp != NULL; bp = bp->b_cont) { 1034 int mblen; 1035 uint_t ncookies; 1036 ddi_dma_cookie_t dma_cookie; 1037 ddi_dma_handle_t dma_handle; 1038 1039 /* skip zero-length message blocks */ 1040 mblen = MBLKL(bp); 1041 if (mblen == 0) { 1042 continue; 1043 } 1044 1045 sent_bytes += mblen; 1046 1047 /* 1048 * Check the message length to decide to DMA or bcopy() data 1049 * to tx descriptor(s). 1050 */ 1051 if (mblen < lldev->config.tx_dma_lowat && 1052 (copied + mblen) < lldev->tx_copied_max) { 1053 xge_hal_status_e rc; 1054 rc = xge_hal_fifo_dtr_buffer_append(ring->channelh, 1055 dtr, bp->b_rptr, mblen); 1056 if (rc == XGE_HAL_OK) { 1057 used_copy = B_TRUE; 1058 copied += mblen; 1059 continue; 1060 } else if (used_copy) { 1061 xge_hal_fifo_dtr_buffer_finalize( 1062 ring->channelh, dtr, frag_cnt++); 1063 used_copy = B_FALSE; 1064 } 1065 } else if (used_copy) { 1066 xge_hal_fifo_dtr_buffer_finalize(ring->channelh, 1067 dtr, frag_cnt++); 1068 used_copy = B_FALSE; 1069 } 1070 1071 ret = ddi_dma_alloc_handle(lldev->dev_info, &tx_dma_attr, 1072 DDI_DMA_DONTWAIT, 0, &dma_handle); 1073 if (ret != DDI_SUCCESS) { 1074 xge_debug_ll(XGE_ERR, 1075 "%s%d: can not allocate dma handle", XGELL_IFNAME, 1076 lldev->instance); 1077 goto _exit_cleanup; 1078 } 1079 1080 ret = ddi_dma_addr_bind_handle(dma_handle, NULL, 1081 (caddr_t)bp->b_rptr, mblen, 1082 DDI_DMA_WRITE | DDI_DMA_STREAMING, DDI_DMA_DONTWAIT, 0, 1083 &dma_cookie, &ncookies); 1084 1085 switch (ret) { 1086 case DDI_DMA_MAPPED: 1087 /* everything's fine */ 1088 break; 1089 1090 case DDI_DMA_NORESOURCES: 1091 xge_debug_ll(XGE_ERR, 1092 "%s%d: can not bind dma address", 1093 XGELL_IFNAME, lldev->instance); 1094 ddi_dma_free_handle(&dma_handle); 1095 goto _exit_cleanup; 1096 1097 case DDI_DMA_NOMAPPING: 1098 case DDI_DMA_INUSE: 1099 case DDI_DMA_TOOBIG: 1100 default: 1101 /* drop packet, don't retry */ 1102 xge_debug_ll(XGE_ERR, 1103 "%s%d: can not map message buffer", 1104 XGELL_IFNAME, lldev->instance); 1105 ddi_dma_free_handle(&dma_handle); 1106 goto _exit_cleanup; 1107 } 1108 1109 if (ncookies + frag_cnt > hldev->config.fifo.max_frags) { 1110 xge_debug_ll(XGE_ERR, "%s%d: too many fragments, " 1111 "requested c:%d+f:%d", XGELL_IFNAME, 1112 lldev->instance, ncookies, frag_cnt); 1113 (void) ddi_dma_unbind_handle(dma_handle); 1114 ddi_dma_free_handle(&dma_handle); 1115 goto _exit_cleanup; 1116 } 1117 1118 /* setup the descriptors for this data buffer */ 1119 while (ncookies) { 1120 xge_hal_fifo_dtr_buffer_set(ring->channelh, dtr, 1121 frag_cnt++, dma_cookie.dmac_laddress, 1122 dma_cookie.dmac_size); 1123 if (--ncookies) { 1124 ddi_dma_nextcookie(dma_handle, &dma_cookie); 1125 } 1126 1127 } 1128 1129 txd_priv->dma_handles[handle_cnt++] = dma_handle; 1130 1131 if (bp->b_cont && 1132 (frag_cnt + XGE_HAL_DEFAULT_FIFO_FRAGS_THRESHOLD >= 1133 hldev->config.fifo.max_frags)) { 1134 mblk_t *nmp; 1135 1136 xge_debug_ll(XGE_TRACE, 1137 "too many FRAGs [%d], pull up them", frag_cnt); 1138 1139 if ((nmp = msgpullup(bp->b_cont, -1)) == NULL) { 1140 /* Drop packet, don't retry */ 1141 xge_debug_ll(XGE_ERR, 1142 "%s%d: can not pullup message buffer", 1143 XGELL_IFNAME, lldev->instance); 1144 goto _exit_cleanup; 1145 } 1146 freemsg(bp->b_cont); 1147 bp->b_cont = nmp; 1148 } 1149 } 1150 1151 /* finalize unfinished copies */ 1152 if (used_copy) { 1153 xge_hal_fifo_dtr_buffer_finalize(ring->channelh, dtr, 1154 frag_cnt++); 1155 } 1156 1157 txd_priv->handle_cnt = handle_cnt; 1158 1159 /* 1160 * If LSO is required, just call xge_hal_fifo_dtr_mss_set(dtr, mss) to 1161 * do all necessary work. 1162 */ 1163 mac_lso_get(mp, &mss, &lsoflags); 1164 1165 if (lsoflags & HW_LSO) { 1166 xge_assert((mss != 0) && (mss <= XGE_HAL_DEFAULT_MTU)); 1167 xge_hal_fifo_dtr_mss_set(dtr, mss); 1168 } 1169 1170 mac_hcksum_get(mp, NULL, NULL, NULL, NULL, &hckflags); 1171 if (hckflags & HCK_IPV4_HDRCKSUM) { 1172 xge_hal_fifo_dtr_cksum_set_bits(dtr, 1173 XGE_HAL_TXD_TX_CKO_IPV4_EN); 1174 } 1175 if (hckflags & HCK_FULLCKSUM) { 1176 xge_hal_fifo_dtr_cksum_set_bits(dtr, XGE_HAL_TXD_TX_CKO_TCP_EN | 1177 XGE_HAL_TXD_TX_CKO_UDP_EN); 1178 } 1179 1180 xge_hal_fifo_dtr_post(ring->channelh, dtr); 1181 1182 /* Update per-ring tx statistics */ 1183 atomic_inc_64(&ring->tx_pkts); 1184 atomic_add_64(&ring->tx_bytes, sent_bytes); 1185 1186 return (NULL); 1187 1188 _exit_cleanup: 1189 /* 1190 * Could not successfully transmit but have changed the message, 1191 * so just free it and return NULL 1192 */ 1193 for (i = 0; i < handle_cnt; i++) { 1194 (void) ddi_dma_unbind_handle(txd_priv->dma_handles[i]); 1195 ddi_dma_free_handle(&txd_priv->dma_handles[i]); 1196 txd_priv->dma_handles[i] = 0; 1197 } 1198 1199 xge_hal_fifo_dtr_free(ring->channelh, dtr); 1200 1201 freemsg(mp); 1202 return (NULL); 1203 1204 _exit: 1205 ring->need_resched = B_TRUE; 1206 return (mp); 1207 } 1208 1209 /* 1210 * xgell_ring_macaddr_init 1211 */ 1212 static void 1213 xgell_rx_ring_maddr_init(xgell_rx_ring_t *ring) 1214 { 1215 int i; 1216 xgelldev_t *lldev = ring->lldev; 1217 xge_hal_device_t *hldev = lldev->devh; 1218 int slot_start; 1219 1220 xge_debug_ll(XGE_TRACE, "%s", "xgell_rx_ring_maddr_init"); 1221 1222 ring->mmac.naddr = XGE_RX_MULTI_MAC_ADDRESSES_MAX; 1223 ring->mmac.naddrfree = ring->mmac.naddr; 1224 1225 /* 1226 * For the default rx ring, the first MAC address is the factory one. 1227 * This will be set by the framework, so need to clear it for now. 1228 */ 1229 (void) xge_hal_device_macaddr_clear(hldev, 0); 1230 1231 /* 1232 * Read the MAC address Configuration Memory from HAL. 1233 * The first slot will hold a factory MAC address, contents in other 1234 * slots will be FF:FF:FF:FF:FF:FF. 1235 */ 1236 slot_start = ring->index * 32; 1237 for (i = 0; i < ring->mmac.naddr; i++) { 1238 (void) xge_hal_device_macaddr_get(hldev, slot_start + i, 1239 ring->mmac.mac_addr + i); 1240 ring->mmac.mac_addr_set[i] = B_FALSE; 1241 } 1242 } 1243 1244 static int xgell_maddr_set(xgelldev_t *, int, uint8_t *); 1245 1246 static int 1247 xgell_addmac(void *arg, const uint8_t *mac_addr) 1248 { 1249 xgell_rx_ring_t *ring = arg; 1250 xgelldev_t *lldev = ring->lldev; 1251 xge_hal_device_t *hldev = lldev->devh; 1252 int slot; 1253 int slot_start; 1254 1255 xge_debug_ll(XGE_TRACE, "%s", "xgell_addmac"); 1256 1257 mutex_enter(&lldev->genlock); 1258 1259 if (ring->mmac.naddrfree == 0) { 1260 mutex_exit(&lldev->genlock); 1261 return (ENOSPC); 1262 } 1263 1264 /* First slot is for factory MAC address */ 1265 for (slot = 0; slot < ring->mmac.naddr; slot++) { 1266 if (ring->mmac.mac_addr_set[slot] == B_FALSE) { 1267 break; 1268 } 1269 } 1270 1271 ASSERT(slot < ring->mmac.naddr); 1272 1273 slot_start = ring->index * 32; 1274 1275 if (xgell_maddr_set(lldev, slot_start + slot, (uint8_t *)mac_addr) != 1276 0) { 1277 mutex_exit(&lldev->genlock); 1278 return (EIO); 1279 } 1280 1281 /* Simply enable RTS for the whole section. */ 1282 (void) xge_hal_device_rts_section_enable(hldev, slot_start + slot); 1283 1284 /* 1285 * Read back the MAC address from HAL to keep the array up to date. 1286 */ 1287 if (xge_hal_device_macaddr_get(hldev, slot_start + slot, 1288 ring->mmac.mac_addr + slot) != XGE_HAL_OK) { 1289 (void) xge_hal_device_macaddr_clear(hldev, slot_start + slot); 1290 return (EIO); 1291 } 1292 1293 ring->mmac.mac_addr_set[slot] = B_TRUE; 1294 ring->mmac.naddrfree--; 1295 1296 mutex_exit(&lldev->genlock); 1297 1298 return (0); 1299 } 1300 1301 static int 1302 xgell_remmac(void *arg, const uint8_t *mac_addr) 1303 { 1304 xgell_rx_ring_t *ring = arg; 1305 xgelldev_t *lldev = ring->lldev; 1306 xge_hal_device_t *hldev = lldev->devh; 1307 xge_hal_status_e status; 1308 int slot; 1309 int slot_start; 1310 1311 xge_debug_ll(XGE_TRACE, "%s", "xgell_remmac"); 1312 1313 slot = xge_hal_device_macaddr_find(hldev, (uint8_t *)mac_addr); 1314 if (slot == -1) 1315 return (EINVAL); 1316 1317 slot_start = ring->index * 32; 1318 1319 /* 1320 * Adjust slot to the offset in the MAC array of this ring (group). 1321 */ 1322 slot -= slot_start; 1323 1324 /* 1325 * Only can remove a pre-set MAC address for this ring (group). 1326 */ 1327 if (slot < 0 || slot >= ring->mmac.naddr) 1328 return (EINVAL); 1329 1330 1331 xge_assert(ring->mmac.mac_addr_set[slot]); 1332 1333 mutex_enter(&lldev->genlock); 1334 if (!ring->mmac.mac_addr_set[slot]) { 1335 mutex_exit(&lldev->genlock); 1336 /* 1337 * The result will be unexpected when reach here. WARNING! 1338 */ 1339 xge_debug_ll(XGE_ERR, 1340 "%s%d: caller is trying to remove an unset MAC address", 1341 XGELL_IFNAME, lldev->instance); 1342 return (ENXIO); 1343 } 1344 1345 status = xge_hal_device_macaddr_clear(hldev, slot_start + slot); 1346 if (status != XGE_HAL_OK) { 1347 mutex_exit(&lldev->genlock); 1348 return (EIO); 1349 } 1350 1351 ring->mmac.mac_addr_set[slot] = B_FALSE; 1352 ring->mmac.naddrfree++; 1353 1354 /* 1355 * TODO: Disable MAC RTS if all addresses have been cleared. 1356 */ 1357 1358 /* 1359 * Read back the MAC address from HAL to keep the array up to date. 1360 */ 1361 (void) xge_hal_device_macaddr_get(hldev, slot_start + slot, 1362 ring->mmac.mac_addr + slot); 1363 mutex_exit(&lldev->genlock); 1364 1365 return (0); 1366 } 1367 1368 /* 1369 * Temporarily calling hal function. 1370 * 1371 * With MSI-X implementation, no lock is needed, so that the interrupt 1372 * handling could be faster. 1373 */ 1374 int 1375 xgell_rx_ring_intr_enable(mac_intr_handle_t ih) 1376 { 1377 xgell_rx_ring_t *ring = (xgell_rx_ring_t *)ih; 1378 1379 mutex_enter(&ring->ring_lock); 1380 xge_hal_device_rx_channel_disable_polling(ring->channelh); 1381 mutex_exit(&ring->ring_lock); 1382 1383 return (0); 1384 } 1385 1386 int 1387 xgell_rx_ring_intr_disable(mac_intr_handle_t ih) 1388 { 1389 xgell_rx_ring_t *ring = (xgell_rx_ring_t *)ih; 1390 1391 mutex_enter(&ring->ring_lock); 1392 xge_hal_device_rx_channel_enable_polling(ring->channelh); 1393 mutex_exit(&ring->ring_lock); 1394 1395 return (0); 1396 } 1397 1398 static int 1399 xgell_rx_ring_start(mac_ring_driver_t rh, uint64_t mr_gen_num) 1400 { 1401 xgell_rx_ring_t *rx_ring = (xgell_rx_ring_t *)rh; 1402 1403 rx_ring->ring_gen_num = mr_gen_num; 1404 1405 return (0); 1406 } 1407 1408 /*ARGSUSED*/ 1409 static void 1410 xgell_rx_ring_stop(mac_ring_driver_t rh) 1411 { 1412 } 1413 1414 /*ARGSUSED*/ 1415 static int 1416 xgell_tx_ring_start(mac_ring_driver_t rh, uint64_t useless) 1417 { 1418 return (0); 1419 } 1420 1421 /*ARGSUSED*/ 1422 static void 1423 xgell_tx_ring_stop(mac_ring_driver_t rh) 1424 { 1425 } 1426 1427 /* 1428 * Callback funtion for MAC layer to register all rings. 1429 * 1430 * Xframe hardware doesn't support grouping explicitly, so the driver needs 1431 * to pretend having resource groups. We may also optionally group all 8 rx 1432 * rings into a single group for increased scalability on CMT architectures, 1433 * or group one rx ring per group for maximum virtualization. 1434 * 1435 * TX grouping is actually done by framework, so, just register all TX 1436 * resources without grouping them. 1437 */ 1438 void 1439 xgell_fill_ring(void *arg, mac_ring_type_t rtype, const int rg_index, 1440 const int index, mac_ring_info_t *infop, mac_ring_handle_t rh) 1441 { 1442 xgelldev_t *lldev = (xgelldev_t *)arg; 1443 mac_intr_t *mintr; 1444 1445 switch (rtype) { 1446 case MAC_RING_TYPE_RX: { 1447 xgell_rx_ring_t *rx_ring; 1448 1449 xge_assert(index < lldev->init_rx_rings); 1450 xge_assert(rg_index < lldev->init_rx_groups); 1451 1452 /* 1453 * Performance vs. Virtualization 1454 */ 1455 if (lldev->init_rx_rings == lldev->init_rx_groups) 1456 rx_ring = lldev->rx_ring + rg_index; 1457 else 1458 rx_ring = lldev->rx_ring + index; 1459 1460 rx_ring->ring_handle = rh; 1461 1462 infop->mri_driver = (mac_ring_driver_t)rx_ring; 1463 infop->mri_start = xgell_rx_ring_start; 1464 infop->mri_stop = xgell_rx_ring_stop; 1465 infop->mri_poll = xgell_rx_poll; 1466 infop->mri_stat = xgell_rx_ring_stat; 1467 1468 mintr = &infop->mri_intr; 1469 mintr->mi_handle = (mac_intr_handle_t)rx_ring; 1470 mintr->mi_enable = xgell_rx_ring_intr_enable; 1471 mintr->mi_disable = xgell_rx_ring_intr_disable; 1472 1473 break; 1474 } 1475 case MAC_RING_TYPE_TX: { 1476 xgell_tx_ring_t *tx_ring; 1477 1478 xge_assert(rg_index == -1); 1479 1480 xge_assert((index >= 0) && (index < lldev->init_tx_rings)); 1481 1482 tx_ring = lldev->tx_ring + index; 1483 tx_ring->ring_handle = rh; 1484 1485 infop->mri_driver = (mac_ring_driver_t)tx_ring; 1486 infop->mri_start = xgell_tx_ring_start; 1487 infop->mri_stop = xgell_tx_ring_stop; 1488 infop->mri_tx = xgell_ring_tx; 1489 infop->mri_stat = xgell_tx_ring_stat; 1490 1491 break; 1492 } 1493 default: 1494 break; 1495 } 1496 } 1497 1498 void 1499 xgell_fill_group(void *arg, mac_ring_type_t rtype, const int index, 1500 mac_group_info_t *infop, mac_group_handle_t gh) 1501 { 1502 xgelldev_t *lldev = (xgelldev_t *)arg; 1503 1504 switch (rtype) { 1505 case MAC_RING_TYPE_RX: { 1506 xgell_rx_ring_t *rx_ring; 1507 1508 xge_assert(index < lldev->init_rx_groups); 1509 1510 rx_ring = lldev->rx_ring + index; 1511 1512 rx_ring->group_handle = gh; 1513 1514 infop->mgi_driver = (mac_group_driver_t)rx_ring; 1515 infop->mgi_start = NULL; 1516 infop->mgi_stop = NULL; 1517 infop->mgi_addmac = xgell_addmac; 1518 infop->mgi_remmac = xgell_remmac; 1519 infop->mgi_count = lldev->init_rx_rings / lldev->init_rx_groups; 1520 1521 break; 1522 } 1523 case MAC_RING_TYPE_TX: 1524 xge_assert(0); 1525 break; 1526 default: 1527 break; 1528 } 1529 } 1530 1531 /* 1532 * xgell_macaddr_set 1533 */ 1534 static int 1535 xgell_maddr_set(xgelldev_t *lldev, int index, uint8_t *macaddr) 1536 { 1537 xge_hal_device_t *hldev = lldev->devh; 1538 xge_hal_status_e status; 1539 1540 xge_debug_ll(XGE_TRACE, "%s", "xgell_maddr_set"); 1541 1542 xge_debug_ll(XGE_TRACE, 1543 "setting macaddr: 0x%02x-%02x-%02x-%02x-%02x-%02x", 1544 macaddr[0], macaddr[1], macaddr[2], 1545 macaddr[3], macaddr[4], macaddr[5]); 1546 1547 status = xge_hal_device_macaddr_set(hldev, index, (uchar_t *)macaddr); 1548 1549 if (status != XGE_HAL_OK) { 1550 xge_debug_ll(XGE_ERR, "%s%d: can not set mac address", 1551 XGELL_IFNAME, lldev->instance); 1552 return (EIO); 1553 } 1554 1555 return (0); 1556 } 1557 1558 /* 1559 * xgell_rx_dtr_term 1560 * 1561 * Function will be called by HAL to terminate all DTRs for 1562 * Ring(s) type of channels. 1563 */ 1564 static void 1565 xgell_rx_dtr_term(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh, 1566 xge_hal_dtr_state_e state, void *userdata, xge_hal_channel_reopen_e reopen) 1567 { 1568 xgell_rxd_priv_t *rxd_priv = 1569 ((xgell_rxd_priv_t *)xge_hal_ring_dtr_private(channelh, dtrh)); 1570 xgell_rx_buffer_t *rx_buffer = rxd_priv->rx_buffer; 1571 1572 if (state == XGE_HAL_DTR_STATE_POSTED) { 1573 xgell_rx_ring_t *ring = rx_buffer->ring; 1574 1575 mutex_enter(&ring->bf_pool.pool_lock); 1576 xge_hal_ring_dtr_free(channelh, dtrh); 1577 xgell_rx_buffer_release(rx_buffer); 1578 mutex_exit(&ring->bf_pool.pool_lock); 1579 } 1580 } 1581 1582 /* 1583 * To open a rx ring. 1584 */ 1585 static boolean_t 1586 xgell_rx_ring_open(xgell_rx_ring_t *rx_ring) 1587 { 1588 xge_hal_status_e status; 1589 xge_hal_channel_attr_t attr; 1590 xgelldev_t *lldev = rx_ring->lldev; 1591 xge_hal_device_t *hldev = lldev->devh; 1592 1593 if (rx_ring->live) 1594 return (B_TRUE); 1595 1596 /* Create the buffer pool first */ 1597 if (!xgell_rx_create_buffer_pool(rx_ring)) { 1598 xge_debug_ll(XGE_ERR, "can not create buffer pool for ring: %d", 1599 rx_ring->index); 1600 return (B_FALSE); 1601 } 1602 1603 /* Default ring initialization */ 1604 attr.post_qid = rx_ring->index; 1605 attr.compl_qid = 0; 1606 attr.callback = xgell_rx_1b_callback; 1607 attr.per_dtr_space = sizeof (xgell_rxd_priv_t); 1608 attr.flags = 0; 1609 attr.type = XGE_HAL_CHANNEL_TYPE_RING; 1610 attr.dtr_init = xgell_rx_dtr_replenish; 1611 attr.dtr_term = xgell_rx_dtr_term; 1612 attr.userdata = rx_ring; 1613 1614 status = xge_hal_channel_open(lldev->devh, &attr, &rx_ring->channelh, 1615 XGE_HAL_CHANNEL_OC_NORMAL); 1616 if (status != XGE_HAL_OK) { 1617 xge_debug_ll(XGE_ERR, "%s%d: cannot open Rx channel got status " 1618 " code %d", XGELL_IFNAME, lldev->instance, status); 1619 (void) xgell_rx_destroy_buffer_pool(rx_ring); 1620 return (B_FALSE); 1621 } 1622 1623 xgell_rx_ring_maddr_init(rx_ring); 1624 1625 mutex_init(&rx_ring->ring_lock, NULL, MUTEX_DRIVER, 1626 DDI_INTR_PRI(hldev->irqh)); 1627 1628 rx_ring->poll_bytes = -1; 1629 rx_ring->polled_bytes = 0; 1630 rx_ring->poll_mp = NULL; 1631 rx_ring->live = B_TRUE; 1632 1633 xge_debug_ll(XGE_TRACE, "RX ring [%d] is opened successfully", 1634 rx_ring->index); 1635 1636 return (B_TRUE); 1637 } 1638 1639 static void 1640 xgell_rx_ring_close(xgell_rx_ring_t *rx_ring) 1641 { 1642 if (!rx_ring->live) 1643 return; 1644 xge_hal_channel_close(rx_ring->channelh, XGE_HAL_CHANNEL_OC_NORMAL); 1645 rx_ring->channelh = NULL; 1646 /* This may not clean up all used buffers, driver will handle it */ 1647 if (xgell_rx_destroy_buffer_pool(rx_ring)) 1648 rx_ring->live = B_FALSE; 1649 1650 mutex_destroy(&rx_ring->ring_lock); 1651 } 1652 1653 /* 1654 * xgell_rx_open 1655 * @lldev: the link layer object 1656 * 1657 * Initialize and open all RX channels. 1658 */ 1659 static boolean_t 1660 xgell_rx_open(xgelldev_t *lldev) 1661 { 1662 xgell_rx_ring_t *rx_ring; 1663 int i; 1664 1665 if (lldev->live_rx_rings != 0) 1666 return (B_TRUE); 1667 1668 lldev->live_rx_rings = 0; 1669 1670 /* 1671 * Initialize all rings 1672 */ 1673 for (i = 0; i < lldev->init_rx_rings; i++) { 1674 rx_ring = &lldev->rx_ring[i]; 1675 rx_ring->index = i; 1676 rx_ring->lldev = lldev; 1677 rx_ring->live = B_FALSE; 1678 1679 if (!xgell_rx_ring_open(rx_ring)) 1680 return (B_FALSE); 1681 1682 lldev->live_rx_rings++; 1683 } 1684 1685 return (B_TRUE); 1686 } 1687 1688 static void 1689 xgell_rx_close(xgelldev_t *lldev) 1690 { 1691 xgell_rx_ring_t *rx_ring; 1692 int i; 1693 1694 if (lldev->live_rx_rings == 0) 1695 return; 1696 1697 /* 1698 * Close all rx rings 1699 */ 1700 for (i = 0; i < lldev->init_rx_rings; i++) { 1701 rx_ring = &lldev->rx_ring[i]; 1702 1703 if (rx_ring->live) { 1704 xgell_rx_ring_close(rx_ring); 1705 lldev->live_rx_rings--; 1706 } 1707 } 1708 1709 xge_assert(lldev->live_rx_rings == 0); 1710 } 1711 1712 /* 1713 * xgell_tx_term 1714 * 1715 * Function will be called by HAL to terminate all DTRs for 1716 * Fifo(s) type of channels. 1717 */ 1718 static void 1719 xgell_tx_term(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh, 1720 xge_hal_dtr_state_e state, void *userdata, xge_hal_channel_reopen_e reopen) 1721 { 1722 xgell_txd_priv_t *txd_priv = 1723 ((xgell_txd_priv_t *)xge_hal_fifo_dtr_private(dtrh)); 1724 mblk_t *mp = txd_priv->mblk; 1725 int i; 1726 1727 /* 1728 * for Tx we must clean up the DTR *only* if it has been 1729 * posted! 1730 */ 1731 if (state != XGE_HAL_DTR_STATE_POSTED) { 1732 return; 1733 } 1734 1735 for (i = 0; i < txd_priv->handle_cnt; i++) { 1736 xge_assert(txd_priv->dma_handles[i]); 1737 (void) ddi_dma_unbind_handle(txd_priv->dma_handles[i]); 1738 ddi_dma_free_handle(&txd_priv->dma_handles[i]); 1739 txd_priv->dma_handles[i] = 0; 1740 } 1741 1742 xge_hal_fifo_dtr_free(channelh, dtrh); 1743 1744 if (mp) { 1745 txd_priv->mblk = NULL; 1746 freemsg(mp); 1747 } 1748 } 1749 1750 static boolean_t 1751 xgell_tx_ring_open(xgell_tx_ring_t *tx_ring) 1752 { 1753 xge_hal_status_e status; 1754 xge_hal_channel_attr_t attr; 1755 xgelldev_t *lldev = tx_ring->lldev; 1756 1757 if (tx_ring->live) 1758 return (B_TRUE); 1759 1760 attr.post_qid = tx_ring->index; 1761 attr.compl_qid = 0; 1762 attr.callback = xgell_xmit_compl; 1763 attr.per_dtr_space = sizeof (xgell_txd_priv_t); 1764 attr.flags = 0; 1765 attr.type = XGE_HAL_CHANNEL_TYPE_FIFO; 1766 attr.dtr_init = NULL; 1767 attr.dtr_term = xgell_tx_term; 1768 attr.userdata = tx_ring; 1769 1770 status = xge_hal_channel_open(lldev->devh, &attr, &tx_ring->channelh, 1771 XGE_HAL_CHANNEL_OC_NORMAL); 1772 if (status != XGE_HAL_OK) { 1773 xge_debug_ll(XGE_ERR, "%s%d: cannot open Tx channel got status " 1774 "code %d", XGELL_IFNAME, lldev->instance, status); 1775 return (B_FALSE); 1776 } 1777 1778 tx_ring->live = B_TRUE; 1779 1780 return (B_TRUE); 1781 } 1782 1783 static void 1784 xgell_tx_ring_close(xgell_tx_ring_t *tx_ring) 1785 { 1786 if (!tx_ring->live) 1787 return; 1788 xge_hal_channel_close(tx_ring->channelh, XGE_HAL_CHANNEL_OC_NORMAL); 1789 tx_ring->live = B_FALSE; 1790 } 1791 1792 /* 1793 * xgell_tx_open 1794 * @lldev: the link layer object 1795 * 1796 * Initialize and open all TX channels. 1797 */ 1798 static boolean_t 1799 xgell_tx_open(xgelldev_t *lldev) 1800 { 1801 xgell_tx_ring_t *tx_ring; 1802 int i; 1803 1804 if (lldev->live_tx_rings != 0) 1805 return (B_TRUE); 1806 1807 lldev->live_tx_rings = 0; 1808 1809 /* 1810 * Enable rings by reserve sequence to match the h/w sequences. 1811 */ 1812 for (i = 0; i < lldev->init_tx_rings; i++) { 1813 tx_ring = &lldev->tx_ring[i]; 1814 tx_ring->index = i; 1815 tx_ring->lldev = lldev; 1816 tx_ring->live = B_FALSE; 1817 1818 if (!xgell_tx_ring_open(tx_ring)) 1819 return (B_FALSE); 1820 1821 lldev->live_tx_rings++; 1822 } 1823 1824 return (B_TRUE); 1825 } 1826 1827 static void 1828 xgell_tx_close(xgelldev_t *lldev) 1829 { 1830 xgell_tx_ring_t *tx_ring; 1831 int i; 1832 1833 if (lldev->live_tx_rings == 0) 1834 return; 1835 1836 /* 1837 * Enable rings by reserve sequence to match the h/w sequences. 1838 */ 1839 for (i = 0; i < lldev->init_tx_rings; i++) { 1840 tx_ring = &lldev->tx_ring[i]; 1841 if (tx_ring->live) { 1842 xgell_tx_ring_close(tx_ring); 1843 lldev->live_tx_rings--; 1844 } 1845 } 1846 } 1847 1848 static int 1849 xgell_initiate_start(xgelldev_t *lldev) 1850 { 1851 xge_hal_status_e status; 1852 xge_hal_device_t *hldev = lldev->devh; 1853 int maxpkt = hldev->config.mtu; 1854 1855 /* check initial mtu before enabling the device */ 1856 status = xge_hal_device_mtu_check(lldev->devh, maxpkt); 1857 if (status != XGE_HAL_OK) { 1858 xge_debug_ll(XGE_ERR, "%s%d: MTU size %d is invalid", 1859 XGELL_IFNAME, lldev->instance, maxpkt); 1860 return (EINVAL); 1861 } 1862 1863 /* set initial mtu before enabling the device */ 1864 status = xge_hal_device_mtu_set(lldev->devh, maxpkt); 1865 if (status != XGE_HAL_OK) { 1866 xge_debug_ll(XGE_ERR, "%s%d: can not set new MTU %d", 1867 XGELL_IFNAME, lldev->instance, maxpkt); 1868 return (EIO); 1869 } 1870 1871 /* tune jumbo/normal frame UFC counters */ 1872 hldev->config.ring.queue[XGELL_RX_RING_MAIN].rti.ufc_b = 1873 (maxpkt > XGE_HAL_DEFAULT_MTU) ? 1874 XGE_HAL_DEFAULT_RX_UFC_B_J : 1875 XGE_HAL_DEFAULT_RX_UFC_B_N; 1876 1877 hldev->config.ring.queue[XGELL_RX_RING_MAIN].rti.ufc_c = 1878 (maxpkt > XGE_HAL_DEFAULT_MTU) ? 1879 XGE_HAL_DEFAULT_RX_UFC_C_J : 1880 XGE_HAL_DEFAULT_RX_UFC_C_N; 1881 1882 /* now, enable the device */ 1883 status = xge_hal_device_enable(lldev->devh); 1884 if (status != XGE_HAL_OK) { 1885 xge_debug_ll(XGE_ERR, "%s%d: can not enable the device", 1886 XGELL_IFNAME, lldev->instance); 1887 return (EIO); 1888 } 1889 1890 if (!xgell_rx_open(lldev)) { 1891 status = xge_hal_device_disable(lldev->devh); 1892 if (status != XGE_HAL_OK) { 1893 u64 adapter_status; 1894 (void) xge_hal_device_status(lldev->devh, 1895 &adapter_status); 1896 xge_debug_ll(XGE_ERR, "%s%d: can not safely disable " 1897 "the device. adaper status 0x%"PRIx64 1898 " returned status %d", 1899 XGELL_IFNAME, lldev->instance, 1900 (uint64_t)adapter_status, status); 1901 } 1902 xgell_rx_close(lldev); 1903 xge_os_mdelay(1500); 1904 return (ENOMEM); 1905 } 1906 1907 if (!xgell_tx_open(lldev)) { 1908 status = xge_hal_device_disable(lldev->devh); 1909 if (status != XGE_HAL_OK) { 1910 u64 adapter_status; 1911 (void) xge_hal_device_status(lldev->devh, 1912 &adapter_status); 1913 xge_debug_ll(XGE_ERR, "%s%d: can not safely disable " 1914 "the device. adaper status 0x%"PRIx64 1915 " returned status %d", 1916 XGELL_IFNAME, lldev->instance, 1917 (uint64_t)adapter_status, status); 1918 } 1919 xgell_tx_close(lldev); 1920 xgell_rx_close(lldev); 1921 xge_os_mdelay(1500); 1922 return (ENOMEM); 1923 } 1924 1925 /* time to enable interrupts */ 1926 (void) xge_enable_intrs(lldev); 1927 xge_hal_device_intr_enable(lldev->devh); 1928 1929 lldev->is_initialized = 1; 1930 1931 return (0); 1932 } 1933 1934 static void 1935 xgell_initiate_stop(xgelldev_t *lldev) 1936 { 1937 xge_hal_status_e status; 1938 1939 lldev->is_initialized = 0; 1940 1941 status = xge_hal_device_disable(lldev->devh); 1942 if (status != XGE_HAL_OK) { 1943 u64 adapter_status; 1944 (void) xge_hal_device_status(lldev->devh, &adapter_status); 1945 xge_debug_ll(XGE_ERR, "%s%d: can not safely disable " 1946 "the device. adaper status 0x%"PRIx64" returned status %d", 1947 XGELL_IFNAME, lldev->instance, 1948 (uint64_t)adapter_status, status); 1949 } 1950 xge_hal_device_intr_disable(lldev->devh); 1951 /* disable OS ISR's */ 1952 xge_disable_intrs(lldev); 1953 1954 xge_debug_ll(XGE_TRACE, "%s", 1955 "waiting for device irq to become quiescent..."); 1956 xge_os_mdelay(1500); 1957 1958 xge_queue_flush(xge_hal_device_queue(lldev->devh)); 1959 1960 xgell_rx_close(lldev); 1961 xgell_tx_close(lldev); 1962 } 1963 1964 /* 1965 * xgell_m_start 1966 * @arg: pointer to device private strucutre(hldev) 1967 * 1968 * This function is called by MAC Layer to enable the XFRAME 1969 * firmware to generate interrupts and also prepare the 1970 * driver to call mac_rx for delivering receive packets 1971 * to MAC Layer. 1972 */ 1973 static int 1974 xgell_m_start(void *arg) 1975 { 1976 xgelldev_t *lldev = arg; 1977 xge_hal_device_t *hldev = lldev->devh; 1978 int ret; 1979 1980 xge_debug_ll(XGE_TRACE, "%s%d: M_START", XGELL_IFNAME, 1981 lldev->instance); 1982 1983 mutex_enter(&lldev->genlock); 1984 1985 if (lldev->is_initialized) { 1986 xge_debug_ll(XGE_ERR, "%s%d: device is already initialized", 1987 XGELL_IFNAME, lldev->instance); 1988 mutex_exit(&lldev->genlock); 1989 return (EINVAL); 1990 } 1991 1992 hldev->terminating = 0; 1993 if (ret = xgell_initiate_start(lldev)) { 1994 mutex_exit(&lldev->genlock); 1995 return (ret); 1996 } 1997 1998 lldev->timeout_id = timeout(xge_device_poll, hldev, XGE_DEV_POLL_TICKS); 1999 2000 mutex_exit(&lldev->genlock); 2001 2002 return (0); 2003 } 2004 2005 /* 2006 * xgell_m_stop 2007 * @arg: pointer to device private data (hldev) 2008 * 2009 * This function is called by the MAC Layer to disable 2010 * the XFRAME firmware for generating any interrupts and 2011 * also stop the driver from calling mac_rx() for 2012 * delivering data packets to the MAC Layer. 2013 */ 2014 static void 2015 xgell_m_stop(void *arg) 2016 { 2017 xgelldev_t *lldev = arg; 2018 xge_hal_device_t *hldev = lldev->devh; 2019 2020 xge_debug_ll(XGE_TRACE, "%s", "MAC_STOP"); 2021 2022 mutex_enter(&lldev->genlock); 2023 if (!lldev->is_initialized) { 2024 xge_debug_ll(XGE_ERR, "%s", "device is not initialized..."); 2025 mutex_exit(&lldev->genlock); 2026 return; 2027 } 2028 2029 xge_hal_device_terminating(hldev); 2030 xgell_initiate_stop(lldev); 2031 2032 /* reset device */ 2033 (void) xge_hal_device_reset(lldev->devh); 2034 2035 mutex_exit(&lldev->genlock); 2036 2037 if (lldev->timeout_id != 0) { 2038 (void) untimeout(lldev->timeout_id); 2039 } 2040 2041 xge_debug_ll(XGE_TRACE, "%s", "returning back to MAC Layer..."); 2042 } 2043 2044 /* 2045 * xgell_onerr_reset 2046 * @lldev: pointer to xgelldev_t structure 2047 * 2048 * This function is called by HAL Event framework to reset the HW 2049 * This function is must be called with genlock taken. 2050 */ 2051 int 2052 xgell_onerr_reset(xgelldev_t *lldev) 2053 { 2054 int rc = 0; 2055 2056 if (!lldev->is_initialized) { 2057 xge_debug_ll(XGE_ERR, "%s%d: can not reset", 2058 XGELL_IFNAME, lldev->instance); 2059 return (rc); 2060 } 2061 2062 lldev->in_reset = 1; 2063 xgell_initiate_stop(lldev); 2064 2065 /* reset device */ 2066 (void) xge_hal_device_reset(lldev->devh); 2067 2068 rc = xgell_initiate_start(lldev); 2069 lldev->in_reset = 0; 2070 2071 return (rc); 2072 } 2073 2074 /* 2075 * xgell_m_multicst 2076 * @arg: pointer to device private strucutre(hldev) 2077 * @add: 2078 * @mc_addr: 2079 * 2080 * This function is called by MAC Layer to enable or 2081 * disable device-level reception of specific multicast addresses. 2082 */ 2083 static int 2084 xgell_m_multicst(void *arg, boolean_t add, const uint8_t *mc_addr) 2085 { 2086 xge_hal_status_e status; 2087 xgelldev_t *lldev = (xgelldev_t *)arg; 2088 xge_hal_device_t *hldev = lldev->devh; 2089 2090 xge_debug_ll(XGE_TRACE, "M_MULTICAST add %d", add); 2091 2092 mutex_enter(&lldev->genlock); 2093 2094 if (!lldev->is_initialized) { 2095 xge_debug_ll(XGE_ERR, "%s%d: can not set multicast", 2096 XGELL_IFNAME, lldev->instance); 2097 mutex_exit(&lldev->genlock); 2098 return (EIO); 2099 } 2100 2101 /* FIXME: missing HAL functionality: enable_one() */ 2102 2103 status = (add) ? 2104 xge_hal_device_mcast_enable(hldev) : 2105 xge_hal_device_mcast_disable(hldev); 2106 2107 if (status != XGE_HAL_OK) { 2108 xge_debug_ll(XGE_ERR, "failed to %s multicast, status %d", 2109 add ? "enable" : "disable", status); 2110 mutex_exit(&lldev->genlock); 2111 return (EIO); 2112 } 2113 2114 mutex_exit(&lldev->genlock); 2115 2116 return (0); 2117 } 2118 2119 2120 /* 2121 * xgell_m_promisc 2122 * @arg: pointer to device private strucutre(hldev) 2123 * @on: 2124 * 2125 * This function is called by MAC Layer to enable or 2126 * disable the reception of all the packets on the medium 2127 */ 2128 static int 2129 xgell_m_promisc(void *arg, boolean_t on) 2130 { 2131 xgelldev_t *lldev = (xgelldev_t *)arg; 2132 xge_hal_device_t *hldev = lldev->devh; 2133 2134 mutex_enter(&lldev->genlock); 2135 2136 xge_debug_ll(XGE_TRACE, "%s", "MAC_PROMISC_SET"); 2137 2138 if (!lldev->is_initialized) { 2139 xge_debug_ll(XGE_ERR, "%s%d: can not set promiscuous", 2140 XGELL_IFNAME, lldev->instance); 2141 mutex_exit(&lldev->genlock); 2142 return (EIO); 2143 } 2144 2145 if (on) { 2146 xge_hal_device_promisc_enable(hldev); 2147 } else { 2148 xge_hal_device_promisc_disable(hldev); 2149 } 2150 2151 mutex_exit(&lldev->genlock); 2152 2153 return (0); 2154 } 2155 2156 /* 2157 * xgell_m_stat 2158 * @arg: pointer to device private strucutre(hldev) 2159 * 2160 * This function is called by MAC Layer to get network statistics 2161 * from the driver. 2162 */ 2163 static int 2164 xgell_m_stat(void *arg, uint_t stat, uint64_t *val) 2165 { 2166 xge_hal_stats_hw_info_t *hw_info; 2167 xgelldev_t *lldev = (xgelldev_t *)arg; 2168 xge_hal_device_t *hldev = lldev->devh; 2169 2170 xge_debug_ll(XGE_TRACE, "%s", "MAC_STATS_GET"); 2171 2172 mutex_enter(&lldev->genlock); 2173 2174 if (!lldev->is_initialized) { 2175 mutex_exit(&lldev->genlock); 2176 return (EAGAIN); 2177 } 2178 2179 if (xge_hal_stats_hw(hldev, &hw_info) != XGE_HAL_OK) { 2180 mutex_exit(&lldev->genlock); 2181 return (EAGAIN); 2182 } 2183 2184 switch (stat) { 2185 case MAC_STAT_IFSPEED: 2186 *val = 10000000000ull; /* 10G */ 2187 break; 2188 2189 case MAC_STAT_MULTIRCV: 2190 *val = ((u64) hw_info->rmac_vld_mcst_frms_oflow << 32) | 2191 hw_info->rmac_vld_mcst_frms; 2192 break; 2193 2194 case MAC_STAT_BRDCSTRCV: 2195 *val = ((u64) hw_info->rmac_vld_bcst_frms_oflow << 32) | 2196 hw_info->rmac_vld_bcst_frms; 2197 break; 2198 2199 case MAC_STAT_MULTIXMT: 2200 *val = ((u64) hw_info->tmac_mcst_frms_oflow << 32) | 2201 hw_info->tmac_mcst_frms; 2202 break; 2203 2204 case MAC_STAT_BRDCSTXMT: 2205 *val = ((u64) hw_info->tmac_bcst_frms_oflow << 32) | 2206 hw_info->tmac_bcst_frms; 2207 break; 2208 2209 case MAC_STAT_RBYTES: 2210 *val = ((u64) hw_info->rmac_ttl_octets_oflow << 32) | 2211 hw_info->rmac_ttl_octets; 2212 break; 2213 2214 case MAC_STAT_NORCVBUF: 2215 *val = hw_info->rmac_drop_frms; 2216 break; 2217 2218 case MAC_STAT_IERRORS: 2219 *val = ((u64) hw_info->rmac_discarded_frms_oflow << 32) | 2220 hw_info->rmac_discarded_frms; 2221 break; 2222 2223 case MAC_STAT_OBYTES: 2224 *val = ((u64) hw_info->tmac_ttl_octets_oflow << 32) | 2225 hw_info->tmac_ttl_octets; 2226 break; 2227 2228 case MAC_STAT_NOXMTBUF: 2229 *val = hw_info->tmac_drop_frms; 2230 break; 2231 2232 case MAC_STAT_OERRORS: 2233 *val = ((u64) hw_info->tmac_any_err_frms_oflow << 32) | 2234 hw_info->tmac_any_err_frms; 2235 break; 2236 2237 case MAC_STAT_IPACKETS: 2238 *val = ((u64) hw_info->rmac_vld_frms_oflow << 32) | 2239 hw_info->rmac_vld_frms; 2240 break; 2241 2242 case MAC_STAT_OPACKETS: 2243 *val = ((u64) hw_info->tmac_frms_oflow << 32) | 2244 hw_info->tmac_frms; 2245 break; 2246 2247 case ETHER_STAT_FCS_ERRORS: 2248 *val = hw_info->rmac_fcs_err_frms; 2249 break; 2250 2251 case ETHER_STAT_TOOLONG_ERRORS: 2252 *val = hw_info->rmac_long_frms; 2253 break; 2254 2255 case ETHER_STAT_LINK_DUPLEX: 2256 *val = LINK_DUPLEX_FULL; 2257 break; 2258 2259 default: 2260 mutex_exit(&lldev->genlock); 2261 return (ENOTSUP); 2262 } 2263 2264 mutex_exit(&lldev->genlock); 2265 2266 return (0); 2267 } 2268 2269 /* 2270 * Retrieve a value for one of the statistics for a particular rx ring 2271 */ 2272 int 2273 xgell_rx_ring_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val) 2274 { 2275 xgell_rx_ring_t *rx_ring = (xgell_rx_ring_t *)rh; 2276 2277 switch (stat) { 2278 case MAC_STAT_RBYTES: 2279 *val = rx_ring->rx_bytes; 2280 break; 2281 2282 case MAC_STAT_IPACKETS: 2283 *val = rx_ring->rx_pkts; 2284 break; 2285 2286 default: 2287 *val = 0; 2288 return (ENOTSUP); 2289 } 2290 2291 return (0); 2292 } 2293 2294 /* 2295 * Retrieve a value for one of the statistics for a particular tx ring 2296 */ 2297 int 2298 xgell_tx_ring_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val) 2299 { 2300 xgell_tx_ring_t *tx_ring = (xgell_tx_ring_t *)rh; 2301 2302 switch (stat) { 2303 case MAC_STAT_OBYTES: 2304 *val = tx_ring->tx_bytes; 2305 break; 2306 2307 case MAC_STAT_OPACKETS: 2308 *val = tx_ring->tx_pkts; 2309 break; 2310 2311 default: 2312 *val = 0; 2313 return (ENOTSUP); 2314 } 2315 2316 return (0); 2317 } 2318 2319 /* 2320 * xgell_device_alloc - Allocate new LL device 2321 */ 2322 int 2323 xgell_device_alloc(xge_hal_device_h devh, 2324 dev_info_t *dev_info, xgelldev_t **lldev_out) 2325 { 2326 xgelldev_t *lldev; 2327 xge_hal_device_t *hldev = (xge_hal_device_t *)devh; 2328 int instance = ddi_get_instance(dev_info); 2329 2330 *lldev_out = NULL; 2331 2332 xge_debug_ll(XGE_TRACE, "trying to register etherenet device %s%d...", 2333 XGELL_IFNAME, instance); 2334 2335 lldev = kmem_zalloc(sizeof (xgelldev_t), KM_SLEEP); 2336 2337 lldev->devh = hldev; 2338 lldev->instance = instance; 2339 lldev->dev_info = dev_info; 2340 2341 *lldev_out = lldev; 2342 2343 ddi_set_driver_private(dev_info, (caddr_t)hldev); 2344 2345 return (DDI_SUCCESS); 2346 } 2347 2348 /* 2349 * xgell_device_free 2350 */ 2351 void 2352 xgell_device_free(xgelldev_t *lldev) 2353 { 2354 xge_debug_ll(XGE_TRACE, "freeing device %s%d", 2355 XGELL_IFNAME, lldev->instance); 2356 2357 kmem_free(lldev, sizeof (xgelldev_t)); 2358 } 2359 2360 /* 2361 * xgell_ioctl 2362 */ 2363 static void 2364 xgell_m_ioctl(void *arg, queue_t *wq, mblk_t *mp) 2365 { 2366 xgelldev_t *lldev = arg; 2367 struct iocblk *iocp; 2368 int err = 0; 2369 int cmd; 2370 int need_privilege = 1; 2371 int ret = 0; 2372 2373 2374 iocp = (struct iocblk *)mp->b_rptr; 2375 iocp->ioc_error = 0; 2376 cmd = iocp->ioc_cmd; 2377 xge_debug_ll(XGE_TRACE, "MAC_IOCTL cmd 0x%x", cmd); 2378 switch (cmd) { 2379 case ND_GET: 2380 need_privilege = 0; 2381 /* FALLTHRU */ 2382 case ND_SET: 2383 break; 2384 default: 2385 xge_debug_ll(XGE_TRACE, "unknown cmd 0x%x", cmd); 2386 miocnak(wq, mp, 0, EINVAL); 2387 return; 2388 } 2389 2390 if (need_privilege) { 2391 err = secpolicy_net_config(iocp->ioc_cr, B_FALSE); 2392 if (err != 0) { 2393 xge_debug_ll(XGE_ERR, 2394 "drv_priv(): rejected cmd 0x%x, err %d", 2395 cmd, err); 2396 miocnak(wq, mp, 0, err); 2397 return; 2398 } 2399 } 2400 2401 switch (cmd) { 2402 case ND_GET: 2403 /* 2404 * If nd_getset() returns B_FALSE, the command was 2405 * not valid (e.g. unknown name), so we just tell the 2406 * top-level ioctl code to send a NAK (with code EINVAL). 2407 * 2408 * Otherwise, nd_getset() will have built the reply to 2409 * be sent (but not actually sent it), so we tell the 2410 * caller to send the prepared reply. 2411 */ 2412 ret = nd_getset(wq, lldev->ndp, mp); 2413 xge_debug_ll(XGE_TRACE, "%s", "got ndd get ioctl"); 2414 break; 2415 2416 case ND_SET: 2417 ret = nd_getset(wq, lldev->ndp, mp); 2418 xge_debug_ll(XGE_TRACE, "%s", "got ndd set ioctl"); 2419 break; 2420 2421 default: 2422 break; 2423 } 2424 2425 if (ret == B_FALSE) { 2426 xge_debug_ll(XGE_ERR, 2427 "nd_getset(): rejected cmd 0x%x, err %d", 2428 cmd, err); 2429 miocnak(wq, mp, 0, EINVAL); 2430 } else { 2431 mp->b_datap->db_type = iocp->ioc_error == 0 ? 2432 M_IOCACK : M_IOCNAK; 2433 qreply(wq, mp); 2434 } 2435 } 2436 2437 2438 static boolean_t 2439 xgell_m_getcapab(void *arg, mac_capab_t cap, void *cap_data) 2440 { 2441 xgelldev_t *lldev = arg; 2442 2443 xge_debug_ll(XGE_TRACE, "xgell_m_getcapab: %x", cap); 2444 2445 switch (cap) { 2446 case MAC_CAPAB_HCKSUM: { 2447 uint32_t *hcksum_txflags = cap_data; 2448 *hcksum_txflags = HCKSUM_INET_FULL_V4 | HCKSUM_INET_FULL_V6 | 2449 HCKSUM_IPHDRCKSUM; 2450 break; 2451 } 2452 case MAC_CAPAB_LSO: { 2453 mac_capab_lso_t *cap_lso = cap_data; 2454 2455 if (lldev->config.lso_enable) { 2456 cap_lso->lso_flags = LSO_TX_BASIC_TCP_IPV4; 2457 cap_lso->lso_basic_tcp_ipv4.lso_max = XGELL_LSO_MAXLEN; 2458 break; 2459 } else { 2460 return (B_FALSE); 2461 } 2462 } 2463 case MAC_CAPAB_RINGS: { 2464 mac_capab_rings_t *cap_rings = cap_data; 2465 2466 switch (cap_rings->mr_type) { 2467 case MAC_RING_TYPE_RX: 2468 cap_rings->mr_group_type = MAC_GROUP_TYPE_STATIC; 2469 cap_rings->mr_rnum = lldev->init_rx_rings; 2470 cap_rings->mr_gnum = lldev->init_rx_groups; 2471 cap_rings->mr_rget = xgell_fill_ring; 2472 cap_rings->mr_gget = xgell_fill_group; 2473 break; 2474 case MAC_RING_TYPE_TX: 2475 cap_rings->mr_group_type = MAC_GROUP_TYPE_STATIC; 2476 cap_rings->mr_rnum = lldev->init_tx_rings; 2477 cap_rings->mr_gnum = 0; 2478 cap_rings->mr_rget = xgell_fill_ring; 2479 cap_rings->mr_gget = NULL; 2480 break; 2481 default: 2482 break; 2483 } 2484 break; 2485 } 2486 default: 2487 return (B_FALSE); 2488 } 2489 return (B_TRUE); 2490 } 2491 2492 static int 2493 xgell_stats_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) 2494 { 2495 xgelldev_t *lldev = (xgelldev_t *)cp; 2496 xge_hal_status_e status; 2497 int count = 0, retsize; 2498 char *buf; 2499 2500 buf = kmem_alloc(XGELL_STATS_BUFSIZE, KM_SLEEP); 2501 if (buf == NULL) { 2502 return (ENOSPC); 2503 } 2504 2505 status = xge_hal_aux_stats_tmac_read(lldev->devh, XGELL_STATS_BUFSIZE, 2506 buf, &retsize); 2507 if (status != XGE_HAL_OK) { 2508 kmem_free(buf, XGELL_STATS_BUFSIZE); 2509 xge_debug_ll(XGE_ERR, "tmac_read(): status %d", status); 2510 return (EINVAL); 2511 } 2512 count += retsize; 2513 2514 status = xge_hal_aux_stats_rmac_read(lldev->devh, 2515 XGELL_STATS_BUFSIZE - count, 2516 buf+count, &retsize); 2517 if (status != XGE_HAL_OK) { 2518 kmem_free(buf, XGELL_STATS_BUFSIZE); 2519 xge_debug_ll(XGE_ERR, "rmac_read(): status %d", status); 2520 return (EINVAL); 2521 } 2522 count += retsize; 2523 2524 status = xge_hal_aux_stats_pci_read(lldev->devh, 2525 XGELL_STATS_BUFSIZE - count, buf + count, &retsize); 2526 if (status != XGE_HAL_OK) { 2527 kmem_free(buf, XGELL_STATS_BUFSIZE); 2528 xge_debug_ll(XGE_ERR, "pci_read(): status %d", status); 2529 return (EINVAL); 2530 } 2531 count += retsize; 2532 2533 status = xge_hal_aux_stats_sw_dev_read(lldev->devh, 2534 XGELL_STATS_BUFSIZE - count, buf + count, &retsize); 2535 if (status != XGE_HAL_OK) { 2536 kmem_free(buf, XGELL_STATS_BUFSIZE); 2537 xge_debug_ll(XGE_ERR, "sw_dev_read(): status %d", status); 2538 return (EINVAL); 2539 } 2540 count += retsize; 2541 2542 status = xge_hal_aux_stats_hal_read(lldev->devh, 2543 XGELL_STATS_BUFSIZE - count, buf + count, &retsize); 2544 if (status != XGE_HAL_OK) { 2545 kmem_free(buf, XGELL_STATS_BUFSIZE); 2546 xge_debug_ll(XGE_ERR, "pci_read(): status %d", status); 2547 return (EINVAL); 2548 } 2549 count += retsize; 2550 2551 *(buf + count - 1) = '\0'; /* remove last '\n' */ 2552 (void) mi_mpprintf(mp, "%s", buf); 2553 kmem_free(buf, XGELL_STATS_BUFSIZE); 2554 2555 return (0); 2556 } 2557 2558 static int 2559 xgell_pciconf_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) 2560 { 2561 xgelldev_t *lldev = (xgelldev_t *)cp; 2562 xge_hal_status_e status; 2563 int retsize; 2564 char *buf; 2565 2566 buf = kmem_alloc(XGELL_PCICONF_BUFSIZE, KM_SLEEP); 2567 if (buf == NULL) { 2568 return (ENOSPC); 2569 } 2570 status = xge_hal_aux_pci_config_read(lldev->devh, XGELL_PCICONF_BUFSIZE, 2571 buf, &retsize); 2572 if (status != XGE_HAL_OK) { 2573 kmem_free(buf, XGELL_PCICONF_BUFSIZE); 2574 xge_debug_ll(XGE_ERR, "pci_config_read(): status %d", status); 2575 return (EINVAL); 2576 } 2577 *(buf + retsize - 1) = '\0'; /* remove last '\n' */ 2578 (void) mi_mpprintf(mp, "%s", buf); 2579 kmem_free(buf, XGELL_PCICONF_BUFSIZE); 2580 2581 return (0); 2582 } 2583 2584 static int 2585 xgell_about_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) 2586 { 2587 xgelldev_t *lldev = (xgelldev_t *)cp; 2588 xge_hal_status_e status; 2589 int retsize; 2590 char *buf; 2591 2592 buf = kmem_alloc(XGELL_ABOUT_BUFSIZE, KM_SLEEP); 2593 if (buf == NULL) { 2594 return (ENOSPC); 2595 } 2596 status = xge_hal_aux_about_read(lldev->devh, XGELL_ABOUT_BUFSIZE, 2597 buf, &retsize); 2598 if (status != XGE_HAL_OK) { 2599 kmem_free(buf, XGELL_ABOUT_BUFSIZE); 2600 xge_debug_ll(XGE_ERR, "about_read(): status %d", status); 2601 return (EINVAL); 2602 } 2603 *(buf + retsize - 1) = '\0'; /* remove last '\n' */ 2604 (void) mi_mpprintf(mp, "%s", buf); 2605 kmem_free(buf, XGELL_ABOUT_BUFSIZE); 2606 2607 return (0); 2608 } 2609 2610 static unsigned long bar0_offset = 0x110; /* adapter_control */ 2611 2612 static int 2613 xgell_bar0_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) 2614 { 2615 xgelldev_t *lldev = (xgelldev_t *)cp; 2616 xge_hal_status_e status; 2617 int retsize; 2618 char *buf; 2619 2620 buf = kmem_alloc(XGELL_IOCTL_BUFSIZE, KM_SLEEP); 2621 if (buf == NULL) { 2622 return (ENOSPC); 2623 } 2624 status = xge_hal_aux_bar0_read(lldev->devh, bar0_offset, 2625 XGELL_IOCTL_BUFSIZE, buf, &retsize); 2626 if (status != XGE_HAL_OK) { 2627 kmem_free(buf, XGELL_IOCTL_BUFSIZE); 2628 xge_debug_ll(XGE_ERR, "bar0_read(): status %d", status); 2629 return (EINVAL); 2630 } 2631 *(buf + retsize - 1) = '\0'; /* remove last '\n' */ 2632 (void) mi_mpprintf(mp, "%s", buf); 2633 kmem_free(buf, XGELL_IOCTL_BUFSIZE); 2634 2635 return (0); 2636 } 2637 2638 static int 2639 xgell_bar0_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, cred_t *credp) 2640 { 2641 unsigned long old_offset = bar0_offset; 2642 char *end; 2643 2644 if (value && *value == '0' && 2645 (*(value + 1) == 'x' || *(value + 1) == 'X')) { 2646 value += 2; 2647 } 2648 2649 bar0_offset = mi_strtol(value, &end, 16); 2650 if (end == value) { 2651 bar0_offset = old_offset; 2652 return (EINVAL); 2653 } 2654 2655 xge_debug_ll(XGE_TRACE, "bar0: new value %s:%lX", value, bar0_offset); 2656 2657 return (0); 2658 } 2659 2660 static int 2661 xgell_debug_level_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) 2662 { 2663 char *buf; 2664 2665 buf = kmem_alloc(XGELL_IOCTL_BUFSIZE, KM_SLEEP); 2666 if (buf == NULL) { 2667 return (ENOSPC); 2668 } 2669 (void) mi_mpprintf(mp, "debug_level %d", xge_hal_driver_debug_level()); 2670 kmem_free(buf, XGELL_IOCTL_BUFSIZE); 2671 2672 return (0); 2673 } 2674 2675 static int 2676 xgell_debug_level_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, 2677 cred_t *credp) 2678 { 2679 int level; 2680 char *end; 2681 2682 level = mi_strtol(value, &end, 10); 2683 if (level < XGE_NONE || level > XGE_ERR || end == value) { 2684 return (EINVAL); 2685 } 2686 2687 xge_hal_driver_debug_level_set(level); 2688 2689 return (0); 2690 } 2691 2692 static int 2693 xgell_debug_module_mask_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) 2694 { 2695 char *buf; 2696 2697 buf = kmem_alloc(XGELL_IOCTL_BUFSIZE, KM_SLEEP); 2698 if (buf == NULL) { 2699 return (ENOSPC); 2700 } 2701 (void) mi_mpprintf(mp, "debug_module_mask 0x%08x", 2702 xge_hal_driver_debug_module_mask()); 2703 kmem_free(buf, XGELL_IOCTL_BUFSIZE); 2704 2705 return (0); 2706 } 2707 2708 static int 2709 xgell_debug_module_mask_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, 2710 cred_t *credp) 2711 { 2712 u32 mask; 2713 char *end; 2714 2715 if (value && *value == '0' && 2716 (*(value + 1) == 'x' || *(value + 1) == 'X')) { 2717 value += 2; 2718 } 2719 2720 mask = mi_strtol(value, &end, 16); 2721 if (end == value) { 2722 return (EINVAL); 2723 } 2724 2725 xge_hal_driver_debug_module_mask_set(mask); 2726 2727 return (0); 2728 } 2729 2730 static int 2731 xgell_devconfig_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *credp) 2732 { 2733 xgelldev_t *lldev = (xgelldev_t *)(void *)cp; 2734 xge_hal_status_e status; 2735 int retsize; 2736 char *buf; 2737 2738 buf = kmem_alloc(XGELL_DEVCONF_BUFSIZE, KM_SLEEP); 2739 if (buf == NULL) { 2740 return (ENOSPC); 2741 } 2742 status = xge_hal_aux_device_config_read(lldev->devh, 2743 XGELL_DEVCONF_BUFSIZE, buf, &retsize); 2744 if (status != XGE_HAL_OK) { 2745 kmem_free(buf, XGELL_DEVCONF_BUFSIZE); 2746 xge_debug_ll(XGE_ERR, "device_config_read(): status %d", 2747 status); 2748 return (EINVAL); 2749 } 2750 *(buf + retsize - 1) = '\0'; /* remove last '\n' */ 2751 (void) mi_mpprintf(mp, "%s", buf); 2752 kmem_free(buf, XGELL_DEVCONF_BUFSIZE); 2753 2754 return (0); 2755 } 2756 2757 /* 2758 * xgell_device_register 2759 * @devh: pointer on HAL device 2760 * @config: pointer on this network device configuration 2761 * @ll_out: output pointer. Will be assigned to valid LL device. 2762 * 2763 * This function will allocate and register network device 2764 */ 2765 int 2766 xgell_device_register(xgelldev_t *lldev, xgell_config_t *config) 2767 { 2768 mac_register_t *macp = NULL; 2769 xge_hal_device_t *hldev = (xge_hal_device_t *)lldev->devh; 2770 2771 /* 2772 * Initialize some NDD interface for internal debug. 2773 */ 2774 if (nd_load(&lldev->ndp, "pciconf", xgell_pciconf_get, NULL, 2775 (caddr_t)lldev) == B_FALSE) 2776 goto xgell_ndd_fail; 2777 2778 if (nd_load(&lldev->ndp, "about", xgell_about_get, NULL, 2779 (caddr_t)lldev) == B_FALSE) 2780 goto xgell_ndd_fail; 2781 2782 if (nd_load(&lldev->ndp, "stats", xgell_stats_get, NULL, 2783 (caddr_t)lldev) == B_FALSE) 2784 goto xgell_ndd_fail; 2785 2786 if (nd_load(&lldev->ndp, "bar0", xgell_bar0_get, xgell_bar0_set, 2787 (caddr_t)lldev) == B_FALSE) 2788 goto xgell_ndd_fail; 2789 2790 if (nd_load(&lldev->ndp, "debug_level", xgell_debug_level_get, 2791 xgell_debug_level_set, (caddr_t)lldev) == B_FALSE) 2792 goto xgell_ndd_fail; 2793 2794 if (nd_load(&lldev->ndp, "debug_module_mask", 2795 xgell_debug_module_mask_get, xgell_debug_module_mask_set, 2796 (caddr_t)lldev) == B_FALSE) 2797 goto xgell_ndd_fail; 2798 2799 if (nd_load(&lldev->ndp, "devconfig", xgell_devconfig_get, NULL, 2800 (caddr_t)lldev) == B_FALSE) 2801 goto xgell_ndd_fail; 2802 2803 bcopy(config, &lldev->config, sizeof (xgell_config_t)); 2804 2805 mutex_init(&lldev->genlock, NULL, MUTEX_DRIVER, 2806 DDI_INTR_PRI(hldev->irqh)); 2807 2808 if ((macp = mac_alloc(MAC_VERSION)) == NULL) 2809 goto xgell_register_fail; 2810 macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER; 2811 macp->m_driver = lldev; 2812 macp->m_dip = lldev->dev_info; 2813 macp->m_src_addr = hldev->macaddr[0]; 2814 macp->m_callbacks = &xgell_m_callbacks; 2815 macp->m_min_sdu = 0; 2816 macp->m_max_sdu = hldev->config.mtu; 2817 macp->m_margin = VLAN_TAGSZ; 2818 macp->m_v12n = MAC_VIRT_LEVEL1; 2819 2820 /* 2821 * MAC Registration. 2822 */ 2823 if (mac_register(macp, &lldev->mh) != 0) 2824 goto xgell_register_fail; 2825 2826 /* Always free the macp after register */ 2827 if (macp != NULL) 2828 mac_free(macp); 2829 2830 /* Calculate tx_copied_max here ??? */ 2831 lldev->tx_copied_max = hldev->config.fifo.max_frags * 2832 hldev->config.fifo.alignment_size * 2833 hldev->config.fifo.max_aligned_frags; 2834 2835 xge_debug_ll(XGE_TRACE, "etherenet device %s%d registered", 2836 XGELL_IFNAME, lldev->instance); 2837 2838 return (DDI_SUCCESS); 2839 2840 xgell_ndd_fail: 2841 nd_free(&lldev->ndp); 2842 xge_debug_ll(XGE_ERR, "%s", "unable to load ndd parameter"); 2843 return (DDI_FAILURE); 2844 2845 xgell_register_fail: 2846 if (macp != NULL) 2847 mac_free(macp); 2848 nd_free(&lldev->ndp); 2849 mutex_destroy(&lldev->genlock); 2850 xge_debug_ll(XGE_ERR, "%s", "unable to register networking device"); 2851 return (DDI_FAILURE); 2852 } 2853 2854 /* 2855 * xgell_device_unregister 2856 * @devh: pointer on HAL device 2857 * @lldev: pointer to valid LL device. 2858 * 2859 * This function will unregister and free network device 2860 */ 2861 int 2862 xgell_device_unregister(xgelldev_t *lldev) 2863 { 2864 if (mac_unregister(lldev->mh) != 0) { 2865 xge_debug_ll(XGE_ERR, "unable to unregister device %s%d", 2866 XGELL_IFNAME, lldev->instance); 2867 return (DDI_FAILURE); 2868 } 2869 2870 mutex_destroy(&lldev->genlock); 2871 2872 nd_free(&lldev->ndp); 2873 2874 xge_debug_ll(XGE_TRACE, "etherenet device %s%d unregistered", 2875 XGELL_IFNAME, lldev->instance); 2876 2877 return (DDI_SUCCESS); 2878 } 2879