1 /* 2 * Copyright (c) 2004-2008 Voltaire, Inc. All rights reserved. 3 * Copyright (c) 2002-2005 Mellanox Technologies LTD. All rights reserved. 4 * Copyright (c) 1996-2003 Intel Corporation. All rights reserved. 5 * 6 * This software is available to you under a choice of one of two 7 * licenses. You may choose to be licensed under the terms of the GNU 8 * General Public License (GPL) Version 2, available from the file 9 * COPYING in the main directory of this source tree, or the 10 * OpenIB.org BSD license below: 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 16 * - Redistributions of source code must retain the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer. 19 * 20 * - Redistributions in binary form must reproduce the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer in the documentation and/or other materials 23 * provided with the distribution. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 * SOFTWARE. 33 * 34 */ 35 36 /* 37 * Abstract: 38 * Implementation of vendor specific transport interface. 39 * This is the "Test" vendor which allows compilation and some 40 * testing without a real vendor interface. 41 * These objects are part of the opensm family of objects. 42 * 43 */ 44 45 #if HAVE_CONFIG_H 46 # include <config.h> 47 #endif /* HAVE_CONFIG_H */ 48 49 #ifdef OSM_VENDOR_INTF_TEST 50 51 #include <stdlib.h> 52 #include <string.h> 53 #include <opensm/osm_log.h> 54 #include <vendor/osm_vendor_test.h> 55 #include <vendor/osm_vendor_api.h> 56 57 void osm_vendor_construct(IN osm_vendor_t * const p_vend) 58 { 59 memset(p_vend, 0, sizeof(*p_vend)); 60 } 61 62 void osm_vendor_destroy(IN osm_vendor_t * const p_vend) 63 { 64 UNUSED_PARAM(p_vend); 65 } 66 67 void osm_vendor_delete(IN osm_vendor_t ** const pp_vend) 68 { 69 CL_ASSERT(pp_vend); 70 71 osm_vendor_destroy(*pp_vend); 72 free(*pp_vend); 73 *pp_vend = NULL; 74 } 75 76 ib_api_status_t 77 osm_vendor_init(IN osm_vendor_t * const p_vend, 78 IN osm_log_t * const p_log, IN const uint32_t timeout) 79 { 80 OSM_LOG_ENTER(p_log); 81 82 CL_ASSERT(p_vend); 83 CL_ASSERT(p_log); 84 85 p_vend->p_log = p_log; 86 p_vend->timeout = timeout; 87 OSM_LOG_EXIT(p_log); 88 return (IB_SUCCESS); 89 } 90 91 osm_vendor_t *osm_vendor_new(IN osm_log_t * const p_log, 92 IN const uint32_t timeout) 93 { 94 ib_api_status_t status; 95 osm_vendor_t *p_vend; 96 OSM_LOG_ENTER(p_log); 97 98 CL_ASSERT(p_log); 99 100 p_vend = malloc(sizeof(*p_vend)); 101 if (p_vend != NULL) { 102 memset(p_vend, 0, sizeof(*p_vend)); 103 104 status = osm_vendor_init(p_vend, p_log, timeout); 105 if (status != IB_SUCCESS) { 106 osm_vendor_delete(&p_vend); 107 } 108 } 109 110 OSM_LOG_EXIT(p_log); 111 return (p_vend); 112 } 113 114 ib_mad_t *osm_vendor_get(IN osm_bind_handle_t h_bind, 115 IN const uint32_t size, 116 IN osm_vend_wrap_t * const p_vend_wrap) 117 { 118 osm_vendor_t *p_vend; 119 ib_mad_t *p_mad; 120 OSM_LOG_ENTER(h_bind->p_vend->p_log); 121 122 UNUSED_PARAM(p_vend_wrap); 123 124 p_vend = h_bind->p_vend; 125 126 /* 127 Simply malloc the MAD off the heap. 128 */ 129 p_mad = (ib_mad_t *) malloc(size); 130 131 osm_log(p_vend->p_log, OSM_LOG_VERBOSE, 132 "osm_vendor_get: " "MAD %p.\n", p_mad); 133 134 if (p_mad) 135 memset(p_mad, 0, size); 136 137 OSM_LOG_EXIT(p_vend->p_log); 138 return (p_mad); 139 } 140 141 void 142 osm_vendor_put(IN osm_bind_handle_t h_bind, 143 IN osm_vend_wrap_t * const p_vend_wrap, 144 IN ib_mad_t * const p_mad) 145 { 146 osm_vendor_t *p_vend; 147 148 OSM_LOG_ENTER(h_bind->p_vend->p_log); 149 150 UNUSED_PARAM(p_vend_wrap); 151 152 p_vend = h_bind->p_vend; 153 154 osm_log(p_vend->p_log, OSM_LOG_VERBOSE, 155 "osm_vendor_put: " "MAD %p.\n", p_mad); 156 157 /* 158 Return the MAD to the heap. 159 */ 160 free(p_mad); 161 162 OSM_LOG_EXIT(p_vend->p_log); 163 } 164 165 ib_api_status_t 166 osm_vendor_send(IN osm_bind_handle_t h_bind, 167 IN osm_vend_wrap_t * const p_vend_wrap, 168 IN osm_mad_addr_t * const p_mad_addr, 169 IN ib_mad_t * const p_mad, 170 IN void *transaction_context, IN boolean_t const resp_expected) 171 { 172 osm_vendor_t *p_vend = h_bind->p_vend; 173 174 OSM_LOG_ENTER(p_vend->p_log); 175 176 UNUSED_PARAM(p_vend_wrap); 177 UNUSED_PARAM(p_mad_addr); 178 UNUSED_PARAM(transaction_context); 179 UNUSED_PARAM(resp_expected); 180 181 osm_log(p_vend->p_log, OSM_LOG_VERBOSE, 182 "osm_vendor_send: " "MAD %p.\n", p_mad); 183 184 OSM_LOG_EXIT(p_vend->p_log); 185 return (IB_SUCCESS); 186 } 187 188 osm_bind_handle_t 189 osm_vendor_bind(IN osm_vendor_t * const p_vend, 190 IN osm_bind_info_t * const p_bind_info, 191 IN osm_mad_pool_t * const p_mad_pool, 192 IN osm_vend_mad_recv_callback_t mad_recv_callback, 193 IN void *context) 194 { 195 osm_bind_handle_t h_bind; 196 197 OSM_LOG_ENTER(p_vend->p_log); 198 199 CL_ASSERT(p_vend); 200 CL_ASSERT(p_bind_info); 201 CL_ASSERT(p_mad_pool); 202 CL_ASSERT(mad_recv_callback); 203 CL_ASSERT(context); 204 205 UNUSED_PARAM(p_vend); 206 UNUSED_PARAM(p_mad_pool); 207 UNUSED_PARAM(mad_recv_callback); 208 UNUSED_PARAM(context); 209 210 h_bind = (osm_bind_handle_t) malloc(sizeof(*h_bind)); 211 if (h_bind != NULL) { 212 memset(h_bind, 0, sizeof(*h_bind)); 213 h_bind->p_vend = p_vend; 214 h_bind->port_guid = p_bind_info->port_guid; 215 h_bind->mad_class = p_bind_info->mad_class; 216 h_bind->class_version = p_bind_info->class_version; 217 h_bind->is_responder = p_bind_info->is_responder; 218 h_bind->is_trap_processor = p_bind_info->is_trap_processor; 219 h_bind->is_report_processor = p_bind_info->is_report_processor; 220 h_bind->send_q_size = p_bind_info->send_q_size; 221 h_bind->recv_q_size = p_bind_info->recv_q_size; 222 } 223 224 OSM_LOG_EXIT(p_vend->p_log); 225 return (h_bind); 226 } 227 228 ib_api_status_t 229 osm_vendor_get_ports(IN osm_vendor_t * const p_vend, 230 IN ib_net64_t * const p_guids, 231 IN uint32_t * const num_guids) 232 { 233 OSM_LOG_ENTER(p_vend->p_log); 234 235 *p_guids = CL_NTOH64(0x0000000000001234); 236 *num_guids = 1; 237 238 OSM_LOG_EXIT(p_vend->p_log); 239 return (IB_SUCCESS); 240 } 241 242 ib_api_status_t osm_vendor_local_lid_change(IN osm_bind_handle_t h_bind) 243 { 244 osm_vendor_t *p_vend = h_bind->p_vend; 245 246 OSM_LOG_ENTER(p_vend->p_log); 247 248 OSM_LOG_EXIT(p_vend->p_log); 249 250 return (IB_SUCCESS); 251 } 252 253 void osm_vendor_set_debug(IN osm_vendor_t * const p_vend, IN int32_t level) 254 { 255 256 } 257 258 #endif /* OSM_VENDOR_INTF_TEST */ 259