Print this page
hg changesets 607a5b46a793..b706c96317c3
Fix ncpus for early boot config
Purge the ack to the interrupt before exiting mptsas_intr()
Changes from code review
Change some obvious references sas -> sas3.
Changes to enable driver to compile.
Header paths, object lists, etc.
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/scsi/adapters/mpt_sas3/mptsas3_smhba.c
+++ new/usr/src/uts/common/io/scsi/adapters/mpt_sas3/mptsas3_smhba.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
25 + * Copyright (c) 2014, Tegile Systems Inc. All rights reserved.
25 26 */
26 27 /*
27 - * This file contains SM-HBA support for MPT SAS driver
28 + * This file contains SM-HBA support for MPT SAS3 driver
28 29 */
29 30
30 31 #if defined(lint) || defined(DEBUG)
31 32 #define MPTSAS_DEBUG
32 33 #endif
33 34
34 35 /*
35 36 * standard header files
36 37 */
37 38 #include <sys/note.h>
38 39 #include <sys/scsi/scsi.h>
39 40 #include <sys/pci.h>
40 41 #include <sys/scsi/generic/sas.h>
41 42 #include <sys/scsi/impl/scsi_sas.h>
42 43
43 44 #pragma pack(1)
44 -#include <sys/scsi/adapters/mpt_sas/mpi/mpi2_type.h>
45 -#include <sys/scsi/adapters/mpt_sas/mpi/mpi2.h>
46 -#include <sys/scsi/adapters/mpt_sas/mpi/mpi2_cnfg.h>
47 -#include <sys/scsi/adapters/mpt_sas/mpi/mpi2_init.h>
48 -#include <sys/scsi/adapters/mpt_sas/mpi/mpi2_ioc.h>
49 -#include <sys/scsi/adapters/mpt_sas/mpi/mpi2_sas.h>
45 +#include <sys/scsi/adapters/mpt_sas3/mpi/mpi2_type.h>
46 +#include <sys/scsi/adapters/mpt_sas3/mpi/mpi2.h>
47 +#include <sys/scsi/adapters/mpt_sas3/mpi/mpi2_cnfg.h>
48 +#include <sys/scsi/adapters/mpt_sas3/mpi/mpi2_init.h>
49 +#include <sys/scsi/adapters/mpt_sas3/mpi/mpi2_ioc.h>
50 +#include <sys/scsi/adapters/mpt_sas3/mpi/mpi2_sas.h>
50 51 #pragma pack()
51 52
52 53 /*
53 54 * private header files.
54 55 */
55 -#include <sys/scsi/adapters/mpt_sas/mptsas_var.h>
56 -#include <sys/scsi/adapters/mpt_sas/mptsas_smhba.h>
56 +#include <sys/scsi/adapters/mpt_sas3/mptsas3_var.h>
57 +#include <sys/scsi/adapters/mpt_sas3/mptsas3_smhba.h>
57 58
58 59 /*
59 60 * SM - HBA statics
60 61 */
61 62 extern char *mptsas_driver_rev;
62 63
63 64 static void mptsas_smhba_create_phy_props(nvlist_t **, smhba_info_t *, uint8_t,
64 65 uint16_t *);
65 66 static void mptsas_smhba_update_phy_props(mptsas_t *, dev_info_t *, nvlist_t **,
66 67 uint8_t);
67 68
68 69 static void
69 70 mptsas_smhba_add_hba_prop(mptsas_t *mpt, data_type_t dt,
70 71 char *prop_name, void *prop_val);
71 72
72 73 void
73 74 mptsas_smhba_show_phy_info(mptsas_t *mpt);
74 75
75 76 static void
76 77 mptsas_smhba_add_hba_prop(mptsas_t *mpt, data_type_t dt,
77 78 char *prop_name, void *prop_val)
78 79 {
79 80 ASSERT(mpt != NULL);
80 81
81 82 switch (dt) {
82 83 case DATA_TYPE_INT32:
83 84 if (ddi_prop_update_int(DDI_DEV_T_NONE, mpt->m_dip,
84 85 prop_name, *(int *)prop_val)) {
85 86 mptsas_log(mpt, CE_WARN,
86 87 "%s: %s prop update failed", __func__, prop_name);
87 88 }
88 89 break;
89 90 case DATA_TYPE_STRING:
90 91 if (ddi_prop_update_string(DDI_DEV_T_NONE, mpt->m_dip,
91 92 prop_name, (char *)prop_val)) {
92 93 mptsas_log(mpt, CE_WARN,
93 94 "%s: %s prop update failed", __func__, prop_name);
94 95 }
95 96 break;
96 97 default:
97 98 mptsas_log(mpt, CE_WARN, "%s: "
98 99 "Unhandled datatype(%d) for (%s). Skipping prop update.",
99 100 __func__, dt, prop_name);
100 101 }
101 102 }
102 103
103 104 void
104 105 mptsas_smhba_show_phy_info(mptsas_t *mpt)
105 106 {
106 107 int i;
107 108
108 109 ASSERT(mpt != NULL);
109 110
110 111 for (i = 0; i < MPTSAS_MAX_PHYS; i++) {
111 112 mptsas_log(mpt, CE_WARN,
112 113 "phy %d, Owner hdl:0x%x, attached hdl: 0x%x,"
113 114 "attached phy identifier %d,Program link rate 0x%x,"
114 115 "hw link rate 0x%x, negotiator link rate 0x%x, path %s",
115 116 i, mpt->m_phy_info[i].smhba_info.owner_devhdl,
116 117 mpt->m_phy_info[i].smhba_info.attached_devhdl,
117 118 mpt->m_phy_info[i].smhba_info.attached_phy_identify,
118 119 mpt->m_phy_info[i].smhba_info.programmed_link_rate,
119 120 mpt->m_phy_info[i].smhba_info.hw_link_rate,
120 121 mpt->m_phy_info[i].smhba_info.negotiated_link_rate,
121 122 mpt->m_phy_info[i].smhba_info.path);
122 123 }
123 124 }
124 125
125 126 static void
126 127 mptsas_smhba_create_phy_props(nvlist_t **phy_props, smhba_info_t *pSmhba,
127 128 uint8_t phy_id, uint16_t *attached_devhdl)
128 129 {
129 130 (void) nvlist_alloc(phy_props, NV_UNIQUE_NAME, KM_SLEEP);
130 131 (void) nvlist_add_uint8(*phy_props, SAS_PHY_ID, phy_id);
131 132 (void) nvlist_add_uint8(*phy_props, "phyState",
132 133 (pSmhba->negotiated_link_rate & 0x0f));
133 134 (void) nvlist_add_int8(*phy_props, SAS_NEG_LINK_RATE,
134 135 (pSmhba->negotiated_link_rate & 0x0f));
135 136 (void) nvlist_add_int8(*phy_props, SAS_PROG_MIN_LINK_RATE,
136 137 (pSmhba->programmed_link_rate & 0x0f));
137 138 (void) nvlist_add_int8(*phy_props, SAS_HW_MIN_LINK_RATE,
138 139 (pSmhba->hw_link_rate & 0x0f));
139 140 (void) nvlist_add_int8(*phy_props, SAS_PROG_MAX_LINK_RATE,
140 141 ((pSmhba->programmed_link_rate & 0xf0) >> 4));
141 142 (void) nvlist_add_int8(*phy_props, SAS_HW_MAX_LINK_RATE,
142 143 ((pSmhba->hw_link_rate & 0xf0) >> 4));
143 144
144 145 if (pSmhba->attached_devhdl && (attached_devhdl != NULL))
145 146 *attached_devhdl = pSmhba->attached_devhdl;
146 147 }
147 148
148 149 static void
149 150 mptsas_smhba_update_phy_props(mptsas_t *mpt, dev_info_t *dip,
150 151 nvlist_t **phy_props, uint8_t phy_nums)
151 152 {
152 153 int rval;
153 154 size_t packed_size;
154 155 char *packed_data = NULL;
155 156 nvlist_t *nvl;
156 157
157 158 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) != 0) {
158 159 mptsas_log(mpt, CE_WARN, "%s: nvlist_alloc() failed", __func__);
159 160 return;
160 161 }
161 162
162 163 rval = nvlist_add_nvlist_array(nvl, SAS_PHY_INFO_NVL, phy_props,
163 164 phy_nums);
164 165 if (rval) {
165 166 mptsas_log(mpt, CE_WARN,
166 167 " nv list array add failed, return value %d.", rval);
167 168 goto exit;
168 169 }
169 170 (void) nvlist_size(nvl, &packed_size, NV_ENCODE_NATIVE);
170 171 packed_data = kmem_zalloc(packed_size, KM_SLEEP);
171 172 (void) nvlist_pack(nvl, &packed_data, &packed_size,
172 173 NV_ENCODE_NATIVE, 0);
173 174
174 175 (void) ddi_prop_update_byte_array(DDI_DEV_T_NONE, dip,
175 176 SAS_PHY_INFO, (uchar_t *)packed_data, packed_size);
176 177
177 178 exit:
178 179 nvlist_free(nvl);
179 180
180 181 if (packed_data != NULL) {
181 182 kmem_free(packed_data, packed_size);
182 183 }
183 184 }
184 185
185 186 void
186 187 mptsas_smhba_set_one_phy_props(mptsas_t *mpt, dev_info_t *dip, uint8_t phy_id,
187 188 uint16_t *attached_devhdl)
188 189 {
189 190 nvlist_t *phy_props;
190 191
191 192 ASSERT(phy_id < mpt->m_num_phys);
192 193
193 194 mptsas_smhba_create_phy_props(&phy_props,
194 195 &mpt->m_phy_info[phy_id].smhba_info, phy_id, attached_devhdl);
195 196
196 197 mptsas_smhba_update_phy_props(mpt, dip, &phy_props, 1);
197 198
198 199 nvlist_free(phy_props);
199 200 }
200 201
201 202 void
202 203 mptsas_smhba_set_all_phy_props(mptsas_t *mpt, dev_info_t *dip, uint8_t phy_nums,
203 204 mptsas_phymask_t phy_mask, uint16_t *attached_devhdl)
204 205 {
205 206 int i, j;
206 207 nvlist_t **phy_props;
207 208
208 209 if (phy_nums == 0)
209 210 return;
210 211
211 212 phy_props = kmem_zalloc(sizeof (nvlist_t *) * phy_nums, KM_SLEEP);
212 213
213 214 for (i = 0, j = 0; i < mpt->m_num_phys && j < phy_nums; i++)
214 215 if (phy_mask == mpt->m_phy_info[i].phy_mask)
215 216 mptsas_smhba_create_phy_props(&phy_props[j++],
216 217 &mpt->m_phy_info[i].smhba_info, i, attached_devhdl);
217 218
218 219 mptsas_smhba_update_phy_props(mpt, dip, phy_props, j);
219 220
220 221 for (i = 0; i < j && phy_props[i] != NULL; i++)
221 222 nvlist_free(phy_props[i]);
222 223
223 224 kmem_free(phy_props, sizeof (nvlist_t *) * phy_nums);
224 225 }
225 226
226 227 /*
227 228 * Called with PHY lock held on phyp
228 229 */
229 230 void
230 231 mptsas_smhba_log_sysevent(mptsas_t *mpt, char *subclass, char *etype,
231 232 smhba_info_t *phyp)
232 233 {
233 234 nvlist_t *attr_list;
234 235 char *pname;
235 236 char sas_addr[MPTSAS_WWN_STRLEN];
236 237 uint8_t phynum = 0;
237 238 uint8_t lrate = 0;
238 239
239 240 if (mpt->m_dip == NULL)
240 241 return;
241 242 if (phyp == NULL)
242 243 return;
243 244
244 245 pname = kmem_zalloc(MAXPATHLEN, KM_NOSLEEP);
245 246 if (pname == NULL)
246 247 return;
247 248
248 249 if ((strcmp(subclass, ESC_SAS_PHY_EVENT) == 0) ||
249 250 (strcmp(subclass, ESC_SAS_HBA_PORT_BROADCAST) == 0)) {
250 251 ASSERT(phyp != NULL);
251 252 (void) strncpy(pname, phyp->path, strlen(phyp->path));
252 253 phynum = phyp->phy_id;
253 254 bzero(sas_addr, sizeof (sas_addr));
254 255 (void) sprintf(sas_addr, "w%016"PRIx64, phyp->sas_addr);
255 256 if (strcmp(etype, SAS_PHY_ONLINE) == 0) {
256 257 lrate = phyp->negotiated_link_rate;
257 258 }
258 259 }
259 260 if (strcmp(subclass, ESC_SAS_HBA_PORT_BROADCAST) == 0) {
260 261 (void) ddi_pathname(mpt->m_dip, pname);
261 262 }
262 263
263 264 if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, 0) != 0) {
264 265 mptsas_log(mpt, CE_WARN,
265 266 "%s: Failed to post sysevent", __func__);
266 267 kmem_free(pname, MAXPATHLEN);
267 268 return;
268 269 }
269 270
270 271 if (nvlist_add_int32(attr_list, SAS_DRV_INST,
271 272 ddi_get_instance(mpt->m_dip)) != 0)
272 273 goto fail;
273 274
274 275 if (nvlist_add_string(attr_list, SAS_PORT_ADDR, sas_addr) != 0)
275 276 goto fail;
276 277
277 278 if (nvlist_add_string(attr_list, SAS_DEVFS_PATH, pname) != 0)
278 279 goto fail;
279 280
280 281 if (nvlist_add_uint8(attr_list, SAS_PHY_ID, phynum) != 0)
281 282 goto fail;
282 283
283 284 if (strcmp(etype, SAS_PHY_ONLINE) == 0) {
284 285 if (nvlist_add_uint8(attr_list, SAS_LINK_RATE, lrate) != 0)
285 286 goto fail;
286 287 }
287 288
288 289 if (nvlist_add_string(attr_list, SAS_EVENT_TYPE, etype) != 0)
289 290 goto fail;
290 291
291 292 (void) ddi_log_sysevent(mpt->m_dip, DDI_VENDOR_SUNW, EC_HBA, subclass,
292 293 attr_list, NULL, DDI_NOSLEEP);
293 294
294 295 fail:
295 296 kmem_free(pname, MAXPATHLEN);
296 297 nvlist_free(attr_list);
297 298 }
298 299
299 300 void
300 301 mptsas_create_phy_stats(mptsas_t *mpt, char *iport, dev_info_t *dip)
301 302 {
302 303 sas_phy_stats_t *ps;
303 304 smhba_info_t *phyp;
304 305 int ndata;
305 306 char ks_name[KSTAT_STRLEN];
306 307 char phymask[MPTSAS_MAX_PHYS];
307 308 int i;
308 309
309 310 ASSERT(iport != NULL);
310 311 ASSERT(mpt != NULL);
311 312
312 313 for (i = 0; i < mpt->m_num_phys; i++) {
313 314
314 315 bzero(phymask, sizeof (phymask));
315 316 (void) sprintf(phymask, "%x", mpt->m_phy_info[i].phy_mask);
316 317 if (strcmp(phymask, iport) == 0) {
317 318
318 319 phyp = &mpt->m_phy_info[i].smhba_info;
319 320 mutex_enter(&phyp->phy_mutex);
320 321
321 322 if (phyp->phy_stats != NULL) {
322 323 mutex_exit(&phyp->phy_mutex);
323 324 /* We've already created this kstat instance */
|
↓ open down ↓ |
257 lines elided |
↑ open up ↑ |
324 325 continue;
325 326 }
326 327
327 328 ndata = (sizeof (sas_phy_stats_t)/
328 329 sizeof (kstat_named_t));
329 330 (void) snprintf(ks_name, sizeof (ks_name),
330 331 "%s.%llx.%d.%d", ddi_driver_name(dip),
331 332 (longlong_t)mpt->un.m_base_wwid,
332 333 ddi_get_instance(dip), i);
333 334
334 - phyp->phy_stats = kstat_create("mptsas",
335 + phyp->phy_stats = kstat_create("mptsas3",
335 336 ddi_get_instance(dip), ks_name, KSTAT_SAS_PHY_CLASS,
336 337 KSTAT_TYPE_NAMED, ndata, 0);
337 338
338 339 if (phyp->phy_stats == NULL) {
339 340 mutex_exit(&phyp->phy_mutex);
340 341 mptsas_log(mpt, CE_WARN,
341 342 "%s: Failed to create %s kstats", __func__,
342 343 ks_name);
343 344 continue;
344 345 }
345 346
346 347 ps = (sas_phy_stats_t *)phyp->phy_stats->ks_data;
347 348
348 349 kstat_named_init(&ps->seconds_since_last_reset,
349 350 "SecondsSinceLastReset", KSTAT_DATA_ULONGLONG);
350 351 kstat_named_init(&ps->tx_frames,
351 352 "TxFrames", KSTAT_DATA_ULONGLONG);
352 353 kstat_named_init(&ps->rx_frames,
353 354 "RxFrames", KSTAT_DATA_ULONGLONG);
354 355 kstat_named_init(&ps->tx_words,
355 356 "TxWords", KSTAT_DATA_ULONGLONG);
356 357 kstat_named_init(&ps->rx_words,
357 358 "RxWords", KSTAT_DATA_ULONGLONG);
358 359 kstat_named_init(&ps->invalid_dword_count,
359 360 "InvalidDwordCount", KSTAT_DATA_ULONGLONG);
360 361 kstat_named_init(&ps->running_disparity_error_count,
361 362 "RunningDisparityErrorCount", KSTAT_DATA_ULONGLONG);
362 363 kstat_named_init(&ps->loss_of_dword_sync_count,
363 364 "LossofDwordSyncCount", KSTAT_DATA_ULONGLONG);
364 365 kstat_named_init(&ps->phy_reset_problem_count,
365 366 "PhyResetProblemCount", KSTAT_DATA_ULONGLONG);
366 367
367 368 phyp->phy_stats->ks_private = phyp;
368 369 phyp->phy_stats->ks_update = mptsas_update_phy_stats;
369 370 kstat_install(phyp->phy_stats);
370 371 mutex_exit(&phyp->phy_mutex);
371 372 }
372 373 }
373 374 }
374 375
375 376 int
376 377 mptsas_update_phy_stats(kstat_t *ks, int rw)
377 378 {
378 379 int ret = DDI_FAILURE;
379 380 smhba_info_t *pptr = NULL;
380 381 sas_phy_stats_t *ps = ks->ks_data;
381 382 uint32_t page_address;
382 383 mptsas_t *mpt;
383 384
384 385 _NOTE(ARGUNUSED(rw));
385 386
386 387 pptr = (smhba_info_t *)ks->ks_private;
387 388 ASSERT((pptr != NULL));
388 389 mpt = (mptsas_t *)pptr->mpt;
389 390 ASSERT((mpt != NULL));
390 391 page_address = (MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | pptr->phy_id);
391 392
392 393 /*
393 394 * We just want to lock against other invocations of kstat;
394 395 * we don't need to pmcs_lock_phy() for this.
395 396 */
396 397 mutex_enter(&mpt->m_mutex);
397 398
398 399 ret = mptsas_get_sas_phy_page1(pptr->mpt, page_address, pptr);
399 400
400 401 if (ret == DDI_FAILURE)
401 402 goto fail;
402 403
403 404 ps->invalid_dword_count.value.ull =
404 405 (unsigned long long)pptr->invalid_dword_count;
405 406
406 407 ps->running_disparity_error_count.value.ull =
407 408 (unsigned long long)pptr->running_disparity_error_count;
408 409
409 410 ps->loss_of_dword_sync_count.value.ull =
410 411 (unsigned long long)pptr->loss_of_dword_sync_count;
411 412
412 413 ps->phy_reset_problem_count.value.ull =
413 414 (unsigned long long)pptr->phy_reset_problem_count;
414 415
415 416 ret = DDI_SUCCESS;
416 417 fail:
417 418 mutex_exit(&mpt->m_mutex);
418 419
419 420 return (ret);
420 421 }
421 422
422 423 void
423 424 mptsas_destroy_phy_stats(mptsas_t *mpt)
424 425 {
425 426 smhba_info_t *phyp;
426 427 int i = 0;
427 428
428 429 ASSERT(mpt != NULL);
429 430
430 431 for (i = 0; i < mpt->m_num_phys; i++) {
431 432 phyp = &mpt->m_phy_info[i].smhba_info;
432 433 if (phyp == NULL) {
433 434 continue;
434 435 }
435 436
436 437 mutex_enter(&phyp->phy_mutex);
437 438 if (phyp->phy_stats != NULL) {
438 439 kstat_delete(phyp->phy_stats);
439 440 phyp->phy_stats = NULL;
440 441 }
441 442 mutex_exit(&phyp->phy_mutex);
442 443 }
443 444 }
444 445
445 446 int
446 447 mptsas_smhba_phy_init(mptsas_t *mpt)
447 448 {
448 449 int i = 0;
449 450 int rval = DDI_SUCCESS;
450 451 uint32_t page_address;
451 452
452 453 ASSERT(mutex_owned(&mpt->m_mutex));
453 454
454 455 for (i = 0; i < mpt->m_num_phys; i++) {
455 456 page_address =
456 457 (MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER |
457 458 (MPI2_SAS_PHY_PGAD_PHY_NUMBER_MASK & i));
458 459 rval = mptsas_get_sas_phy_page0(mpt,
459 460 page_address, &mpt->m_phy_info[i].smhba_info);
460 461 if (rval != DDI_SUCCESS) {
461 462 mptsas_log(mpt, CE_WARN,
462 463 "Failed to get sas phy page 0"
463 464 " for each phy");
464 465 return (DDI_FAILURE);
465 466 }
466 467 mpt->m_phy_info[i].smhba_info.phy_id = (uint8_t)i;
467 468 mpt->m_phy_info[i].smhba_info.sas_addr =
468 469 mpt->un.m_base_wwid + i;
469 470 mpt->m_phy_info[i].smhba_info.mpt = mpt;
470 471 }
471 472 return (DDI_SUCCESS);
472 473 }
473 474
474 475 int
475 476 mptsas_smhba_setup(mptsas_t *mpt)
476 477 {
477 478 int sm_hba = 1;
478 479 char chiprev, hw_rev[24];
479 480 char serial_number[72];
480 481 int protocol = 0;
481 482
482 483 mutex_enter(&mpt->m_mutex);
483 484 if (mptsas_smhba_phy_init(mpt)) {
484 485 mutex_exit(&mpt->m_mutex);
485 486 return (DDI_FAILURE);
486 487 }
487 488 mutex_exit(&mpt->m_mutex);
488 489
489 490 /* SM-HBA support */
490 491 mptsas_smhba_add_hba_prop(mpt, DATA_TYPE_INT32, MPTSAS_SMHBA_SUPPORTED,
491 492 &sm_hba);
492 493
493 494 /* SM-HBA driver version */
494 495 mptsas_smhba_add_hba_prop(mpt, DATA_TYPE_STRING, MPTSAS_DRV_VERSION,
495 496 mptsas_driver_rev);
496 497
497 498 /* SM-HBA hardware version */
498 499 chiprev = 'A' + mpt->m_revid;
499 500 (void) snprintf(hw_rev, 2, "%s", &chiprev);
500 501 mptsas_smhba_add_hba_prop(mpt, DATA_TYPE_STRING, MPTSAS_HWARE_VERSION,
501 502 hw_rev);
502 503
503 504 /* SM-HBA phy number per HBA */
504 505 mptsas_smhba_add_hba_prop(mpt, DATA_TYPE_INT32, MPTSAS_NUM_PHYS_HBA,
505 506 &(mpt->m_num_phys));
506 507
507 508 /* SM-HBA protocal support */
508 509 protocol = SAS_SSP_SUPPORT | SAS_SATA_SUPPORT | SAS_SMP_SUPPORT;
509 510 mptsas_smhba_add_hba_prop(mpt, DATA_TYPE_INT32,
510 511 MPTSAS_SUPPORTED_PROTOCOL, &protocol);
511 512
512 513 mptsas_smhba_add_hba_prop(mpt, DATA_TYPE_STRING, MPTSAS_MANUFACTURER,
513 514 mpt->m_MANU_page0.ChipName);
514 515
515 516 mptsas_smhba_add_hba_prop(mpt, DATA_TYPE_STRING, MPTSAS_MODEL_NAME,
516 517 mpt->m_MANU_page0.BoardName);
517 518
518 519 /*
519 520 * VPD data is not available, we make a serial number for this.
520 521 */
521 522
522 523 (void) sprintf(serial_number, "%s%s%s%s%s",
523 524 mpt->m_MANU_page0.ChipName,
524 525 mpt->m_MANU_page0.ChipRevision,
525 526 mpt->m_MANU_page0.BoardName,
526 527 mpt->m_MANU_page0.BoardAssembly,
527 528 mpt->m_MANU_page0.BoardTracerNumber);
528 529
529 530 mptsas_smhba_add_hba_prop(mpt, DATA_TYPE_STRING, MPTSAS_SERIAL_NUMBER,
530 531 &serial_number[0]);
531 532
532 533 return (DDI_SUCCESS);
533 534 }
|
↓ open down ↓ |
189 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX