1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * driver for Microsemi PQI-based storage controllers 4 * Copyright (c) 2019-2020 Microchip Technology Inc. and its subsidiaries 5 * Copyright (c) 2016-2018 Microsemi Corporation 6 * Copyright (c) 2016 PMC-Sierra, Inc. 7 * 8 * Questions/Comments/Bugfixes to storagedev@microchip.com 9 * 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/bsg-lib.h> 14 #include <scsi/scsi_host.h> 15 #include <scsi/scsi_cmnd.h> 16 #include <scsi/scsi_transport_sas.h> 17 #include <asm/unaligned.h> 18 #include "smartpqi.h" 19 20 static struct pqi_sas_phy *pqi_alloc_sas_phy(struct pqi_sas_port *pqi_sas_port) 21 { 22 struct pqi_sas_phy *pqi_sas_phy; 23 struct sas_phy *phy; 24 25 pqi_sas_phy = kzalloc(sizeof(*pqi_sas_phy), GFP_KERNEL); 26 if (!pqi_sas_phy) 27 return NULL; 28 29 phy = sas_phy_alloc(pqi_sas_port->parent_node->parent_dev, 30 pqi_sas_port->next_phy_index); 31 if (!phy) { 32 kfree(pqi_sas_phy); 33 return NULL; 34 } 35 36 pqi_sas_port->next_phy_index++; 37 pqi_sas_phy->phy = phy; 38 pqi_sas_phy->parent_port = pqi_sas_port; 39 40 return pqi_sas_phy; 41 } 42 43 static void pqi_free_sas_phy(struct pqi_sas_phy *pqi_sas_phy) 44 { 45 struct sas_phy *phy = pqi_sas_phy->phy; 46 47 sas_port_delete_phy(pqi_sas_phy->parent_port->port, phy); 48 if (pqi_sas_phy->added_to_port) 49 list_del(&pqi_sas_phy->phy_list_entry); 50 sas_phy_delete(phy); 51 kfree(pqi_sas_phy); 52 } 53 54 static int pqi_sas_port_add_phy(struct pqi_sas_phy *pqi_sas_phy) 55 { 56 int rc; 57 struct pqi_sas_port *pqi_sas_port; 58 struct sas_phy *phy; 59 struct sas_identify *identify; 60 61 pqi_sas_port = pqi_sas_phy->parent_port; 62 phy = pqi_sas_phy->phy; 63 64 identify = &phy->identify; 65 memset(identify, 0, sizeof(*identify)); 66 identify->sas_address = pqi_sas_port->sas_address; 67 identify->device_type = SAS_END_DEVICE; 68 identify->initiator_port_protocols = SAS_PROTOCOL_STP; 69 identify->target_port_protocols = SAS_PROTOCOL_STP; 70 phy->minimum_linkrate_hw = SAS_LINK_RATE_UNKNOWN; 71 phy->maximum_linkrate_hw = SAS_LINK_RATE_UNKNOWN; 72 phy->minimum_linkrate = SAS_LINK_RATE_UNKNOWN; 73 phy->maximum_linkrate = SAS_LINK_RATE_UNKNOWN; 74 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN; 75 76 rc = sas_phy_add(pqi_sas_phy->phy); 77 if (rc) 78 return rc; 79 80 sas_port_add_phy(pqi_sas_port->port, pqi_sas_phy->phy); 81 list_add_tail(&pqi_sas_phy->phy_list_entry, 82 &pqi_sas_port->phy_list_head); 83 pqi_sas_phy->added_to_port = true; 84 85 return 0; 86 } 87 88 static int pqi_sas_port_add_rphy(struct pqi_sas_port *pqi_sas_port, 89 struct sas_rphy *rphy) 90 { 91 struct sas_identify *identify; 92 93 identify = &rphy->identify; 94 identify->sas_address = pqi_sas_port->sas_address; 95 96 if (pqi_sas_port->device && 97 pqi_sas_port->device->is_expander_smp_device) { 98 identify->initiator_port_protocols = SAS_PROTOCOL_SMP; 99 identify->target_port_protocols = SAS_PROTOCOL_SMP; 100 } else { 101 identify->initiator_port_protocols = SAS_PROTOCOL_STP; 102 identify->target_port_protocols = SAS_PROTOCOL_STP; 103 } 104 105 return sas_rphy_add(rphy); 106 } 107 108 static struct sas_rphy *pqi_sas_rphy_alloc(struct pqi_sas_port *pqi_sas_port) 109 { 110 if (pqi_sas_port->device && 111 pqi_sas_port->device->is_expander_smp_device) 112 return sas_expander_alloc(pqi_sas_port->port, 113 SAS_FANOUT_EXPANDER_DEVICE); 114 115 return sas_end_device_alloc(pqi_sas_port->port); 116 } 117 118 static struct pqi_sas_port *pqi_alloc_sas_port( 119 struct pqi_sas_node *pqi_sas_node, u64 sas_address, 120 struct pqi_scsi_dev *device) 121 { 122 int rc; 123 struct pqi_sas_port *pqi_sas_port; 124 struct sas_port *port; 125 126 pqi_sas_port = kzalloc(sizeof(*pqi_sas_port), GFP_KERNEL); 127 if (!pqi_sas_port) 128 return NULL; 129 130 INIT_LIST_HEAD(&pqi_sas_port->phy_list_head); 131 pqi_sas_port->parent_node = pqi_sas_node; 132 133 port = sas_port_alloc_num(pqi_sas_node->parent_dev); 134 if (!port) 135 goto free_pqi_port; 136 137 rc = sas_port_add(port); 138 if (rc) 139 goto free_sas_port; 140 141 pqi_sas_port->port = port; 142 pqi_sas_port->sas_address = sas_address; 143 pqi_sas_port->device = device; 144 list_add_tail(&pqi_sas_port->port_list_entry, 145 &pqi_sas_node->port_list_head); 146 147 return pqi_sas_port; 148 149 free_sas_port: 150 sas_port_free(port); 151 free_pqi_port: 152 kfree(pqi_sas_port); 153 154 return NULL; 155 } 156 157 static void pqi_free_sas_port(struct pqi_sas_port *pqi_sas_port) 158 { 159 struct pqi_sas_phy *pqi_sas_phy; 160 struct pqi_sas_phy *next; 161 162 list_for_each_entry_safe(pqi_sas_phy, next, 163 &pqi_sas_port->phy_list_head, phy_list_entry) 164 pqi_free_sas_phy(pqi_sas_phy); 165 166 sas_port_delete(pqi_sas_port->port); 167 list_del(&pqi_sas_port->port_list_entry); 168 kfree(pqi_sas_port); 169 } 170 171 static struct pqi_sas_node *pqi_alloc_sas_node(struct device *parent_dev) 172 { 173 struct pqi_sas_node *pqi_sas_node; 174 175 pqi_sas_node = kzalloc(sizeof(*pqi_sas_node), GFP_KERNEL); 176 if (pqi_sas_node) { 177 pqi_sas_node->parent_dev = parent_dev; 178 INIT_LIST_HEAD(&pqi_sas_node->port_list_head); 179 } 180 181 return pqi_sas_node; 182 } 183 184 static void pqi_free_sas_node(struct pqi_sas_node *pqi_sas_node) 185 { 186 struct pqi_sas_port *pqi_sas_port; 187 struct pqi_sas_port *next; 188 189 if (!pqi_sas_node) 190 return; 191 192 list_for_each_entry_safe(pqi_sas_port, next, 193 &pqi_sas_node->port_list_head, port_list_entry) 194 pqi_free_sas_port(pqi_sas_port); 195 196 kfree(pqi_sas_node); 197 } 198 199 struct pqi_scsi_dev *pqi_find_device_by_sas_rphy( 200 struct pqi_ctrl_info *ctrl_info, struct sas_rphy *rphy) 201 { 202 struct pqi_scsi_dev *device; 203 204 list_for_each_entry(device, &ctrl_info->scsi_device_list, 205 scsi_device_list_entry) { 206 if (!device->sas_port) 207 continue; 208 if (device->sas_port->rphy == rphy) 209 return device; 210 } 211 212 return NULL; 213 } 214 215 int pqi_add_sas_host(struct Scsi_Host *shost, struct pqi_ctrl_info *ctrl_info) 216 { 217 int rc; 218 struct device *parent_dev; 219 struct pqi_sas_node *pqi_sas_node; 220 struct pqi_sas_port *pqi_sas_port; 221 struct pqi_sas_phy *pqi_sas_phy; 222 223 parent_dev = &shost->shost_dev; 224 225 pqi_sas_node = pqi_alloc_sas_node(parent_dev); 226 if (!pqi_sas_node) 227 return -ENOMEM; 228 229 pqi_sas_port = pqi_alloc_sas_port(pqi_sas_node, 230 ctrl_info->sas_address, NULL); 231 if (!pqi_sas_port) { 232 rc = -ENODEV; 233 goto free_sas_node; 234 } 235 236 pqi_sas_phy = pqi_alloc_sas_phy(pqi_sas_port); 237 if (!pqi_sas_phy) { 238 rc = -ENODEV; 239 goto free_sas_port; 240 } 241 242 rc = pqi_sas_port_add_phy(pqi_sas_phy); 243 if (rc) 244 goto free_sas_phy; 245 246 ctrl_info->sas_host = pqi_sas_node; 247 248 return 0; 249 250 free_sas_phy: 251 pqi_free_sas_phy(pqi_sas_phy); 252 free_sas_port: 253 pqi_free_sas_port(pqi_sas_port); 254 free_sas_node: 255 pqi_free_sas_node(pqi_sas_node); 256 257 return rc; 258 } 259 260 void pqi_delete_sas_host(struct pqi_ctrl_info *ctrl_info) 261 { 262 pqi_free_sas_node(ctrl_info->sas_host); 263 } 264 265 int pqi_add_sas_device(struct pqi_sas_node *pqi_sas_node, 266 struct pqi_scsi_dev *device) 267 { 268 int rc; 269 struct pqi_sas_port *pqi_sas_port; 270 struct sas_rphy *rphy; 271 272 pqi_sas_port = pqi_alloc_sas_port(pqi_sas_node, 273 device->sas_address, device); 274 if (!pqi_sas_port) 275 return -ENOMEM; 276 277 rphy = pqi_sas_rphy_alloc(pqi_sas_port); 278 if (!rphy) { 279 rc = -ENODEV; 280 goto free_sas_port; 281 } 282 283 pqi_sas_port->rphy = rphy; 284 device->sas_port = pqi_sas_port; 285 286 rc = pqi_sas_port_add_rphy(pqi_sas_port, rphy); 287 if (rc) 288 goto free_sas_port; 289 290 return 0; 291 292 free_sas_port: 293 pqi_free_sas_port(pqi_sas_port); 294 device->sas_port = NULL; 295 296 return rc; 297 } 298 299 void pqi_remove_sas_device(struct pqi_scsi_dev *device) 300 { 301 if (device->sas_port) { 302 pqi_free_sas_port(device->sas_port); 303 device->sas_port = NULL; 304 } 305 } 306 307 static int pqi_sas_get_linkerrors(struct sas_phy *phy) 308 { 309 return 0; 310 } 311 312 static int pqi_sas_get_enclosure_identifier(struct sas_rphy *rphy, 313 u64 *identifier) 314 { 315 int rc; 316 unsigned long flags; 317 struct Scsi_Host *shost; 318 struct pqi_ctrl_info *ctrl_info; 319 struct pqi_scsi_dev *found_device; 320 struct pqi_scsi_dev *device; 321 322 if (!rphy) 323 return -ENODEV; 324 325 shost = rphy_to_shost(rphy); 326 ctrl_info = shost_to_hba(shost); 327 spin_lock_irqsave(&ctrl_info->scsi_device_list_lock, flags); 328 found_device = pqi_find_device_by_sas_rphy(ctrl_info, rphy); 329 330 if (!found_device) { 331 rc = -ENODEV; 332 goto out; 333 } 334 335 if (found_device->devtype == TYPE_ENCLOSURE) { 336 *identifier = get_unaligned_be64(&found_device->wwid); 337 rc = 0; 338 goto out; 339 } 340 341 if (found_device->box_index == 0xff || 342 found_device->phys_box_on_bus == 0 || 343 found_device->bay == 0xff) { 344 rc = -EINVAL; 345 goto out; 346 } 347 348 list_for_each_entry(device, &ctrl_info->scsi_device_list, 349 scsi_device_list_entry) { 350 if (device->devtype == TYPE_ENCLOSURE && 351 device->box_index == found_device->box_index && 352 device->phys_box_on_bus == 353 found_device->phys_box_on_bus && 354 memcmp(device->phys_connector, 355 found_device->phys_connector, 2) == 0) { 356 *identifier = 357 get_unaligned_be64(&device->wwid); 358 rc = 0; 359 goto out; 360 } 361 } 362 363 if (found_device->phy_connected_dev_type != SA_DEVICE_TYPE_CONTROLLER) { 364 rc = -EINVAL; 365 goto out; 366 } 367 368 list_for_each_entry(device, &ctrl_info->scsi_device_list, 369 scsi_device_list_entry) { 370 if (device->devtype == TYPE_ENCLOSURE && 371 CISS_GET_DRIVE_NUMBER(device->scsi3addr) == 372 PQI_VSEP_CISS_BTL) { 373 *identifier = get_unaligned_be64(&device->wwid); 374 rc = 0; 375 goto out; 376 } 377 } 378 379 rc = -EINVAL; 380 out: 381 spin_unlock_irqrestore(&ctrl_info->scsi_device_list_lock, flags); 382 383 return rc; 384 } 385 386 static int pqi_sas_get_bay_identifier(struct sas_rphy *rphy) 387 { 388 int rc; 389 unsigned long flags; 390 struct pqi_ctrl_info *ctrl_info; 391 struct pqi_scsi_dev *device; 392 struct Scsi_Host *shost; 393 394 if (!rphy) 395 return -ENODEV; 396 397 shost = rphy_to_shost(rphy); 398 ctrl_info = shost_to_hba(shost); 399 spin_lock_irqsave(&ctrl_info->scsi_device_list_lock, flags); 400 device = pqi_find_device_by_sas_rphy(ctrl_info, rphy); 401 402 if (!device) { 403 rc = -ENODEV; 404 goto out; 405 } 406 407 if (device->bay == 0xff) 408 rc = -EINVAL; 409 else 410 rc = device->bay; 411 412 out: 413 spin_unlock_irqrestore(&ctrl_info->scsi_device_list_lock, flags); 414 415 return rc; 416 } 417 418 static int pqi_sas_phy_reset(struct sas_phy *phy, int hard_reset) 419 { 420 return 0; 421 } 422 423 static int pqi_sas_phy_enable(struct sas_phy *phy, int enable) 424 { 425 return 0; 426 } 427 428 static int pqi_sas_phy_setup(struct sas_phy *phy) 429 { 430 return 0; 431 } 432 433 static void pqi_sas_phy_release(struct sas_phy *phy) 434 { 435 } 436 437 static int pqi_sas_phy_speed(struct sas_phy *phy, 438 struct sas_phy_linkrates *rates) 439 { 440 return -EINVAL; 441 } 442 443 #define CSMI_IOCTL_TIMEOUT 60 444 #define SMP_CRC_FIELD_LENGTH 4 445 446 static struct bmic_csmi_smp_passthru_buffer * 447 pqi_build_csmi_smp_passthru_buffer(struct sas_rphy *rphy, 448 struct bsg_job *job) 449 { 450 struct bmic_csmi_smp_passthru_buffer *smp_buf; 451 struct bmic_csmi_ioctl_header *ioctl_header; 452 struct bmic_csmi_smp_passthru *parameters; 453 u32 req_size; 454 u32 resp_size; 455 456 smp_buf = kzalloc(sizeof(*smp_buf), GFP_KERNEL); 457 if (!smp_buf) 458 return NULL; 459 460 req_size = job->request_payload.payload_len; 461 resp_size = job->reply_payload.payload_len; 462 463 ioctl_header = &smp_buf->ioctl_header; 464 put_unaligned_le32(sizeof(smp_buf->ioctl_header), 465 &ioctl_header->header_length); 466 put_unaligned_le32(CSMI_IOCTL_TIMEOUT, &ioctl_header->timeout); 467 put_unaligned_le32(CSMI_CC_SAS_SMP_PASSTHRU, 468 &ioctl_header->control_code); 469 put_unaligned_le32(sizeof(smp_buf->parameters), &ioctl_header->length); 470 471 parameters = &smp_buf->parameters; 472 parameters->phy_identifier = rphy->identify.phy_identifier; 473 parameters->port_identifier = 0; 474 parameters->connection_rate = 0; 475 put_unaligned_be64(rphy->identify.sas_address, 476 ¶meters->destination_sas_address); 477 478 if (req_size > SMP_CRC_FIELD_LENGTH) 479 req_size -= SMP_CRC_FIELD_LENGTH; 480 481 put_unaligned_le32(req_size, ¶meters->request_length); 482 put_unaligned_le32(resp_size, ¶meters->response_length); 483 484 sg_copy_to_buffer(job->request_payload.sg_list, 485 job->reply_payload.sg_cnt, ¶meters->request, 486 req_size); 487 488 return smp_buf; 489 } 490 491 static unsigned int pqi_build_sas_smp_handler_reply( 492 struct bmic_csmi_smp_passthru_buffer *smp_buf, struct bsg_job *job, 493 struct pqi_raid_error_info *error_info) 494 { 495 sg_copy_from_buffer(job->reply_payload.sg_list, 496 job->reply_payload.sg_cnt, &smp_buf->parameters.response, 497 le32_to_cpu(smp_buf->parameters.response_length)); 498 499 job->reply_len = le16_to_cpu(error_info->sense_data_length); 500 memcpy(job->reply, error_info->data, 501 le16_to_cpu(error_info->sense_data_length)); 502 503 return job->reply_payload.payload_len - 504 get_unaligned_le32(&error_info->data_in_transferred); 505 } 506 507 void pqi_sas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost, 508 struct sas_rphy *rphy) 509 { 510 int rc; 511 struct pqi_ctrl_info *ctrl_info; 512 struct bmic_csmi_smp_passthru_buffer *smp_buf; 513 struct pqi_raid_error_info error_info; 514 unsigned int reslen = 0; 515 516 ctrl_info = shost_to_hba(shost); 517 518 if (job->reply_payload.payload_len == 0) { 519 rc = -ENOMEM; 520 goto out; 521 } 522 523 if (!rphy) { 524 rc = -EINVAL; 525 goto out; 526 } 527 528 if (rphy->identify.device_type != SAS_FANOUT_EXPANDER_DEVICE) { 529 rc = -EINVAL; 530 goto out; 531 } 532 533 if (job->request_payload.sg_cnt > 1 || job->reply_payload.sg_cnt > 1) { 534 rc = -EINVAL; 535 goto out; 536 } 537 538 smp_buf = pqi_build_csmi_smp_passthru_buffer(rphy, job); 539 if (!smp_buf) { 540 rc = -ENOMEM; 541 goto out; 542 } 543 544 rc = pqi_csmi_smp_passthru(ctrl_info, smp_buf, sizeof(*smp_buf), 545 &error_info); 546 if (rc) 547 goto out; 548 549 reslen = pqi_build_sas_smp_handler_reply(smp_buf, job, &error_info); 550 out: 551 bsg_job_done(job, rc, reslen); 552 pqi_ctrl_unbusy(ctrl_info); 553 } 554 struct sas_function_template pqi_sas_transport_functions = { 555 .get_linkerrors = pqi_sas_get_linkerrors, 556 .get_enclosure_identifier = pqi_sas_get_enclosure_identifier, 557 .get_bay_identifier = pqi_sas_get_bay_identifier, 558 .phy_reset = pqi_sas_phy_reset, 559 .phy_enable = pqi_sas_phy_enable, 560 .phy_setup = pqi_sas_phy_setup, 561 .phy_release = pqi_sas_phy_release, 562 .set_phy_speed = pqi_sas_phy_speed, 563 .smp_handler = pqi_sas_smp_handler, 564 }; 565