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 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * This file defines interfaces between fcoe and its clients (FCoEI/FCoET) 29 */ 30 31 #include <sys/ddi.h> 32 #include <sys/sunddi.h> 33 #include <sys/sunndi.h> 34 #include <sys/byteorder.h> 35 #include <sys/atomic.h> 36 #include <sys/sysmacros.h> 37 #include <sys/cmn_err.h> 38 #include <sys/crc32.h> 39 #include <sys/fcntl.h> 40 #include <sys/unistd.h> 41 #include <sys/mac_client.h> 42 43 /* 44 * FCoE header files 45 */ 46 #include <sys/fcoe/fcoeio.h> 47 #include <sys/fcoe/fcoe_common.h> 48 49 /* 50 * Driver's own header files 51 */ 52 #include <fcoe.h> 53 #include <fcoe_fc.h> 54 #include <fcoe_eth.h> 55 56 static void fcoe_fill_frame_headers(fcoe_frame_t *frm); 57 static void fcoe_fill_frame_tailers(fcoe_frame_t *frm); 58 static void fcoe_deregister_client(fcoe_port_t *eport); 59 static int fcoe_ctl(fcoe_port_t *eport, int cmd, void *arg); 60 static void fcoe_tx_frame(fcoe_frame_t *frm); 61 static void *fcoe_alloc_netb(fcoe_port_t *eport, 62 uint32_t fc_frame_size, uint8_t **ppfc); 63 static void fcoe_free_netb(void *netb); 64 65 /* 66 * Only this function will be called explicitly by clients 67 * Register the specified client port (fcoei/fcoet) 68 */ 69 fcoe_port_t * 70 fcoe_register_client(fcoe_client_t *client) 71 { 72 fcoe_mac_t *mac; 73 fcoe_port_t *eport; 74 75 if (client->ect_fcoe_ver != fcoe_ver_now) { 76 cmn_err(CE_WARN, "FCoE modules version mismatch, " 77 "fail registering client."); 78 return (NULL); 79 } 80 81 /* 82 * We will not come here, when someone is changing ss_mac_list, 83 * so it's safe to go through ss_mac_list. 84 */ 85 for (mac = list_head(&fcoe_global_ss->ss_mac_list); mac; 86 mac = list_next(&fcoe_global_ss->ss_mac_list, mac)) { 87 if (client->ect_channelid == mac->fm_linkid) { 88 break; 89 } 90 } 91 92 if (mac == NULL) { 93 FCOE_LOG(0, "can't find the MAC you want to bind"); 94 return (NULL); 95 } 96 97 if (mac->fm_flags & FCOE_MAC_FLAG_BOUND) { 98 FCOE_LOG(0, "the MAC you want to bind is bound already"); 99 return (NULL); 100 } 101 102 atomic_or_32(&mac->fm_flags, FCOE_MAC_FLAG_BOUND); 103 bcopy(client, &mac->fm_client, sizeof (fcoe_client_t)); 104 105 /* 106 * fcoe_port_t initialization 107 */ 108 eport = &mac->fm_eport; 109 eport->eport_flags = client->ect_eport_flags | EPORT_FLAG_MAC_IN_USE; 110 eport->eport_fcoe_private = mac; 111 eport->eport_client_private = client->ect_client_port_struct; 112 eport->eport_max_fc_frame_size = 2136; 113 eport->eport_tx_frame = fcoe_tx_frame; 114 eport->eport_alloc_frame = fcoe_allocate_frame; 115 eport->eport_release_frame = fcoe_release_frame; 116 eport->eport_alloc_netb = fcoe_alloc_netb; 117 eport->eport_free_netb = fcoe_free_netb; 118 eport->eport_deregister_client = fcoe_deregister_client; 119 eport->eport_ctl = fcoe_ctl; 120 eport->eport_set_mac_address = fcoe_mac_set_address; 121 122 return (eport); 123 } 124 125 /* 126 * The following routines will be called through vectors in fcoe_port_t 127 */ 128 129 /* 130 * Deregister fcoet/fcoei modules, client should make sure the port is in 131 * offline status already 132 */ 133 static void 134 fcoe_deregister_client(fcoe_port_t *eport) 135 { 136 fcoe_mac_t *mac = EPORT2MAC(eport); 137 138 /* 139 * Wait for all the related frame to be freed, this should be fast 140 * because before deregister fcoei/fcoet will make sure its port 141 * is already in offline status so no frame will be received or sent 142 * any more 143 */ 144 while (mac->fm_frm_cnt > 0) { 145 delay(10); 146 } 147 148 atomic_and_32(&EPORT2MAC(eport)->fm_flags, ~FCOE_MAC_FLAG_BOUND); 149 atomic_and_32(&mac->fm_eport.eport_flags, ~EPORT_FLAG_MAC_IN_USE); 150 if (!(EPORT2MAC(eport)->fm_flags & FCOE_MAC_FLAG_USER_DEL)) { 151 (void) fcoe_close_mac(mac); 152 fcoe_destroy_mac(mac); 153 } 154 } 155 156 /* ARGSUSED */ 157 static int 158 fcoe_ctl(fcoe_port_t *eport, int cmd, void *arg) 159 { 160 fcoe_mac_t *mac = EPORT2MAC(eport); 161 162 switch (cmd) { 163 case FCOE_CMD_PORT_ONLINE: 164 /* 165 * client ask us to online, so it's safe to post event 166 * and data up 167 */ 168 if (fcoe_enable_callback(mac) == FCOE_FAILURE) { 169 return (FCOE_FAILURE); 170 } 171 mac->fm_state = FCOE_MAC_STATE_ONLINE; 172 if (mac->fm_link_state == FCOE_MAC_LINK_STATE_UP) 173 (void) ddi_taskq_dispatch( 174 fcoe_global_ss->ss_watchdog_taskq, 175 fcoe_mac_notify_link_up, mac, DDI_SLEEP); 176 break; 177 case FCOE_CMD_PORT_OFFLINE: 178 if (fcoe_disable_callback(mac) == FCOE_FAILURE) { 179 return (FCOE_FAILURE); 180 } 181 mac->fm_state = FCOE_MAC_STATE_OFFLINE; 182 // in case there are threads waiting 183 mutex_enter(&mac->fm_mutex); 184 cv_broadcast(&mac->fm_tx_cv); 185 mutex_exit(&mac->fm_mutex); 186 break; 187 default: 188 FCOE_LOG("fcoe", "fcoe_ctl, unsupported cmd %x", cmd); 189 break; 190 } 191 192 return (FCOE_SUCCESS); 193 } 194 195 /* 196 * Transmit the specified frame to the link 197 */ 198 static void 199 fcoe_tx_frame(fcoe_frame_t *frm) 200 { 201 mblk_t *ret_mblk = NULL; 202 fcoe_mac_t *mac = FRM2MAC(frm); 203 mac_tx_cookie_t ret_cookie; 204 205 fcoe_fill_frame_headers(frm); 206 fcoe_fill_frame_tailers(frm); 207 208 tx_frame: 209 ret_cookie = mac_tx(mac->fm_cli_handle, FRM2MBLK(frm), 0, 210 MAC_TX_NO_ENQUEUE, &ret_mblk); 211 if (ret_cookie != NULL) { 212 mutex_enter(&mac->fm_mutex); 213 (void) cv_reltimedwait(&mac->fm_tx_cv, &mac->fm_mutex, 214 drv_usectohz(100000), TR_CLOCK_TICK); 215 mutex_exit(&mac->fm_mutex); 216 217 if (mac->fm_state == FCOE_MAC_STATE_OFFLINE) { 218 /* 219 * we are doing offline, so just tell the upper that 220 * this is finished, the cmd will be aborted soon. 221 */ 222 fcoe_free_netb(ret_mblk); 223 } else { 224 goto tx_frame; 225 } 226 } 227 228 /* 229 * MAC driver will release the mblk of the frame 230 * We need only release the frame itself 231 */ 232 mutex_enter(&FRM2MAC(frm)->fm_ss->ss_watch_mutex); 233 list_insert_tail(&FRM2MAC(frm)->fm_ss->ss_pfrm_list, 234 FRM2FMI(frm)); 235 mac->fm_frm_cnt ++; 236 if (FRM2MAC(frm)->fm_ss->ss_flags & SS_FLAG_DOG_WAITING) { 237 cv_signal(&FRM2MAC(frm)->fm_ss->ss_watch_cv); 238 } 239 mutex_exit(&FRM2MAC(frm)->fm_ss->ss_watch_mutex); 240 } 241 242 /* 243 * Consider cache allocation in the future 244 */ 245 void 246 fcoe_release_frame(fcoe_frame_t *frame) 247 { 248 kmem_free(frame, frame->frm_alloc_size); 249 } 250 251 static void * 252 fcoe_alloc_netb(fcoe_port_t *eport, uint32_t fc_frame_size, uint8_t **ppfc) 253 { 254 mblk_t *mp; 255 256 mp = fcoe_get_mblk(eport->eport_fcoe_private, 257 fc_frame_size + PADDING_SIZE); 258 if (mp != NULL) { 259 *ppfc = mp->b_rptr + PADDING_HEADER_SIZE; 260 } 261 262 return (mp); 263 } 264 265 static void 266 fcoe_free_netb(void *netb) 267 { 268 freeb((mblk_t *)netb); 269 } 270 271 fcoe_frame_t * 272 fcoe_allocate_frame(fcoe_port_t *eport, uint32_t fc_frame_size, void *xmp) 273 { 274 fcoe_frame_t *frm; 275 fcoe_i_frame_t *fmi; 276 mblk_t *mp = xmp; 277 uint32_t alloc_size; 278 uint32_t raw_frame_size; 279 280 if (fc_frame_size > 2136) { 281 FCOE_LOG("fcoe", "fcoe_allocate_frame %d > 2136", 282 fc_frame_size); 283 return (NULL); 284 } 285 286 if (mp == NULL) { 287 /* 288 * We are allocating solicited frame now 289 */ 290 raw_frame_size = PADDING_SIZE + fc_frame_size; 291 mp = fcoe_get_mblk(EPORT2MAC(eport), raw_frame_size); 292 if (mp == NULL) { 293 return (NULL); 294 } 295 } 296 297 alloc_size = sizeof (fcoe_frame_t) + sizeof (fcoe_i_frame_t) + 298 EPORT2MAC(eport)->fm_client.ect_private_frame_struct_size; 299 300 /* 301 * fcoe_frame_t initialization 302 */ 303 frm = (fcoe_frame_t *)kmem_alloc(alloc_size, KM_SLEEP); 304 frm->frm_alloc_size = alloc_size; 305 frm->frm_fc_frame_size = fc_frame_size; 306 frm->frm_payload_size = fc_frame_size - 307 sizeof (fcoe_fc_frame_header_t); 308 frm->frm_fcoe_private = sizeof (fcoe_frame_t) + (uint8_t *)frm; 309 frm->frm_client_private = sizeof (fcoe_i_frame_t) + 310 (uint8_t *)frm->frm_fcoe_private; 311 frm->frm_flags = 0; 312 frm->frm_eport = eport; 313 frm->frm_netb = mp; 314 315 /* 316 * fcoe_i_frame_t initialization 317 */ 318 fmi = FRM2FMI(frm); 319 fmi->fmi_frame = frm; 320 fmi->fmi_mac = EPORT2MAC(eport); 321 fmi->fmi_efh = (void *)mp->b_rptr; 322 323 fmi->fmi_ffh = (fcoe_frame_header_t *) 324 (sizeof (struct ether_header) + (uint8_t *)fmi->fmi_efh); 325 326 fmi->fmi_fc_frame = sizeof (fcoe_frame_header_t) + 327 (uint8_t *)fmi->fmi_ffh; 328 fmi->fmi_fft = (fcoe_frame_tailer_t *) 329 (fc_frame_size + (uint8_t *)fmi->fmi_fc_frame); 330 331 /* 332 * Continue to initialize fcoe_frame_t 333 */ 334 frm->frm_hdr = (fcoe_fc_frame_header_t *)fmi->fmi_fc_frame; 335 frm->frm_ofh1 = NULL; 336 frm->frm_ofh2 = NULL; 337 frm->frm_fc_frame = (uint8_t *)frm->frm_hdr; 338 frm->frm_payload = sizeof (fcoe_fc_frame_header_t) + 339 (uint8_t *)frm->frm_fc_frame; 340 return (frm); 341 } 342 343 /* 344 * Sub routines called by interface functions 345 */ 346 347 /* 348 * According to spec, fill EthernetII frame header, FCoE frame header 349 * VLAN (not included for now) 350 */ 351 static void 352 fcoe_fill_frame_headers(fcoe_frame_t *frm) 353 { 354 fcoe_i_frame_t *fmi = FRM2FMI(frm); 355 356 /* 357 * Initialize ethernet frame header 358 */ 359 bcopy(FRM2MAC(frm)->fm_current_addr, &fmi->fmi_efh->ether_shost, 360 ETHERADDRL); 361 bcopy(frm->frm_eport->eport_efh_dst, 362 &fmi->fmi_efh->ether_dhost, ETHERADDRL); 363 fmi->fmi_efh->ether_type = htons(ETHERTYPE_FCOE); 364 365 /* 366 * Initialize FCoE frame header 367 */ 368 bzero(fmi->fmi_ffh, sizeof (fcoe_frame_header_t)); 369 FCOE_ENCAPS_VER(fmi->fmi_ffh, FCOE_VER); 370 /* set to SOFi3 for the first frame of a sequence */ 371 if (FRM_SEQ_CNT(frm) == 0) { 372 FCOE_V2B_1(0x2E, fmi->fmi_ffh->ffh_sof); 373 } else { 374 FCOE_V2B_1(0x36, fmi->fmi_ffh->ffh_sof); 375 } 376 } 377 378 /* 379 * According to spec, fill FCOE frame tailer including CRC 380 * VLAN (not included for now) 381 */ 382 static void 383 fcoe_fill_frame_tailers(fcoe_frame_t *frm) 384 { 385 uint32_t crc; 386 387 /* 388 * Initialize FCoE frame tailer 389 * CRC is not big endian, can't use macro V2B 390 */ 391 CRC32(crc, frm->frm_fc_frame, frm->frm_fc_frame_size, 392 (uint32_t)~0, crc32_table); 393 FRM2FMI(frm)->fmi_fft->fft_crc[0] = 0xFF & (~crc); 394 FRM2FMI(frm)->fmi_fft->fft_crc[1] = 0xFF & (~crc >> 8); 395 FRM2FMI(frm)->fmi_fft->fft_crc[2] = 0xFF & (~crc >> 16); 396 FRM2FMI(frm)->fmi_fft->fft_crc[3] = 0xFF & (~crc >> 24); 397 if (FRM_F_CTL(frm) & 0x080000) { 398 FCOE_V2B_1(0x42, FRM2FMI(frm)->fmi_fft->fft_eof); 399 } else { 400 FCOE_V2B_1(0x41, FRM2FMI(frm)->fmi_fft->fft_eof); 401 } 402 403 FRM2FMI(frm)->fmi_fft->fft_resvd[0] = 0; 404 FRM2FMI(frm)->fmi_fft->fft_resvd[1] = 0; 405 FRM2FMI(frm)->fmi_fft->fft_resvd[2] = 0; 406 } 407 408 void 409 fcoe_mac_notify_link_up(void *arg) 410 { 411 fcoe_mac_t *mac = (fcoe_mac_t *)arg; 412 413 ASSERT(mac->fm_flags & FCOE_MAC_FLAG_BOUND); 414 415 mac->fm_client.ect_port_event(&mac->fm_eport, 416 FCOE_NOTIFY_EPORT_LINK_UP); 417 } 418 void 419 fcoe_mac_notify_link_down(void *arg) 420 { 421 fcoe_mac_t *mac = (fcoe_mac_t *)arg; 422 423 if (mac->fm_flags & FCOE_MAC_FLAG_BOUND) { 424 mac->fm_client.ect_port_event(&mac->fm_eport, 425 FCOE_NOTIFY_EPORT_LINK_DOWN); 426 } 427 } 428 429 int 430 fcoe_create_port(dev_info_t *parent, fcoe_mac_t *mac, int is_target) 431 { 432 int rval = 0; 433 dev_info_t *child = NULL; 434 char *devname = is_target ? FCOET_DRIVER_NAME : FCOEI_DRIVER_NAME; 435 436 ndi_devi_alloc_sleep(parent, devname, DEVI_PSEUDO_NODEID, &child); 437 if (child == NULL) { 438 FCOE_LOG("fcoe", "fail to create new devinfo"); 439 return (NDI_FAILURE); 440 } 441 442 if (ddi_prop_update_int(DDI_DEV_T_NONE, child, 443 "mac_id", mac->fm_linkid) != DDI_PROP_SUCCESS) { 444 FCOE_LOG("fcoe", 445 "fcoe%d: prop_update port mac id failed for mac %d", 446 ddi_get_instance(parent), mac->fm_linkid); 447 (void) ndi_devi_free(child); 448 return (NDI_FAILURE); 449 } 450 451 rval = ndi_devi_online(child, NDI_ONLINE_ATTACH); 452 if (rval != NDI_SUCCESS) { 453 FCOE_LOG("fcoe", "fcoe%d: online_driver failed for mac %d", 454 ddi_get_instance(parent), mac->fm_linkid); 455 return (NDI_FAILURE); 456 } 457 mac->fm_client_dev = child; 458 459 return (rval); 460 } 461 462 int 463 fcoe_delete_port(dev_info_t *parent, fcoeio_t *fcoeio, datalink_id_t linkid, 464 uint64_t *is_target) 465 { 466 int rval = 0; 467 fcoe_mac_t *mac; 468 469 mac = fcoe_lookup_mac_by_id(linkid); 470 if (mac == NULL) { 471 fcoeio->fcoeio_status = FCOEIOE_MAC_NOT_FOUND; 472 return (EINVAL); 473 } 474 475 *is_target = EPORT_CLT_TYPE(&mac->fm_eport); 476 if ((mac->fm_flags & FCOE_MAC_FLAG_ENABLED) != FCOE_MAC_FLAG_ENABLED) { 477 fcoeio->fcoeio_status = FCOEIOE_ALREADY; 478 return (EALREADY); 479 } 480 481 if (!(mac->fm_flags & FCOE_MAC_FLAG_BOUND)) { 482 /* 483 * It means that deferred detach has finished 484 * of last delete operation 485 */ 486 goto skip_devi_offline; 487 } 488 489 atomic_and_32(&mac->fm_eport.eport_flags, ~EPORT_FLAG_MAC_IN_USE); 490 mac->fm_flags |= FCOE_MAC_FLAG_USER_DEL; 491 rval = ndi_devi_offline(mac->fm_client_dev, NDI_DEVI_REMOVE); 492 if (rval != NDI_SUCCESS) { 493 FCOE_LOG("fcoe", "fcoe%d: offline_driver %s failed", 494 ddi_get_instance(parent), 495 ddi_get_name(mac->fm_client_dev)); 496 atomic_or_32(&mac->fm_eport.eport_flags, 497 EPORT_FLAG_MAC_IN_USE); 498 499 fcoeio->fcoeio_status = FCOEIOE_OFFLINE_FAILURE; 500 return (EBUSY); 501 } 502 503 skip_devi_offline: 504 (void) fcoe_close_mac(mac); 505 fcoe_destroy_mac(mac); 506 return (0); 507 } 508