1 /*-
2 * Copyright 2016-2021 Microchip Technology, Inc. and/or its subsidiaries.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26 /* $FreeBSD$ */
27
28 #include "smartpqi_includes.h"
29
30 #define MAX_RETRIES 3
31 #define PQISRC_INQUIRY_TIMEOUT 30
32
33 /* Validate the scsi sense response code */
34 static inline
35 boolean_t pqisrc_scsi_sense_valid(const struct sense_header_scsi *sshdr)
36 {
37 DBG_FUNC("IN\n");
38
39 if (!sshdr)
40 return false;
41
42 DBG_FUNC("OUT\n");
43
44 return (sshdr->response_code & 0x70) == 0x70;
45 }
46
47 /*
48 * Initialize target ID pool for HBA/PDs .
49 */
50 void
51 pqisrc_init_targetid_pool(pqisrc_softstate_t *softs)
52 {
53 int i, tid = PQI_MAX_PHYSICALS + PQI_MAX_LOGICALS - 1;
54
55 for(i = 0; i < PQI_MAX_PHYSICALS; i++) {
56 softs->tid_pool.tid[i] = tid--;
57 }
58 softs->tid_pool.index = i - 1;
59 }
60
61 int
62 pqisrc_alloc_tid(pqisrc_softstate_t *softs)
63 {
64
65 if(softs->tid_pool.index <= -1) {
66 DBG_ERR("Target ID exhausted\n");
67 return INVALID_ELEM;
68 }
69
70 return softs->tid_pool.tid[softs->tid_pool.index--];
71 }
72
73 void
74 pqisrc_free_tid(pqisrc_softstate_t *softs, int tid)
75 {
76 if(softs->tid_pool.index >= (PQI_MAX_PHYSICALS - 1)) {
77 DBG_ERR("Target ID queue is full\n");
78 return;
79 }
80
81 softs->tid_pool.index++;
82 softs->tid_pool.tid[softs->tid_pool.index] = tid;
83 }
84
85 /* Update scsi sense info to a local buffer*/
86 boolean_t
87 pqisrc_update_scsi_sense(const uint8_t *buff, int len,
88 struct sense_header_scsi *header)
89 {
90
91 DBG_FUNC("IN\n");
92
93 if (!buff || !len)
94 return false;
95
96 memset(header, 0, sizeof(struct sense_header_scsi));
97
98 header->response_code = (buff[0] & 0x7f);
99
100 if (!pqisrc_scsi_sense_valid(header))
101 return false;
102
103 if (header->response_code >= 0x72) {
104 /* descriptor format */
105 if (len > 1)
106 header->sense_key = (buff[1] & 0xf);
107 if (len > 2)
108 header->asc = buff[2];
109 if (len > 3)
110 header->ascq = buff[3];
111 if (len > 7)
112 header->additional_length = buff[7];
113 } else {
114 /* fixed format */
115 if (len > 2)
116 header->sense_key = (buff[2] & 0xf);
117 if (len > 7) {
118 len = (len < (buff[7] + 8)) ?
119 len : (buff[7] + 8);
120 if (len > 12)
121 header->asc = buff[12];
122 if (len > 13)
123 header->ascq = buff[13];
124 }
125 }
126
127 DBG_FUNC("OUT\n");
128
129 return true;
130 }
131
132 /*
133 * Function used to build the internal raid request and analyze the response
134 */
135 int
136 pqisrc_build_send_raid_request(pqisrc_softstate_t *softs, pqisrc_raid_req_t *request,
137 void *buff, size_t datasize, uint8_t cmd, uint16_t vpd_page, uint8_t *scsi3addr,
138 raid_path_error_info_elem_t *error_info)
139 {
140
141 uint8_t *cdb;
142 int ret = PQI_STATUS_SUCCESS;
143 uint32_t tag = 0;
144 struct dma_mem device_mem;
145 sgt_t *sgd;
146
147 ib_queue_t *ib_q = &softs->op_raid_ib_q[PQI_DEFAULT_IB_QUEUE];
148 ob_queue_t *ob_q = &softs->op_ob_q[PQI_DEFAULT_IB_QUEUE];
149
150 rcb_t *rcb = NULL;
151
152 DBG_FUNC("IN\n");
153
154 memset(&device_mem, 0, sizeof(struct dma_mem));
155
156 /* for TUR datasize: 0 buff: NULL */
157 if (datasize) {
158 device_mem.tag = "device_mem";
159 device_mem.size = datasize;
160 device_mem.align = PQISRC_DEFAULT_DMA_ALIGN;
161
162 ret = os_dma_mem_alloc(softs, &device_mem);
163
164 if (ret) {
165 DBG_ERR("failed to allocate dma memory for device_mem return code %d\n", ret);
166 return ret;
167 }
168
169 sgd = (sgt_t *)&request->sg_descriptors[0];
170
171 sgd->addr = device_mem.dma_addr;
172 sgd->len = datasize;
173 sgd->flags = SG_FLAG_LAST;
174
175 }
176
177 /* Build raid path request */
178 request->header.iu_type = PQI_IU_TYPE_RAID_PATH_IO_REQUEST;
179
180 request->header.iu_length = LE_16(offsetof(pqisrc_raid_req_t,
181 sg_descriptors[1]) - PQI_REQUEST_HEADER_LENGTH);
182 request->buffer_length = LE_32(datasize);
183 memcpy(request->lun_number, scsi3addr, sizeof(request->lun_number));
184 request->task_attribute = SOP_TASK_ATTRIBUTE_SIMPLE;
185 request->additional_cdb_bytes_usage = PQI_ADDITIONAL_CDB_BYTES_0;
186
187 cdb = request->cdb;
188
189 switch (cmd) {
190 case SA_INQUIRY:
191 request->data_direction = SOP_DATA_DIR_TO_DEVICE;
192 cdb[0] = SA_INQUIRY;
193 if (vpd_page & VPD_PAGE) {
194 cdb[1] = 0x1;
195 cdb[2] = (uint8_t)vpd_page;
196 }
197 cdb[4] = (uint8_t)datasize;
198 if (softs->timeout_in_passthrough) {
199 request->timeout_in_sec = PQISRC_INQUIRY_TIMEOUT;
200 }
201 break;
202 case SA_REPORT_LOG:
203 case SA_REPORT_PHYS:
204 request->data_direction = SOP_DATA_DIR_TO_DEVICE;
205 cdb[0] = cmd;
206 if (cmd == SA_REPORT_PHYS)
207 cdb[1] = SA_REPORT_PHYS_EXTENDED;
208 else
209 cdb[1] = SA_REPORT_LOG_EXTENDED;
210 cdb[8] = (uint8_t)((datasize) >> 8);
211 cdb[9] = (uint8_t)datasize;
212 break;
213 case PQI_LOG_EXT_QUEUE_ENABLE:
214 request->data_direction = SOP_DATA_DIR_TO_DEVICE;
215 cdb[0] = SA_REPORT_LOG;
216 cdb[1] = (PQI_LOG_EXT_QUEUE_DEPTH_ENABLED | SA_REPORT_LOG_EXTENDED);
217 cdb[8] = (uint8_t)((datasize) >> 8);
218 cdb[9] = (uint8_t)datasize;
219 break;
220 case TEST_UNIT_READY:
221 request->data_direction = SOP_DATA_DIR_NONE;
222 break;
223 case SA_GET_RAID_MAP:
224 request->data_direction = SOP_DATA_DIR_TO_DEVICE;
225 cdb[0] = SA_CISS_READ;
226 cdb[1] = cmd;
227 cdb[8] = (uint8_t)((datasize) >> 8);
228 cdb[9] = (uint8_t)datasize;
229 break;
230 case SA_CACHE_FLUSH:
231 request->data_direction = SOP_DATA_DIR_FROM_DEVICE;
232 memcpy(device_mem.virt_addr, buff, datasize);
233 cdb[0] = BMIC_WRITE;
234 cdb[6] = BMIC_CACHE_FLUSH;
235 cdb[7] = (uint8_t)((datasize) << 8);
236 cdb[8] = (uint8_t)((datasize) >> 8);
237 break;
238 case BMIC_IDENTIFY_CONTROLLER:
239 case BMIC_IDENTIFY_PHYSICAL_DEVICE:
240 request->data_direction = SOP_DATA_DIR_TO_DEVICE;
241 cdb[0] = BMIC_READ;
242 cdb[6] = cmd;
243 cdb[7] = (uint8_t)((datasize) << 8);
244 cdb[8] = (uint8_t)((datasize) >> 8);
245 break;
246 case BMIC_WRITE_HOST_WELLNESS:
247 request->data_direction = SOP_DATA_DIR_FROM_DEVICE;
248 memcpy(device_mem.virt_addr, buff, datasize);
249 cdb[0] = BMIC_WRITE;
250 cdb[6] = cmd;
251 cdb[7] = (uint8_t)((datasize) << 8);
252 cdb[8] = (uint8_t)((datasize) >> 8);
253 break;
254 case BMIC_SENSE_SUBSYSTEM_INFORMATION:
255 request->data_direction = SOP_DATA_DIR_TO_DEVICE;
256 cdb[0] = BMIC_READ;
257 cdb[6] = cmd;
258 cdb[7] = (uint8_t)((datasize) << 8);
259 cdb[8] = (uint8_t)((datasize) >> 8);
260 break;
261 default:
262 DBG_ERR("unknown command 0x%x", cmd);
263 ret = PQI_STATUS_FAILURE;
264 return ret;
265 }
266
267 tag = pqisrc_get_tag(&softs->taglist);
268 if (INVALID_ELEM == tag) {
269 DBG_ERR("Tag not available\n");
270 ret = PQI_STATUS_FAILURE;
271 goto err_notag;
272 }
273
274 ((pqisrc_raid_req_t *)request)->request_id = tag;
275 ((pqisrc_raid_req_t *)request)->error_index = ((pqisrc_raid_req_t *)request)->request_id;
276 ((pqisrc_raid_req_t *)request)->response_queue_id = ob_q->q_id;
277 rcb = &softs->rcb[tag];
278 rcb->success_cmp_callback = pqisrc_process_internal_raid_response_success;
279 rcb->error_cmp_callback = pqisrc_process_internal_raid_response_error;
280
281 rcb->req_pending = true;
282 rcb->tag = tag;
283 /* Submit Command */
284 ret = pqisrc_submit_cmnd(softs, ib_q, request);
285
286 if (ret != PQI_STATUS_SUCCESS) {
287 DBG_ERR("Unable to submit command\n");
288 goto err_out;
289 }
290
291 ret = pqisrc_wait_on_condition(softs, rcb, PQISRC_CMD_TIMEOUT);
292 if (ret != PQI_STATUS_SUCCESS) {
293 DBG_ERR("Internal RAID request timed out: cmd : 0x%c\n", cmd);
294 goto err_out;
295 }
296
297 if (datasize) {
298 if (buff) {
299 memcpy(buff, device_mem.virt_addr, datasize);
300 }
301 os_dma_mem_free(softs, &device_mem);
302 }
303
304 ret = rcb->status;
305 if (ret) {
306 if(error_info) {
307 memcpy(error_info,
308 rcb->error_info,
309 sizeof(*error_info));
310
311 if (error_info->data_out_result ==
312 PQI_RAID_DATA_IN_OUT_UNDERFLOW) {
313 ret = PQI_STATUS_SUCCESS;
314 }
315 else{
316 DBG_DISC("Error!! Bus=%u Target=%u, Cmd=0x%x,"
317 "Ret=%d\n", BMIC_GET_LEVEL_2_BUS(scsi3addr),
318 BMIC_GET_LEVEL_TWO_TARGET(scsi3addr),
319 cmd, ret);
320 ret = PQI_STATUS_FAILURE;
321 }
322 }
323 } else {
324 if(error_info) {
325 ret = PQI_STATUS_SUCCESS;
326 memset(error_info, 0, sizeof(*error_info));
327 }
328 }
329
330 os_reset_rcb(rcb);
331 pqisrc_put_tag(&softs->taglist, ((pqisrc_raid_req_t *)request)->request_id);
332 DBG_FUNC("OUT\n");
333 return ret;
334
335 err_out:
336 DBG_ERR("Error!! Bus=%u Target=%u, Cmd=0x%x, Ret=%d\n",
337 BMIC_GET_LEVEL_2_BUS(scsi3addr), BMIC_GET_LEVEL_TWO_TARGET(scsi3addr),
338 cmd, ret);
339 os_reset_rcb(rcb);
340 pqisrc_put_tag(&softs->taglist, ((pqisrc_raid_req_t *)request)->request_id);
341 err_notag:
342 if (datasize)
343 os_dma_mem_free(softs, &device_mem);
344 DBG_FUNC("FAILED \n");
345 return ret;
346 }
347
348 /* common function used to send report physical and logical luns cmnds*/
349 static int
350 pqisrc_report_luns(pqisrc_softstate_t *softs, uint8_t cmd,
351 void *buff, size_t buf_len)
352 {
353 int ret;
354 pqisrc_raid_req_t request;
355
356 DBG_FUNC("IN\n");
357
358 memset(&request, 0, sizeof(request));
359 ret = pqisrc_build_send_raid_request(softs, &request, buff,
360 buf_len, cmd, 0, (uint8_t *)RAID_CTLR_LUNID, NULL);
361
362 DBG_FUNC("OUT\n");
363
364 return ret;
365 }
366
367 /* subroutine used to get physical and logical luns of the device */
368 int
369 pqisrc_get_physical_logical_luns(pqisrc_softstate_t *softs, uint8_t cmd,
370 reportlun_data_ext_t **buff, size_t *data_length)
371 {
372 int ret;
373 size_t list_len;
374 size_t data_len;
375 size_t new_lun_list_length;
376 reportlun_data_ext_t *lun_data;
377 reportlun_header_t report_lun_header;
378
379 DBG_FUNC("IN\n");
380
381 ret = pqisrc_report_luns(softs, cmd, &report_lun_header,
382 sizeof(report_lun_header));
383
384 if (ret) {
385 DBG_ERR("failed return code: %d\n", ret);
386 return ret;
387 }
388 list_len = BE_32(report_lun_header.list_length);
389
390 retry:
391 data_len = sizeof(reportlun_header_t) + list_len;
392 *data_length = data_len;
393
394 lun_data = os_mem_alloc(softs, data_len);
395
396 if (!lun_data) {
397 DBG_ERR("failed to allocate memory for lun_data\n");
398 return PQI_STATUS_FAILURE;
399 }
400
401 if (list_len == 0) {
402 DBG_DISC("list_len is 0\n");
403 memcpy(lun_data, &report_lun_header, sizeof(report_lun_header));
404 goto out;
405 }
406
407 ret = pqisrc_report_luns(softs, cmd, lun_data, data_len);
408
409 if (ret) {
410 DBG_ERR("error\n");
411 goto error;
412 }
413
414 new_lun_list_length = BE_32(lun_data->header.list_length);
415
416 if (new_lun_list_length > list_len) {
417 list_len = new_lun_list_length;
418 os_mem_free(softs, (void *)lun_data, data_len);
419 goto retry;
420 }
421
422 out:
423 *buff = lun_data;
424 DBG_FUNC("OUT\n");
425 return 0;
426
427 error:
428 os_mem_free(softs, (void *)lun_data, data_len);
429 DBG_ERR("FAILED\n");
430 return ret;
431 }
432
433 /*
434 * Function used to grab queue depth ext lun data for logical devices
435 */
436 static int
437 pqisrc_get_queue_lun_list(pqisrc_softstate_t *softs, uint8_t cmd,
438 reportlun_queue_depth_data_t **buff, size_t *data_length)
439 {
440 int ret;
441 size_t list_len;
442 size_t data_len;
443 size_t new_lun_list_length;
444 reportlun_queue_depth_data_t *lun_data;
445 reportlun_header_t report_lun_header;
446
447 DBG_FUNC("IN\n");
448
449 ret = pqisrc_report_luns(softs, cmd, &report_lun_header,
450 sizeof(report_lun_header));
451
452 if (ret) {
453 DBG_ERR("failed return code: %d\n", ret);
454 return ret;
455 }
456 list_len = BE_32(report_lun_header.list_length);
457 retry:
458 data_len = sizeof(reportlun_header_t) + list_len;
459 *data_length = data_len;
460 lun_data = os_mem_alloc(softs, data_len);
461
462 if (!lun_data) {
463 DBG_ERR("failed to allocate memory for lun_data\n");
464 return PQI_STATUS_FAILURE;
465 }
466
467 if (list_len == 0) {
468 DBG_INFO("list_len is 0\n");
469 memcpy(lun_data, &report_lun_header, sizeof(report_lun_header));
470 goto out;
471 }
472 ret = pqisrc_report_luns(softs, cmd, lun_data, data_len);
473
474 if (ret) {
475 DBG_ERR("error\n");
476 goto error;
477 }
478 new_lun_list_length = BE_32(lun_data->header.list_length);
479
480 if (new_lun_list_length > list_len) {
481 list_len = new_lun_list_length;
482 os_mem_free(softs, (void *)lun_data, data_len);
483 goto retry;
484 }
485
486 out:
487 *buff = lun_data;
488 DBG_FUNC("OUT\n");
489 return 0;
490
491 error:
492 os_mem_free(softs, (void *)lun_data, data_len);
493 DBG_ERR("FAILED\n");
494 return ret;
495 }
496
497 /*
498 * Function used to get physical and logical device list
499 */
500 static int
501 pqisrc_get_phys_log_device_list(pqisrc_softstate_t *softs,
502 reportlun_data_ext_t **physical_dev_list,
503 reportlun_data_ext_t **logical_dev_list,
504 reportlun_queue_depth_data_t **queue_dev_list,
505 size_t *queue_data_length,
506 size_t *phys_data_length,
507 size_t *log_data_length)
508 {
509 int ret = PQI_STATUS_SUCCESS;
510 size_t logical_list_length;
511 size_t logdev_data_length;
512 size_t data_length;
513 reportlun_data_ext_t *local_logdev_list;
514 reportlun_data_ext_t *logdev_data;
515 reportlun_header_t report_lun_header;
516
517 DBG_FUNC("IN\n");
518
519 ret = pqisrc_get_physical_logical_luns(softs, SA_REPORT_PHYS, physical_dev_list, phys_data_length);
520 if (ret) {
521 DBG_ERR("report physical LUNs failed");
522 return ret;
523 }
524
525 ret = pqisrc_get_physical_logical_luns(softs, SA_REPORT_LOG, logical_dev_list, log_data_length);
526 if (ret) {
527 DBG_ERR("report logical LUNs failed");
528 return ret;
529 }
530
531 ret = pqisrc_get_queue_lun_list(softs, PQI_LOG_EXT_QUEUE_ENABLE, queue_dev_list, queue_data_length);
532 if (ret) {
533 DBG_ERR("report logical LUNs failed");
534 return ret;
535 }
536
537 logdev_data = *logical_dev_list;
538
539 if (logdev_data) {
540 logical_list_length =
541 BE_32(logdev_data->header.list_length);
542 } else {
543 memset(&report_lun_header, 0, sizeof(report_lun_header));
544 logdev_data =
545 (reportlun_data_ext_t *)&report_lun_header;
546 logical_list_length = 0;
547 }
548
549 logdev_data_length = sizeof(reportlun_header_t) +
550 logical_list_length;
551
552 /* Adding LOGICAL device entry for controller */
553 local_logdev_list = os_mem_alloc(softs,
554 logdev_data_length + sizeof(reportlun_ext_entry_t));
555 if (!local_logdev_list) {
556 data_length = *log_data_length;
557 os_mem_free(softs, (char *)*logical_dev_list, data_length);
558 *logical_dev_list = NULL;
559 return PQI_STATUS_FAILURE;
560 }
561
562 memcpy(local_logdev_list, logdev_data, logdev_data_length);
563 memset((uint8_t *)local_logdev_list + logdev_data_length, 0,
564 sizeof(reportlun_ext_entry_t));
565 local_logdev_list->header.list_length = BE_32(logical_list_length +
566 sizeof(reportlun_ext_entry_t));
567 data_length = *log_data_length;
568 os_mem_free(softs, (char *)*logical_dev_list, data_length);
569 *log_data_length = logdev_data_length + sizeof(reportlun_ext_entry_t);
570 *logical_dev_list = local_logdev_list;
571
572 DBG_FUNC("OUT\n");
573
574 return ret;
575 }
576
577 /* Subroutine used to set Bus-Target-Lun for the requested device */
578 static inline void
579 pqisrc_set_btl(pqi_scsi_dev_t *device,
580 int bus, int target, int lun)
581 {
582 DBG_FUNC("IN\n");
583
584 device->bus = bus;
585 device->target = target;
586 device->lun = lun;
587
588 DBG_FUNC("OUT\n");
589 }
590
591 inline
592 boolean_t pqisrc_is_external_raid_device(pqi_scsi_dev_t *device)
593 {
594 return device->is_external_raid_device;
595 }
596
597 static inline boolean_t pqisrc_is_external_raid_addr(uint8_t *scsi3addr)
598 {
599 return scsi3addr[2] != 0;
600 }
601
602 /* Function used to assign Bus-Target-Lun for the requested device */
603 static void
604 pqisrc_assign_btl(pqi_scsi_dev_t *device)
605 {
606 uint8_t *scsi3addr;
607 uint32_t lunid;
608 uint32_t bus;
609 uint32_t target;
610 uint32_t lun;
611 DBG_FUNC("IN\n");
612
613 scsi3addr = device->scsi3addr;
614 lunid = GET_LE32(scsi3addr);
615
616 if (pqisrc_is_hba_lunid(scsi3addr)) {
617 /* The specified device is the controller. */
618 pqisrc_set_btl(device, PQI_HBA_BUS, PQI_CTLR_INDEX, (lunid & 0x3fff) + 1);
619 device->target_lun_valid = true;
620 return;
621 }
622
623 if (pqisrc_is_logical_device(device)) {
624 if (pqisrc_is_external_raid_device(device)) {
625 DBG_DISC("External Raid Device!!!");
626 bus = PQI_EXTERNAL_RAID_VOLUME_BUS;
627 target = (lunid >> 16) & 0x3fff;
628 lun = lunid & 0xff;
629 } else {
630 bus = PQI_RAID_VOLUME_BUS;
631 lun = (lunid & 0x3fff) + 1;
632 target = 0;
633 }
634 pqisrc_set_btl(device, bus, target, lun);
635 device->target_lun_valid = true;
636 return;
637 }
638
639 DBG_FUNC("OUT\n");
640 }
641
642 /* Build and send the internal INQUIRY command to particular device */
643 int
644 pqisrc_send_scsi_inquiry(pqisrc_softstate_t *softs,
645 uint8_t *scsi3addr, uint16_t vpd_page, uint8_t *buff, int buf_len)
646 {
647 int ret = PQI_STATUS_SUCCESS;
648 pqisrc_raid_req_t request;
649 raid_path_error_info_elem_t error_info;
650
651 DBG_FUNC("IN\n");
652
653 memset(&request, 0, sizeof(request));
654 ret = pqisrc_build_send_raid_request(softs, &request, buff, buf_len,
655 SA_INQUIRY, vpd_page, scsi3addr, &error_info);
656
657 DBG_FUNC("OUT\n");
658 return ret;
659 }
660
661 #if 0
662 /* Function used to parse the sense information from response */
663 static void
664 pqisrc_fetch_sense_info(const uint8_t *sense_data,
665 unsigned sense_data_length, uint8_t *sense_key, uint8_t *asc, uint8_t *ascq)
666 {
667 struct sense_header_scsi header;
668
669 DBG_FUNC("IN\n");
670
671 *sense_key = 0;
672 *ascq = 0;
673 *asc = 0;
674
675 if (pqisrc_update_scsi_sense(sense_data, sense_data_length, &header)) {
676 *sense_key = header.sense_key;
677 *asc = header.asc;
678 *ascq = header.ascq;
679 }
680
681 DBG_DISC("sense_key: %x asc: %x ascq: %x\n", *sense_key, *asc, *ascq);
682
683 DBG_FUNC("OUT\n");
684 }
685 #endif
686
687 /* Determine logical volume status from vpd buffer.*/
688 static void pqisrc_get_dev_vol_status(pqisrc_softstate_t *softs,
689 pqi_scsi_dev_t *device)
690 {
691 int ret;
692 uint8_t status = SA_LV_STATUS_VPD_UNSUPPORTED;
693 uint8_t vpd_size = sizeof(vpd_volume_status);
694 uint8_t offline = true;
695 size_t page_length;
696 vpd_volume_status *vpd;
697
698 DBG_FUNC("IN\n");
699
700 vpd = os_mem_alloc(softs, vpd_size);
701 if (vpd == NULL)
702 goto out;
703
704 /* Get the size of the VPD return buff. */
705 ret = pqisrc_send_scsi_inquiry(softs, device->scsi3addr, VPD_PAGE | SA_VPD_LV_STATUS,
706 (uint8_t *)vpd, vpd_size);
707
708 if (ret) {
709 DBG_WARN("Inquiry returned failed status\n");
710 goto out;
711 }
712
713 if (vpd->page_code != SA_VPD_LV_STATUS) {
714 DBG_WARN("Returned invalid buffer\n");
715 goto out;
716 }
717
718 page_length = offsetof(vpd_volume_status, volume_status) + vpd->page_length;
719 if (page_length < vpd_size)
720 goto out;
721
722 status = vpd->volume_status;
723 offline = (vpd->flags & SA_LV_FLAGS_NO_HOST_IO)!=0;
724
725 out:
726 device->volume_offline = offline;
727 device->volume_status = status;
728
729 os_mem_free(softs, (char *)vpd, vpd_size);
730
731 DBG_FUNC("OUT\n");
732
733 return;
734 }
735
736 /* Validate the RAID map parameters */
737 static int
738 pqisrc_raid_map_validation(pqisrc_softstate_t *softs,
739 pqi_scsi_dev_t *device, pqisrc_raid_map_t *raid_map)
740 {
741 char *error_msg;
742 uint32_t raidmap_size;
743 uint32_t r5or6_blocks_per_row;
744
745 DBG_FUNC("IN\n");
746
747 raidmap_size = LE_32(raid_map->structure_size);
748 if (raidmap_size < offsetof(pqisrc_raid_map_t, dev_data)) {
749 error_msg = "RAID map too small\n";
750 goto error;
751 }
752
753 #if 0
754 phys_dev_num = LE_16(raid_map->layout_map_count) *
755 (LE_16(raid_map->data_disks_per_row) +
756 LE_16(raid_map->metadata_disks_per_row));
757 #endif
758
759 if (device->raid_level == SA_RAID_1) {
760 if (LE_16(raid_map->layout_map_count) != 2) {
761 error_msg = "invalid RAID-1 map\n";
762 goto error;
763 }
764 } else if (device->raid_level == SA_RAID_ADM) {
765 if (LE_16(raid_map->layout_map_count) != 3) {
766 error_msg = "invalid RAID-1(triple) map\n";
767 goto error;
768 }
769 } else if ((device->raid_level == SA_RAID_5 ||
770 device->raid_level == SA_RAID_6) &&
771 LE_16(raid_map->layout_map_count) > 1) {
772 /* RAID 50/60 */
773 r5or6_blocks_per_row =
774 LE_16(raid_map->strip_size) *
775 LE_16(raid_map->data_disks_per_row);
776 if (r5or6_blocks_per_row == 0) {
777 error_msg = "invalid RAID-5 or RAID-6 map\n";
778 goto error;
779 }
780 }
781
782 DBG_FUNC("OUT\n");
783
784 return 0;
785
786 error:
787 DBG_NOTE("%s\n", error_msg);
788 return PQI_STATUS_FAILURE;
789 }
790
791 /* Get device raidmap for the requested device */
792 static int
793 pqisrc_get_device_raidmap(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device)
794 {
795 int ret = PQI_STATUS_SUCCESS;
796 int raidmap_size;
797
798 pqisrc_raid_req_t request;
799 pqisrc_raid_map_t *raid_map;
800
801 DBG_FUNC("IN\n");
802
803 raid_map = os_mem_alloc(softs, sizeof(*raid_map));
804 if (!raid_map)
805 return PQI_STATUS_FAILURE;
806
807 memset(&request, 0, sizeof(request));
808 ret = pqisrc_build_send_raid_request(softs, &request, raid_map, sizeof(*raid_map),
809 SA_GET_RAID_MAP, 0, device->scsi3addr, NULL);
810
811 if (ret) {
812 DBG_ERR("error in build send raid req ret=%d\n", ret);
813 goto err_out;
814 }
815
816 raidmap_size = LE_32(raid_map->structure_size);
817 if (raidmap_size > sizeof(*raid_map)) {
818 DBG_NOTE("Raid map is larger than 1024 entries, request once again");
819 os_mem_free(softs, (char*)raid_map, sizeof(*raid_map));
820
821 raid_map = os_mem_alloc(softs, raidmap_size);
822 if (!raid_map)
823 return PQI_STATUS_FAILURE;
824 memset(&request, 0, sizeof(request));
825
826 ret = pqisrc_build_send_raid_request(softs, &request, raid_map, raidmap_size,
827 SA_GET_RAID_MAP, 0, device->scsi3addr, NULL);
828 if (ret) {
829 DBG_ERR("error in build send raid req ret=%d\n", ret);
830 goto err_out;
831 }
832
833 if(LE_32(raid_map->structure_size) != raidmap_size) {
834 DBG_WARN("Expected raid map size %d bytes and got %d bytes\n",
835 raidmap_size,LE_32(raid_map->structure_size));
836 goto err_out;
837 }
838 }
839
840 ret = pqisrc_raid_map_validation(softs, device, raid_map);
841 if (ret) {
842 DBG_NOTE("error in raid map validation ret=%d\n", ret);
843 goto err_out;
844 }
845
846 device->raid_map = raid_map;
847 DBG_FUNC("OUT\n");
848 return 0;
849
850 err_out:
851 os_mem_free(softs, (char*)raid_map, sizeof(*raid_map));
852 DBG_FUNC("FAILED \n");
853 return ret;
854 }
855
856 /* Get device ioaccel_status to validate the type of device */
857 static void
858 pqisrc_get_dev_ioaccel_status(pqisrc_softstate_t *softs,
859 pqi_scsi_dev_t *device)
860 {
861 int ret = PQI_STATUS_SUCCESS;
862 uint8_t *buff;
863 uint8_t ioaccel_status;
864
865 DBG_FUNC("IN\n");
866
867 buff = os_mem_alloc(softs, 64);
868 if (!buff)
869 return;
870
871 ret = pqisrc_send_scsi_inquiry(softs, device->scsi3addr,
872 VPD_PAGE | SA_VPD_LV_IOACCEL_STATUS, buff, 64);
873 if (ret) {
874 DBG_ERR("error in send scsi inquiry ret=%d\n", ret);
875 goto err_out;
876 }
877
878 ioaccel_status = buff[IOACCEL_STATUS_BYTE];
879 device->offload_config =
880 !!(ioaccel_status & OFFLOAD_CONFIGURED_BIT);
881
882 if (device->offload_config) {
883 device->offload_enabled_pending =
884 !!(ioaccel_status & OFFLOAD_ENABLED_BIT);
885 if (pqisrc_get_device_raidmap(softs, device))
886 device->offload_enabled_pending = false;
887 }
888
889 DBG_DISC("offload_config: 0x%x offload_enabled_pending: 0x%x \n",
890 device->offload_config, device->offload_enabled_pending);
891
892 err_out:
893 os_mem_free(softs, (char*)buff, 64);
894 DBG_FUNC("OUT\n");
895 }
896
897 /* Get RAID level of requested device */
898 static void
899 pqisrc_get_dev_raid_level(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device)
900 {
901 uint8_t raid_level;
902 uint8_t *buff;
903
904 DBG_FUNC("IN\n");
905
906 raid_level = SA_RAID_UNKNOWN;
907
908 buff = os_mem_alloc(softs, 64);
909 if (buff) {
910 int ret;
911 ret = pqisrc_send_scsi_inquiry(softs, device->scsi3addr,
912 VPD_PAGE | SA_VPD_LV_DEVICE_GEOMETRY, buff, 64);
913 if (ret == 0) {
914 raid_level = buff[8];
915 if (raid_level > SA_RAID_MAX)
916 raid_level = SA_RAID_UNKNOWN;
917 }
918 os_mem_free(softs, (char*)buff, 64);
919 }
920
921 device->raid_level = raid_level;
922 DBG_DISC("RAID LEVEL: %x \n", raid_level);
923 DBG_FUNC("OUT\n");
924 }
925
926 /* Parse the inquiry response and determine the type of device */
927 static int
928 pqisrc_get_dev_data(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device)
929 {
930 int ret = PQI_STATUS_SUCCESS;
931 uint8_t *inq_buff;
932 int retry = MAX_RETRIES;
933
934 DBG_FUNC("IN\n");
935
936 inq_buff = os_mem_alloc(softs, OBDR_TAPE_INQ_SIZE);
937 if (!inq_buff)
938 return PQI_STATUS_FAILURE;
939
940 while(retry--) {
941 /* Send an inquiry to the device to see what it is. */
942 ret = pqisrc_send_scsi_inquiry(softs, device->scsi3addr, 0, inq_buff,
943 OBDR_TAPE_INQ_SIZE);
944 if (!ret)
945 break;
946 DBG_WARN("Retrying inquiry !!!\n");
947 }
948 if(retry <= 0)
949 goto err_out;
950 pqisrc_sanitize_inquiry_string(&inq_buff[8], 8);
951 pqisrc_sanitize_inquiry_string(&inq_buff[16], 16);
952
953 device->devtype = inq_buff[0] & 0x1f;
954 memcpy(device->vendor, &inq_buff[8],
955 sizeof(device->vendor));
956 memcpy(device->model, &inq_buff[16],
957 sizeof(device->model));
958 DBG_DISC("DEV_TYPE: %x VENDOR: %.8s MODEL: %.16s\n", device->devtype, device->vendor, device->model);
959
960 if (pqisrc_is_logical_device(device) && device->devtype == DISK_DEVICE) {
961 if (pqisrc_is_external_raid_device(device)) {
962 device->raid_level = SA_RAID_UNKNOWN;
963 device->volume_status = SA_LV_OK;
964 device->volume_offline = false;
965 }
966 else {
967 pqisrc_get_dev_raid_level(softs, device);
968 pqisrc_get_dev_ioaccel_status(softs, device);
969 pqisrc_get_dev_vol_status(softs, device);
970 }
971 }
972
973 /*
974 * Check if this is a One-Button-Disaster-Recovery device
975 * by looking for "$DR-10" at offset 43 in the inquiry data.
976 */
977 device->is_obdr_device = (device->devtype == ROM_DEVICE &&
978 memcmp(&inq_buff[OBDR_SIG_OFFSET], OBDR_TAPE_SIG,
979 OBDR_SIG_LEN) == 0);
980 err_out:
981 os_mem_free(softs, (char*)inq_buff, OBDR_TAPE_INQ_SIZE);
982
983 DBG_FUNC("OUT\n");
984 return ret;
985 }
986
987 /*
988 * BMIC (Basic Management And Interface Commands) command
989 * to get the controller identify params
990 */
991 static int
992 pqisrc_identify_ctrl(pqisrc_softstate_t *softs, bmic_ident_ctrl_t *buff)
993 {
994 int ret = PQI_STATUS_SUCCESS;
995 pqisrc_raid_req_t request;
996
997 DBG_FUNC("IN\n");
998
999 memset(&request, 0, sizeof(request));
1000 ret = pqisrc_build_send_raid_request(softs, &request, buff, sizeof(*buff),
1001 BMIC_IDENTIFY_CONTROLLER, 0, (uint8_t *)RAID_CTLR_LUNID, NULL);
1002 DBG_FUNC("OUT\n");
1003
1004 return ret;
1005 }
1006
1007 /* Get the adapter FW version using BMIC_IDENTIFY_CONTROLLER */
1008 int
1009 pqisrc_get_ctrl_fw_version(pqisrc_softstate_t *softs)
1010 {
1011 int ret = PQI_STATUS_SUCCESS;
1012 bmic_ident_ctrl_t *identify_ctrl;
1013
1014 DBG_FUNC("IN\n");
1015
1016 identify_ctrl = os_mem_alloc(softs, sizeof(*identify_ctrl));
1017 if (!identify_ctrl) {
1018 DBG_ERR("failed to allocate memory for identify_ctrl\n");
1019 return PQI_STATUS_FAILURE;
1020 }
1021
1022 memset(identify_ctrl, 0, sizeof(*identify_ctrl));
1023
1024 ret = pqisrc_identify_ctrl(softs, identify_ctrl);
1025 if (ret)
1026 goto out;
1027
1028 softs->fw_build_number = identify_ctrl->fw_build_number;
1029 memcpy(softs->fw_version, identify_ctrl->fw_version,
1030 sizeof(identify_ctrl->fw_version));
1031 softs->fw_version[sizeof(identify_ctrl->fw_version)] = '\0';
1032 snprintf(softs->fw_version +
1033 strlen(softs->fw_version),
1034 sizeof(softs->fw_version),
1035 "-%u", identify_ctrl->fw_build_number);
1036 out:
1037 os_mem_free(softs, (char *)identify_ctrl, sizeof(*identify_ctrl));
1038 DBG_NOTE("Firmware version: %s Firmware build number: %d\n", softs->fw_version, softs->fw_build_number);
1039 DBG_FUNC("OUT\n");
1040 return ret;
1041 }
1042
1043 /* BMIC command to determine scsi device identify params */
1044 static int
1045 pqisrc_identify_physical_disk(pqisrc_softstate_t *softs,
1046 pqi_scsi_dev_t *device,
1047 bmic_ident_physdev_t *buff,
1048 int buf_len)
1049 {
1050 int ret = PQI_STATUS_SUCCESS;
1051 uint16_t bmic_device_index;
1052 pqisrc_raid_req_t request;
1053
1054
1055 DBG_FUNC("IN\n");
1056
1057 memset(&request, 0, sizeof(request));
1058 bmic_device_index = BMIC_GET_DRIVE_NUMBER(device->scsi3addr);
1059 request.cdb[2] = (uint8_t)bmic_device_index;
1060 request.cdb[9] = (uint8_t)(bmic_device_index >> 8);
1061
1062 ret = pqisrc_build_send_raid_request(softs, &request, buff, buf_len,
1063 BMIC_IDENTIFY_PHYSICAL_DEVICE, 0, (uint8_t *)RAID_CTLR_LUNID, NULL);
1064 DBG_FUNC("OUT\n");
1065 return ret;
1066 }
1067
1068 /*
1069 * Function used to get the scsi device information using one of BMIC
1070 * BMIC_IDENTIFY_PHYSICAL_DEVICE
1071 */
1072 static void
1073 pqisrc_get_physical_device_info(pqisrc_softstate_t *softs,
1074 pqi_scsi_dev_t *device,
1075 bmic_ident_physdev_t *id_phys)
1076 {
1077 int ret = PQI_STATUS_SUCCESS;
1078
1079 DBG_FUNC("IN\n");
1080 memset(id_phys, 0, sizeof(*id_phys));
1081
1082 ret= pqisrc_identify_physical_disk(softs, device,
1083 id_phys, sizeof(*id_phys));
1084 if (ret) {
1085 device->queue_depth = PQI_PHYSICAL_DISK_DEFAULT_MAX_QUEUE_DEPTH;
1086 return;
1087 }
1088
1089 device->queue_depth =
1090 LE_16(id_phys->current_queue_depth_limit);
1091 device->device_type = id_phys->device_type;
1092 device->active_path_index = id_phys->active_path_number;
1093 device->path_map = id_phys->redundant_path_present_map;
1094 memcpy(&device->box,
1095 &id_phys->alternate_paths_phys_box_on_port,
1096 sizeof(device->box));
1097 memcpy(&device->phys_connector,
1098 &id_phys->alternate_paths_phys_connector,
1099 sizeof(device->phys_connector));
1100 device->bay = id_phys->phys_bay_in_box;
1101
1102 DBG_DISC("BMIC DEV_TYPE: %x QUEUE DEPTH: 0x%x \n", device->device_type, device->queue_depth);
1103 DBG_FUNC("OUT\n");
1104 }
1105
1106
1107 /* Function used to find the entry of the device in a list */
1108 static
1109 device_status_t pqisrc_scsi_find_entry(pqisrc_softstate_t *softs,
1110 pqi_scsi_dev_t *device_to_find, pqi_scsi_dev_t **same_device)
1111 {
1112 pqi_scsi_dev_t *device;
1113 int i,j;
1114 DBG_FUNC("IN\n");
1115 for(i = 0; i < PQI_MAX_DEVICES; i++) {
1116 for(j = 0; j < PQI_MAX_MULTILUN; j++) {
1117 if(softs->device_list[i][j] == NULL)
1118 continue;
1119 device = softs->device_list[i][j];
1120 if (pqisrc_scsi3addr_equal(device_to_find->scsi3addr,
1121 device->scsi3addr)) {
1122 *same_device = device;
1123 if (pqisrc_device_equal(device_to_find, device)) {
1124 if (device_to_find->volume_offline)
1125 return DEVICE_CHANGED;
1126 return DEVICE_UNCHANGED;
1127 }
1128 return DEVICE_CHANGED;
1129 }
1130 }
1131 }
1132 DBG_FUNC("OUT\n");
1133
1134 return DEVICE_NOT_FOUND;
1135 }
1136
1137
1138 /* Update the newly added devices as existed device */
1139 static void
1140 pqisrc_exist_device_update(pqisrc_softstate_t *softs,
1141 pqi_scsi_dev_t *device_exist, pqi_scsi_dev_t *new_device)
1142 {
1143 DBG_FUNC("IN\n");
1144 device_exist->expose_device = new_device->expose_device;
1145 memcpy(device_exist->vendor, new_device->vendor,
1146 sizeof(device_exist->vendor));
1147 memcpy(device_exist->model, new_device->model,
1148 sizeof(device_exist->model));
1149 device_exist->is_physical_device = new_device->is_physical_device;
1150 device_exist->is_external_raid_device =
1151 new_device->is_external_raid_device;
1152
1153 if ((device_exist->volume_status == SA_LV_QUEUED_FOR_EXPANSION ||
1154 device_exist->volume_status == SA_LV_UNDERGOING_EXPANSION) &&
1155 new_device->volume_status == SA_LV_OK) {
1156 device_exist->scsi_rescan = true;
1157 }
1158
1159 device_exist->sas_address = new_device->sas_address;
1160 device_exist->raid_level = new_device->raid_level;
1161 device_exist->queue_depth = new_device->queue_depth;
1162 device_exist->ioaccel_handle = new_device->ioaccel_handle;
1163 device_exist->volume_status = new_device->volume_status;
1164 device_exist->active_path_index = new_device->active_path_index;
1165 device_exist->path_map = new_device->path_map;
1166 device_exist->bay = new_device->bay;
1167 memcpy(device_exist->box, new_device->box,
1168 sizeof(device_exist->box));
1169 memcpy(device_exist->phys_connector, new_device->phys_connector,
1170 sizeof(device_exist->phys_connector));
1171 device_exist->offload_config = new_device->offload_config;
1172 device_exist->offload_enabled_pending =
1173 new_device->offload_enabled_pending;
1174 device_exist->offload_to_mirror = 0;
1175 if (device_exist->raid_map)
1176 os_mem_free(softs,
1177 (char *)device_exist->raid_map,
1178 sizeof(*device_exist->raid_map));
1179 device_exist->raid_map = new_device->raid_map;
1180 /* To prevent this from being freed later. */
1181 new_device->raid_map = NULL;
1182 DBG_FUNC("OUT\n");
1183 }
1184
1185 /* Validate the ioaccel_handle for a newly added device */
1186 static
1187 pqi_scsi_dev_t *pqisrc_identify_device_via_ioaccel(
1188 pqisrc_softstate_t *softs, uint32_t ioaccel_handle)
1189 {
1190 pqi_scsi_dev_t *device;
1191 int i,j;
1192 DBG_FUNC("IN\n");
1193 for(i = 0; i < PQI_MAX_DEVICES; i++) {
1194 for(j = 0; j < PQI_MAX_MULTILUN; j++) {
1195 if(softs->device_list[i][j] == NULL)
1196 continue;
1197 device = softs->device_list[i][j];
1198 if (device->devtype != DISK_DEVICE)
1199 continue;
1200 if (pqisrc_is_logical_device(device))
1201 continue;
1202 if (device->ioaccel_handle == ioaccel_handle)
1203 return device;
1204 }
1205 }
1206 DBG_FUNC("OUT\n");
1207
1208 return NULL;
1209 }
1210
1211 /* Get the scsi device queue depth */
1212 static void
1213 pqisrc_update_log_dev_qdepth(pqisrc_softstate_t *softs)
1214 {
1215 unsigned i;
1216 unsigned phys_dev_num;
1217 unsigned num_raidmap_entries;
1218 unsigned queue_depth;
1219 pqisrc_raid_map_t *raid_map;
1220 pqi_scsi_dev_t *device;
1221 raidmap_data_t *dev_data;
1222 pqi_scsi_dev_t *phys_disk;
1223 unsigned j;
1224 unsigned k;
1225
1226 DBG_FUNC("IN\n");
1227
1228 for(i = 0; i < PQI_MAX_DEVICES; i++) {
1229 for(j = 0; j < PQI_MAX_MULTILUN; j++) {
1230 if(softs->device_list[i][j] == NULL)
1231 continue;
1232 device = softs->device_list[i][j];
1233 if (device->devtype != DISK_DEVICE)
1234 continue;
1235 if (!pqisrc_is_logical_device(device))
1236 continue;
1237 if (pqisrc_is_external_raid_device(device))
1238 continue;
1239 device->queue_depth = PQI_LOGICAL_DISK_DEFAULT_MAX_QUEUE_DEPTH;
1240 raid_map = device->raid_map;
1241 if (!raid_map)
1242 return;
1243 dev_data = raid_map->dev_data;
1244 phys_dev_num = LE_16(raid_map->layout_map_count) *
1245 (LE_16(raid_map->data_disks_per_row) +
1246 LE_16(raid_map->metadata_disks_per_row));
1247 num_raidmap_entries = phys_dev_num *
1248 LE_16(raid_map->row_cnt);
1249
1250 queue_depth = 0;
1251 for (k = 0; k < num_raidmap_entries; k++) {
1252 phys_disk = pqisrc_identify_device_via_ioaccel(softs,
1253 dev_data[k].ioaccel_handle);
1254
1255 if (!phys_disk) {
1256 DBG_WARN(
1257 "Failed to find physical disk handle for logical drive %016llx\n",
1258 (unsigned long long)BE_64(device->scsi3addr[0]));
1259 device->offload_enabled = false;
1260 device->offload_enabled_pending = false;
1261 if (raid_map)
1262 os_mem_free(softs, (char *)raid_map, sizeof(*raid_map));
1263 device->raid_map = NULL;
1264 return;
1265 }
1266
1267 queue_depth += phys_disk->queue_depth;
1268 }
1269
1270 device->queue_depth = queue_depth;
1271 } /* end inner loop */
1272 }/* end outer loop */
1273 DBG_FUNC("OUT\n");
1274 }
1275
1276 /* Function used to add a scsi device to OS scsi subsystem */
1277 static int
1278 pqisrc_add_device(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device)
1279 {
1280 DBG_FUNC("IN\n");
1281 DBG_NOTE("vendor: %s model: %s bus:%d target:%d lun:%d is_physical_device:0x%x expose_device:0x%x volume_offline 0x%x volume_status 0x%x \n",
1282 device->vendor, device->model, device->bus, device->target, device->lun, device->is_physical_device, device->expose_device, device->volume_offline, device->volume_status);
1283
1284 device->invalid = false;
1285
1286 if(device->expose_device) {
1287 pqisrc_init_device_active_io(softs, device);
1288 /* TBD: Call OS upper layer function to add the device entry */
1289 os_add_device(softs,device);
1290 }
1291 DBG_FUNC("OUT\n");
1292 return PQI_STATUS_SUCCESS;
1293
1294 }
1295
1296 /* Function used to remove a scsi device from OS scsi subsystem */
1297 void
1298 pqisrc_remove_device(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device)
1299 {
1300 DBG_FUNC("IN\n");
1301 DBG_NOTE("vendor: %s model: %s bus:%d target:%d lun:%d is_physical_device:0x%x expose_device:0x%x volume_offline 0x%x volume_status 0x%x \n",
1302 device->vendor, device->model, device->bus, device->target, device->lun, device->is_physical_device, device->expose_device, device->volume_offline, device->volume_status);
1303
1304 device->invalid = true;
1305 if (device->expose_device == false) {
1306 /*Masked physical devices are not been exposed to storage stack.
1307 *Hence, free the masked device resources such as
1308 *device memory, Target ID,etc., here.
1309 */
1310 DBG_NOTE("Deallocated Masked Device Resources.\n");
1311 pqisrc_free_device(softs,device);
1312 return;
1313 }
1314 /* Wait for device outstanding Io's */
1315 pqisrc_wait_for_device_commands_to_complete(softs, device);
1316 /* Call OS upper layer function to remove the exposed device entry */
1317 os_remove_device(softs,device);
1318 DBG_FUNC("OUT\n");
1319 }
1320
1321 /*
1322 * When exposing new device to OS fails then adjst list according to the
1323 * mid scsi list
1324 */
1325 static void
1326 pqisrc_adjust_list(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device)
1327 {
1328 DBG_FUNC("IN\n");
1329
1330 if (!device) {
1331 DBG_ERR("softs = %p: device is NULL !!!\n", softs);
1332 return;
1333 }
1334
1335 OS_ACQUIRE_SPINLOCK(&softs->devlist_lock);
1336 softs->device_list[device->target][device->lun] = NULL;
1337 OS_RELEASE_SPINLOCK(&softs->devlist_lock);
1338 pqisrc_device_mem_free(softs, device);
1339
1340 DBG_FUNC("OUT\n");
1341 }
1342
1343 /* Debug routine used to display the RAID volume status of the device */
1344 static void
1345 pqisrc_display_volume_status(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device)
1346 {
1347 char *status;
1348
1349 DBG_FUNC("IN\n");
1350 switch (device->volume_status) {
1351 case SA_LV_OK:
1352 status = "Volume is online.";
1353 break;
1354 case SA_LV_UNDERGOING_ERASE:
1355 status = "Volume is undergoing background erase process.";
1356 break;
1357 case SA_LV_NOT_AVAILABLE:
1358 status = "Volume is waiting for transforming volume.";
1359 break;
1360 case SA_LV_UNDERGOING_RPI:
1361 status = "Volume is undergoing rapid parity initialization process.";
1362 break;
1363 case SA_LV_PENDING_RPI:
1364 status = "Volume is queued for rapid parity initialization process.";
1365 break;
1366 case SA_LV_ENCRYPTED_NO_KEY:
1367 status = "Volume is encrypted and cannot be accessed because key is not present.";
1368 break;
1369 case SA_LV_PLAINTEXT_IN_ENCRYPT_ONLY_CONTROLLER:
1370 status = "Volume is not encrypted and cannot be accessed because controller is in encryption-only mode.";
1371 break;
1372 case SA_LV_UNDERGOING_ENCRYPTION:
1373 status = "Volume is undergoing encryption process.";
1374 break;
1375 case SA_LV_UNDERGOING_ENCRYPTION_REKEYING:
1376 status = "Volume is undergoing encryption re-keying process.";
1377 break;
1378 case SA_LV_ENCRYPTED_IN_NON_ENCRYPTED_CONTROLLER:
1379 status = "Volume is encrypted and cannot be accessed because controller does not have encryption enabled.";
1380 break;
1381 case SA_LV_PENDING_ENCRYPTION:
1382 status = "Volume is pending migration to encrypted state, but process has not started.";
1383 break;
1384 case SA_LV_PENDING_ENCRYPTION_REKEYING:
1385 status = "Volume is encrypted and is pending encryption rekeying.";
1386 break;
1387 case SA_LV_STATUS_VPD_UNSUPPORTED:
1388 status = "Volume status is not available through vital product data pages.";
1389 break;
1390 case SA_LV_UNDERGOING_EXPANSION:
1391 status = "Volume undergoing expansion";
1392 break;
1393 case SA_LV_QUEUED_FOR_EXPANSION:
1394 status = "Volume queued for expansion";
1395 case SA_LV_EJECTED:
1396 status = "Volume ejected";
1397 break;
1398 case SA_LV_WRONG_PHYSICAL_DRIVE_REPLACED:
1399 status = "Volume has wrong physical drive replaced";
1400 break;
1401 case SA_LV_DISABLED_SCSI_ID_CONFLICT:
1402 status = "Volume disabled scsi id conflict";
1403 break;
1404 case SA_LV_HARDWARE_HAS_OVERHEATED:
1405 status = "Volume hardware has over heated";
1406 break;
1407 case SA_LV_HARDWARE_OVERHEATING:
1408 status = "Volume hardware over heating";
1409 break;
1410 case SA_LV_PHYSICAL_DRIVE_CONNECTION_PROBLEM:
1411 status = "Volume physical drive connection problem";
1412 break;
1413 default:
1414 status = "Volume is in an unknown state.";
1415 break;
1416 }
1417
1418 DBG_DISC("scsi BTL %d:%d:%d %s\n",
1419 device->bus, device->target, device->lun, status);
1420 DBG_FUNC("OUT\n");
1421 }
1422
1423 void
1424 pqisrc_device_mem_free(pqisrc_softstate_t *softs, pqi_scsi_dev_t *device)
1425 {
1426 DBG_FUNC("IN\n");
1427 if (!device)
1428 return;
1429 if (device->raid_map) {
1430 os_mem_free(softs, (char *)device->raid_map, sizeof(pqisrc_raid_map_t));
1431 }
1432 os_mem_free(softs, (char *)device,sizeof(*device));
1433 DBG_FUNC("OUT\n");
1434
1435 }
1436
1437 /* OS should call this function to free the scsi device */
1438 void
1439 pqisrc_free_device(pqisrc_softstate_t * softs,pqi_scsi_dev_t *device)
1440 {
1441 rcb_t *rcb;
1442 int i;
1443
1444 /* Clear the "device" field in the rcb.
1445 * Response coming after device removal shouldn't access this field
1446 */
1447 for(i = 1; i <= softs->max_outstanding_io; i++)
1448 {
1449 rcb = &softs->rcb[i];
1450 if(rcb->dvp == device) {
1451 DBG_WARN("Pending requests for the removing device\n");
1452 rcb->dvp = NULL;
1453 }
1454 }
1455
1456 OS_ACQUIRE_SPINLOCK(&softs->devlist_lock);
1457
1458 if (!pqisrc_is_logical_device(device)) {
1459 pqisrc_free_tid(softs,device->target);
1460 }
1461
1462 softs->device_list[device->target][device->lun] = NULL;
1463
1464 pqisrc_device_mem_free(softs, device);
1465
1466 OS_RELEASE_SPINLOCK(&softs->devlist_lock);
1467
1468 }
1469
1470 /* Update the newly added devices to the device list */
1471 static void
1472 pqisrc_update_device_list(pqisrc_softstate_t *softs,
1473 pqi_scsi_dev_t *new_device_list[], int num_new_devices)
1474 {
1475 int ret;
1476 int i;
1477 device_status_t dev_status;
1478 pqi_scsi_dev_t *device;
1479 pqi_scsi_dev_t *same_device;
1480 pqi_scsi_dev_t **added = NULL;
1481 pqi_scsi_dev_t **removed = NULL;
1482 int nadded = 0, nremoved = 0;
1483 int j;
1484 int tid = 0;
1485 boolean_t driver_queue_depth_flag = false;
1486
1487 DBG_FUNC("IN\n");
1488
1489 added = os_mem_alloc(softs, sizeof(*added) * PQI_MAX_DEVICES);
1490 removed = os_mem_alloc(softs, sizeof(*removed) * PQI_MAX_DEVICES);
1491
1492 if (!added || !removed) {
1493 DBG_WARN("Out of memory \n");
1494 goto free_and_out;
1495 }
1496
1497 OS_ACQUIRE_SPINLOCK(&softs->devlist_lock);
1498
1499 for(i = 0; i < PQI_MAX_DEVICES; i++) {
1500 for(j = 0; j < PQI_MAX_MULTILUN; j++) {
1501 if(softs->device_list[i][j] == NULL)
1502 continue;
1503 device = softs->device_list[i][j];
1504 device->device_gone = true;
1505 }
1506 }
1507 DBG_IO("Device list used an array\n");
1508 for (i = 0; i < num_new_devices; i++) {
1509 device = new_device_list[i];
1510
1511 dev_status = pqisrc_scsi_find_entry(softs, device,
1512 &same_device);
1513
1514 switch (dev_status) {
1515 case DEVICE_UNCHANGED:
1516 /* New Device present in existing device list */
1517 device->new_device = false;
1518 same_device->device_gone = false;
1519 pqisrc_exist_device_update(softs, same_device, device);
1520 break;
1521 case DEVICE_NOT_FOUND:
1522 /* Device not found in existing list */
1523 device->new_device = true;
1524 break;
1525 case DEVICE_CHANGED:
1526 /* Actual device gone need to add device to list*/
1527 device->new_device = true;
1528 break;
1529 default:
1530 break;
1531 }
1532 }
1533 /* Process all devices that have gone away. */
1534 for(i = 0, nremoved = 0; i < PQI_MAX_DEVICES; i++) {
1535 for(j = 0; j < PQI_MAX_MULTILUN; j++) {
1536 if(softs->device_list[i][j] == NULL)
1537 continue;
1538 device = softs->device_list[i][j];
1539 if (device->device_gone) {
1540 softs->device_list[device->target][device->lun] = NULL;
1541 removed[nremoved] = device;
1542 nremoved++;
1543 }
1544 }
1545 }
1546
1547 /* Process all new devices. */
1548 for (i = 0, nadded = 0; i < num_new_devices; i++) {
1549 device = new_device_list[i];
1550 if (!device->new_device)
1551 continue;
1552 if (device->volume_offline)
1553 continue;
1554
1555 /* physical device */
1556 if (!pqisrc_is_logical_device(device)) {
1557 tid = pqisrc_alloc_tid(softs);
1558 if(INVALID_ELEM != tid)
1559 pqisrc_set_btl(device, PQI_PHYSICAL_DEVICE_BUS, tid, 0);
1560 }
1561
1562 /* This is not expected. We may lose the reference to the old device entry.
1563 * If the target & lun ids are same, it is supposed to detect as an existing
1564 * device, and not as a new device
1565 */
1566 if(softs->device_list[device->target][device->lun] != NULL) {
1567 DBG_WARN("Overwriting T : %d L :%d\n",device->target,device->lun);
1568 }
1569
1570 softs->device_list[device->target][device->lun] = device;
1571
1572 DBG_DISC("Added device %p at B : %d T : %d L : %d\n",device,
1573 device->bus,device->target,device->lun);
1574 /* To prevent this entry from being freed later. */
1575 new_device_list[i] = NULL;
1576 added[nadded] = device;
1577 nadded++;
1578 }
1579
1580
1581 for(i = 0; i < PQI_MAX_DEVICES; i++) {
1582 for(j = 0; j < PQI_MAX_MULTILUN; j++) {
1583 if(softs->device_list[i][j] == NULL)
1584 continue;
1585 device = softs->device_list[i][j];
1586 device->offload_enabled = device->offload_enabled_pending;
1587 }
1588 }
1589
1590 OS_RELEASE_SPINLOCK(&softs->devlist_lock);
1591
1592 for(i = 0; i < nremoved; i++) {
1593 device = removed[i];
1594 if (device == NULL)
1595 continue;
1596 pqisrc_display_device_info(softs, "removed", device);
1597 pqisrc_remove_device(softs, device);
1598
1599 }
1600
1601 for(i = 0; i < PQI_MAX_DEVICES; i++) {
1602 for(j = 0; j < PQI_MAX_MULTILUN; j++) {
1603 if(softs->device_list[i][j] == NULL)
1604 continue;
1605 device = softs->device_list[i][j];
1606 /*
1607 * Notify the OS upper layer if the queue depth of any existing device has
1608 * changed.
1609 */
1610 if (device->queue_depth !=
1611 device->advertised_queue_depth) {
1612 device->advertised_queue_depth = device->queue_depth;
1613 /* TBD: Call OS upper layer function to change device Q depth */
1614 }
1615 if (device->firmware_queue_depth_set == false)
1616 driver_queue_depth_flag = true;
1617 if (device->scsi_rescan)
1618 os_rescan_target(softs, device);
1619 }
1620 }
1621 /*
1622 * If firmware queue depth is corrupt or not working
1623 * use driver method to re-calculate the queue depth
1624 * for all logical devices
1625 */
1626 if (driver_queue_depth_flag)
1627 pqisrc_update_log_dev_qdepth(softs);
1628
1629 for(i = 0; i < nadded; i++) {
1630 device = added[i];
1631 if (device->expose_device) {
1632 ret = pqisrc_add_device(softs, device);
1633 if (ret) {
1634 DBG_WARN("scsi %d:%d:%d addition failed, device not added\n",
1635 device->bus, device->target,
1636 device->lun);
1637 pqisrc_adjust_list(softs, device);
1638 continue;
1639 }
1640 }
1641
1642 pqisrc_display_device_info(softs, "added", device);
1643 }
1644
1645 /* Process all volumes that are offline. */
1646 for (i = 0; i < num_new_devices; i++) {
1647 device = new_device_list[i];
1648 if (!device)
1649 continue;
1650 if (!device->new_device)
1651 continue;
1652 if (device->volume_offline) {
1653 pqisrc_display_volume_status(softs, device);
1654 pqisrc_display_device_info(softs, "offline", device);
1655 }
1656 }
1657
1658 free_and_out:
1659 if (added)
1660 os_mem_free(softs, (char *)added,
1661 sizeof(*added) * PQI_MAX_DEVICES);
1662 if (removed)
1663 os_mem_free(softs, (char *)removed,
1664 sizeof(*removed) * PQI_MAX_DEVICES);
1665
1666 DBG_FUNC("OUT\n");
1667 }
1668
1669 /*
1670 * Let the Adapter know about driver version using one of BMIC
1671 * BMIC_WRITE_HOST_WELLNESS
1672 */
1673 int
1674 pqisrc_write_driver_version_to_host_wellness(pqisrc_softstate_t *softs)
1675 {
1676 int rval = PQI_STATUS_SUCCESS;
1677 struct bmic_host_wellness_driver_version *host_wellness_driver_ver;
1678 size_t data_length;
1679 pqisrc_raid_req_t request;
1680
1681 DBG_FUNC("IN\n");
1682
1683 memset(&request, 0, sizeof(request));
1684 data_length = sizeof(*host_wellness_driver_ver);
1685
1686 host_wellness_driver_ver = os_mem_alloc(softs, data_length);
1687 if (!host_wellness_driver_ver) {
1688 DBG_ERR("failed to allocate memory for host wellness driver_version\n");
1689 return PQI_STATUS_FAILURE;
1690 }
1691
1692 host_wellness_driver_ver->start_tag[0] = '<';
1693 host_wellness_driver_ver->start_tag[1] = 'H';
1694 host_wellness_driver_ver->start_tag[2] = 'W';
1695 host_wellness_driver_ver->start_tag[3] = '>';
1696 host_wellness_driver_ver->driver_version_tag[0] = 'D';
1697 host_wellness_driver_ver->driver_version_tag[1] = 'V';
1698 host_wellness_driver_ver->driver_version_length = LE_16(sizeof(host_wellness_driver_ver->driver_version));
1699 strncpy(host_wellness_driver_ver->driver_version, softs->os_name,
1700 sizeof(host_wellness_driver_ver->driver_version));
1701 if (strlen(softs->os_name) < sizeof(host_wellness_driver_ver->driver_version) ) {
1702 strncpy(host_wellness_driver_ver->driver_version + strlen(softs->os_name), PQISRC_DRIVER_VERSION,
1703 sizeof(host_wellness_driver_ver->driver_version) - strlen(softs->os_name));
1704 } else {
1705 DBG_DISC("OS name length(%lu) is longer than buffer of driver_version\n",
1706 strlen(softs->os_name));
1707
1708 }
1709 host_wellness_driver_ver->driver_version[sizeof(host_wellness_driver_ver->driver_version) - 1] = '\0';
1710 host_wellness_driver_ver->end_tag[0] = 'Z';
1711 host_wellness_driver_ver->end_tag[1] = 'Z';
1712
1713 rval = pqisrc_build_send_raid_request(softs, &request, host_wellness_driver_ver,data_length,
1714 BMIC_WRITE_HOST_WELLNESS, 0, (uint8_t *)RAID_CTLR_LUNID, NULL);
1715
1716 os_mem_free(softs, (char *)host_wellness_driver_ver, data_length);
1717
1718 DBG_FUNC("OUT");
1719 return rval;
1720 }
1721
1722 /*
1723 * Write current RTC time from host to the adapter using
1724 * BMIC_WRITE_HOST_WELLNESS
1725 */
1726 int
1727 pqisrc_write_current_time_to_host_wellness(pqisrc_softstate_t *softs)
1728 {
1729 int rval = PQI_STATUS_SUCCESS;
1730 struct bmic_host_wellness_time *host_wellness_time;
1731 size_t data_length;
1732 pqisrc_raid_req_t request;
1733
1734 DBG_FUNC("IN\n");
1735
1736 memset(&request, 0, sizeof(request));
1737 data_length = sizeof(*host_wellness_time);
1738
1739 host_wellness_time = os_mem_alloc(softs, data_length);
1740 if (!host_wellness_time) {
1741 DBG_ERR("failed to allocate memory for host wellness time structure\n");
1742 return PQI_STATUS_FAILURE;
1743 }
1744
1745 host_wellness_time->start_tag[0] = '<';
1746 host_wellness_time->start_tag[1] = 'H';
1747 host_wellness_time->start_tag[2] = 'W';
1748 host_wellness_time->start_tag[3] = '>';
1749 host_wellness_time->time_tag[0] = 'T';
1750 host_wellness_time->time_tag[1] = 'D';
1751 host_wellness_time->time_length = LE_16(offsetof(struct bmic_host_wellness_time, time_length) -
1752 offsetof(struct bmic_host_wellness_time, century));
1753
1754 os_get_time(host_wellness_time);
1755
1756 host_wellness_time->dont_write_tag[0] = 'D';
1757 host_wellness_time->dont_write_tag[1] = 'W';
1758 host_wellness_time->end_tag[0] = 'Z';
1759 host_wellness_time->end_tag[1] = 'Z';
1760
1761 rval = pqisrc_build_send_raid_request(softs, &request, host_wellness_time,data_length,
1762 BMIC_WRITE_HOST_WELLNESS, 0, (uint8_t *)RAID_CTLR_LUNID, NULL);
1763
1764 os_mem_free(softs, (char *)host_wellness_time, data_length);
1765
1766 DBG_FUNC("OUT");
1767 return rval;
1768 }
1769
1770 /*
1771 * Function used to perform a rescan of scsi devices
1772 * for any config change events
1773 */
1774 int
1775 pqisrc_scan_devices(pqisrc_softstate_t *softs)
1776 {
1777 boolean_t is_physical_device;
1778 int ret = PQI_STATUS_FAILURE;
1779 int i;
1780 int new_dev_cnt;
1781 int phy_log_dev_cnt;
1782 size_t queue_log_data_length;
1783 uint8_t *scsi3addr;
1784 uint8_t multiplier;
1785 uint16_t qdepth;
1786 uint32_t physical_cnt;
1787 uint32_t logical_cnt;
1788 uint32_t logical_queue_cnt;
1789 uint32_t ndev_allocated = 0;
1790 size_t phys_data_length, log_data_length;
1791 reportlun_data_ext_t *physical_dev_list = NULL;
1792 reportlun_data_ext_t *logical_dev_list = NULL;
1793 reportlun_ext_entry_t *lun_ext_entry = NULL;
1794 reportlun_queue_depth_data_t *logical_queue_dev_list = NULL;
1795 bmic_ident_physdev_t *bmic_phy_info = NULL;
1796 pqi_scsi_dev_t **new_device_list = NULL;
1797 pqi_scsi_dev_t *device = NULL;
1798
1799
1800 DBG_FUNC("IN\n");
1801
1802 ret = pqisrc_get_phys_log_device_list(softs, &physical_dev_list, &logical_dev_list,
1803 &logical_queue_dev_list, &queue_log_data_length,
1804 &phys_data_length, &log_data_length);
1805
1806 if (ret)
1807 goto err_out;
1808
1809 physical_cnt = BE_32(physical_dev_list->header.list_length)
1810 / sizeof(physical_dev_list->lun_entries[0]);
1811
1812 logical_cnt = BE_32(logical_dev_list->header.list_length)
1813 / sizeof(logical_dev_list->lun_entries[0]);
1814
1815 logical_queue_cnt = BE_32(logical_queue_dev_list->header.list_length)
1816 / sizeof(logical_queue_dev_list->lun_entries[0]);
1817
1818
1819 DBG_DISC("physical_cnt %d logical_cnt %d queue_cnt %d\n", physical_cnt, logical_cnt, logical_queue_cnt);
1820
1821 if (physical_cnt) {
1822 bmic_phy_info = os_mem_alloc(softs, sizeof(*bmic_phy_info));
1823 if (bmic_phy_info == NULL) {
1824 ret = PQI_STATUS_FAILURE;
1825 DBG_ERR("failed to allocate memory for BMIC ID PHYS Device : %d\n", ret);
1826 goto err_out;
1827 }
1828 }
1829 phy_log_dev_cnt = physical_cnt + logical_cnt;
1830 new_device_list = os_mem_alloc(softs,
1831 sizeof(*new_device_list) * phy_log_dev_cnt);
1832
1833 if (new_device_list == NULL) {
1834 ret = PQI_STATUS_FAILURE;
1835 DBG_ERR("failed to allocate memory for device list : %d\n", ret);
1836 goto err_out;
1837 }
1838
1839 for (i = 0; i < phy_log_dev_cnt; i++) {
1840 new_device_list[i] = os_mem_alloc(softs,
1841 sizeof(*new_device_list[i]));
1842 if (new_device_list[i] == NULL) {
1843 ret = PQI_STATUS_FAILURE;
1844 DBG_ERR("failed to allocate memory for device list : %d\n", ret);
1845 ndev_allocated = i;
1846 goto err_out;
1847 }
1848 }
1849
1850 ndev_allocated = phy_log_dev_cnt;
1851 new_dev_cnt = 0;
1852 for (i = 0; i < phy_log_dev_cnt; i++) {
1853
1854 if (i < physical_cnt) {
1855 is_physical_device = true;
1856 lun_ext_entry = &physical_dev_list->lun_entries[i];
1857 } else {
1858 is_physical_device = false;
1859 lun_ext_entry =
1860 &logical_dev_list->lun_entries[i - physical_cnt];
1861 }
1862
1863 scsi3addr = lun_ext_entry->lunid;
1864
1865 /* Save the target sas adderess for external raid device */
1866 if(lun_ext_entry->device_type == CONTROLLER_DEVICE) {
1867 int target = lun_ext_entry->lunid[3] & 0x3f;
1868 softs->target_sas_addr[target] = BE_64(lun_ext_entry->wwid);
1869 }
1870
1871 /* Skip masked physical non-disk devices. */
1872 if (MASKED_DEVICE(scsi3addr) && is_physical_device
1873 && (lun_ext_entry->ioaccel_handle == 0))
1874 continue;
1875
1876 device = new_device_list[new_dev_cnt];
1877 memset(device, 0, sizeof(*device));
1878 memcpy(device->scsi3addr, scsi3addr, sizeof(device->scsi3addr));
1879 device->wwid = lun_ext_entry->wwid;
1880 device->is_physical_device = is_physical_device;
1881 if (!is_physical_device && logical_queue_cnt--) {
1882 device->is_external_raid_device =
1883 pqisrc_is_external_raid_addr(scsi3addr);
1884 /* The multiplier is the value we multiply the queue
1885 * depth value with to get the actual queue depth.
1886 * If multiplier is 1 multiply by 256 if
1887 * multiplier 0 then multiply by 16 */
1888 multiplier = logical_queue_dev_list->lun_entries[i - physical_cnt].multiplier;
1889 qdepth = logical_queue_dev_list->lun_entries[i - physical_cnt].queue_depth;
1890 if (multiplier) {
1891 device->firmware_queue_depth_set = true;
1892 device->queue_depth = qdepth*256;
1893 } else {
1894 device->firmware_queue_depth_set = true;
1895 device->queue_depth = qdepth*16;
1896 }
1897 if (device->queue_depth > softs->adapterQDepth) {
1898 device->firmware_queue_depth_set = true;
1899 device->queue_depth = softs->adapterQDepth;
1900 }
1901 if ((multiplier == 1) &&
1902 (qdepth <= 0 || qdepth >= MAX_RAW_M256_QDEPTH))
1903 device->firmware_queue_depth_set = false;
1904 if ((multiplier == 0) &&
1905 (qdepth <= 0 || qdepth >= MAX_RAW_M16_QDEPTH))
1906 device->firmware_queue_depth_set = false;
1907 }
1908
1909
1910 /* Get device type, vendor, model, device ID. */
1911 ret = pqisrc_get_dev_data(softs, device);
1912 if (ret) {
1913 DBG_WARN("Inquiry failed, skipping device %016llx\n",
1914 (unsigned long long)BE_64(device->scsi3addr[0]));
1915 DBG_DISC("INQUIRY FAILED \n");
1916 continue;
1917 }
1918 /* Set controller queue depth to what
1919 * it was from the scsi midlayer */
1920 if (device->devtype == RAID_DEVICE) {
1921 device->firmware_queue_depth_set = true;
1922 device->queue_depth = softs->adapterQDepth;
1923 }
1924 pqisrc_assign_btl(device);
1925
1926 /*
1927 * Expose all devices except for physical devices that
1928 * are masked.
1929 */
1930 if (device->is_physical_device &&
1931 MASKED_DEVICE(scsi3addr))
1932 device->expose_device = false;
1933 else
1934 device->expose_device = true;
1935
1936 if (device->is_physical_device &&
1937 (lun_ext_entry->device_flags &
1938 REPORT_LUN_DEV_FLAG_AIO_ENABLED) &&
1939 lun_ext_entry->ioaccel_handle) {
1940 device->aio_enabled = true;
1941 }
1942 switch (device->devtype) {
1943 case ROM_DEVICE:
1944 /*
1945 * We don't *really* support actual CD-ROM devices,
1946 * but we do support the HP "One Button Disaster
1947 * Recovery" tape drive which temporarily pretends to
1948 * be a CD-ROM drive.
1949 */
1950 if (device->is_obdr_device)
1951 new_dev_cnt++;
1952 break;
1953 case DISK_DEVICE:
1954 case ZBC_DEVICE:
1955 if (device->is_physical_device) {
1956 device->ioaccel_handle =
1957 lun_ext_entry->ioaccel_handle;
1958 device->sas_address = BE_64(lun_ext_entry->wwid);
1959 pqisrc_get_physical_device_info(softs, device,
1960 bmic_phy_info);
1961 }
1962 new_dev_cnt++;
1963 break;
1964 case ENCLOSURE_DEVICE:
1965 if (device->is_physical_device) {
1966 device->sas_address = BE_64(lun_ext_entry->wwid);
1967 }
1968 new_dev_cnt++;
1969 break;
1970 case TAPE_DEVICE:
1971 case MEDIUM_CHANGER_DEVICE:
1972 new_dev_cnt++;
1973 break;
1974 case RAID_DEVICE:
1975 /*
1976 * Only present the HBA controller itself as a RAID
1977 * controller. If it's a RAID controller other than
1978 * the HBA itself (an external RAID controller, MSA500
1979 * or similar), don't present it.
1980 */
1981 if (pqisrc_is_hba_lunid(scsi3addr))
1982 new_dev_cnt++;
1983 break;
1984 case SES_DEVICE:
1985 case CONTROLLER_DEVICE:
1986 default:
1987 break;
1988 }
1989 }
1990 DBG_DISC("new_dev_cnt %d\n", new_dev_cnt);
1991
1992 pqisrc_update_device_list(softs, new_device_list, new_dev_cnt);
1993
1994 err_out:
1995 if (new_device_list) {
1996 for (i = 0; i < ndev_allocated; i++) {
1997 if (new_device_list[i]) {
1998 if(new_device_list[i]->raid_map)
1999 os_mem_free(softs, (char *)new_device_list[i]->raid_map,
2000 sizeof(pqisrc_raid_map_t));
2001 os_mem_free(softs, (char*)new_device_list[i],
2002 sizeof(*new_device_list[i]));
2003 }
2004 }
2005 os_mem_free(softs, (char *)new_device_list,
2006 sizeof(*new_device_list) * ndev_allocated);
2007 }
2008 if(physical_dev_list)
2009 os_mem_free(softs, (char *)physical_dev_list, phys_data_length);
2010 if(logical_dev_list)
2011 os_mem_free(softs, (char *)logical_dev_list, log_data_length);
2012 if(logical_queue_dev_list)
2013 os_mem_free(softs, (char*)logical_queue_dev_list,
2014 queue_log_data_length);
2015 if (bmic_phy_info)
2016 os_mem_free(softs, (char *)bmic_phy_info, sizeof(*bmic_phy_info));
2017
2018 DBG_FUNC("OUT \n");
2019
2020 return ret;
2021 }
2022
2023 /*
2024 * Clean up memory allocated for devices.
2025 */
2026 void
2027 pqisrc_cleanup_devices(pqisrc_softstate_t *softs)
2028 {
2029
2030 int i = 0,j = 0;
2031 pqi_scsi_dev_t *dvp = NULL;
2032 DBG_FUNC("IN\n");
2033
2034 for(i = 0; i < PQI_MAX_DEVICES; i++) {
2035 for(j = 0; j < PQI_MAX_MULTILUN; j++) {
2036 if (softs->device_list[i][j] == NULL)
2037 continue;
2038 dvp = softs->device_list[i][j];
2039 pqisrc_device_mem_free(softs, dvp);
2040 }
2041 }
2042 DBG_FUNC("OUT\n");
2043 }
Cache object: f17ad60cf6f6fc5fed079ff74c7f68e8
|