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