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