1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * SCSI Enclosure Services 4 * 5 * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com> 6 */ 7 8 #include <linux/slab.h> 9 #include <linux/module.h> 10 #include <linux/kernel.h> 11 #include <linux/enclosure.h> 12 #include <linux/unaligned.h> 13 14 #include <scsi/scsi.h> 15 #include <scsi/scsi_cmnd.h> 16 #include <scsi/scsi_dbg.h> 17 #include <scsi/scsi_device.h> 18 #include <scsi/scsi_driver.h> 19 #include <scsi/scsi_host.h> 20 21 #include <scsi/scsi_transport_sas.h> 22 23 struct ses_device { 24 unsigned char *page1; 25 unsigned char *page1_types; 26 unsigned char *page2; 27 unsigned char *page10; 28 short page1_len; 29 short page1_num_types; 30 short page2_len; 31 short page10_len; 32 }; 33 34 struct ses_component { 35 u64 addr; 36 }; 37 38 static bool ses_page2_supported(struct enclosure_device *edev) 39 { 40 struct ses_device *ses_dev = edev->scratch; 41 42 return (ses_dev->page2 != NULL); 43 } 44 45 static int ses_probe(struct scsi_device *sdev) 46 { 47 int err = -ENODEV; 48 49 if (sdev->type != TYPE_ENCLOSURE) 50 goto out; 51 52 err = 0; 53 sdev_printk(KERN_NOTICE, sdev, "Attached Enclosure device\n"); 54 55 out: 56 return err; 57 } 58 59 #define SES_TIMEOUT (30 * HZ) 60 #define SES_RETRIES 3 61 62 static void init_device_slot_control(unsigned char *dest_desc, 63 struct enclosure_component *ecomp, 64 unsigned char *status) 65 { 66 memcpy(dest_desc, status, 4); 67 dest_desc[0] = 0; 68 /* only clear byte 1 for ENCLOSURE_COMPONENT_DEVICE */ 69 if (ecomp->type == ENCLOSURE_COMPONENT_DEVICE) 70 dest_desc[1] = 0; 71 dest_desc[2] &= 0xde; 72 dest_desc[3] &= 0x3c; 73 } 74 75 76 static int ses_recv_diag(struct scsi_device *sdev, int page_code, 77 void *buf, int bufflen) 78 { 79 int ret; 80 unsigned char cmd[] = { 81 RECEIVE_DIAGNOSTIC, 82 1, /* Set PCV bit */ 83 page_code, 84 bufflen >> 8, 85 bufflen & 0xff, 86 0 87 }; 88 unsigned char recv_page_code; 89 struct scsi_failure failure_defs[] = { 90 { 91 .sense = UNIT_ATTENTION, 92 .asc = 0x29, 93 .ascq = SCMD_FAILURE_ASCQ_ANY, 94 .allowed = SES_RETRIES, 95 .result = SAM_STAT_CHECK_CONDITION, 96 }, 97 { 98 .sense = NOT_READY, 99 .asc = SCMD_FAILURE_ASC_ANY, 100 .ascq = SCMD_FAILURE_ASCQ_ANY, 101 .allowed = SES_RETRIES, 102 .result = SAM_STAT_CHECK_CONDITION, 103 }, 104 {} 105 }; 106 struct scsi_failures failures = { 107 .failure_definitions = failure_defs, 108 }; 109 const struct scsi_exec_args exec_args = { 110 .failures = &failures, 111 }; 112 113 ret = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_IN, buf, bufflen, 114 SES_TIMEOUT, 1, &exec_args); 115 if (unlikely(ret)) 116 return ret; 117 118 recv_page_code = ((unsigned char *)buf)[0]; 119 120 if (likely(recv_page_code == page_code)) 121 return ret; 122 123 /* successful diagnostic but wrong page code. This happens to some 124 * USB devices, just print a message and pretend there was an error */ 125 126 sdev_printk(KERN_ERR, sdev, 127 "Wrong diagnostic page; asked for %d got %u\n", 128 page_code, recv_page_code); 129 130 return -EINVAL; 131 } 132 133 static int ses_send_diag(struct scsi_device *sdev, int page_code, 134 void *buf, int bufflen) 135 { 136 int result; 137 138 unsigned char cmd[] = { 139 SEND_DIAGNOSTIC, 140 0x10, /* Set PF bit */ 141 0, 142 bufflen >> 8, 143 bufflen & 0xff, 144 0 145 }; 146 struct scsi_failure failure_defs[] = { 147 { 148 .sense = UNIT_ATTENTION, 149 .asc = 0x29, 150 .ascq = SCMD_FAILURE_ASCQ_ANY, 151 .allowed = SES_RETRIES, 152 .result = SAM_STAT_CHECK_CONDITION, 153 }, 154 { 155 .sense = NOT_READY, 156 .asc = SCMD_FAILURE_ASC_ANY, 157 .ascq = SCMD_FAILURE_ASCQ_ANY, 158 .allowed = SES_RETRIES, 159 .result = SAM_STAT_CHECK_CONDITION, 160 }, 161 {} 162 }; 163 struct scsi_failures failures = { 164 .failure_definitions = failure_defs, 165 }; 166 const struct scsi_exec_args exec_args = { 167 .failures = &failures, 168 }; 169 170 result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_OUT, buf, bufflen, 171 SES_TIMEOUT, 1, &exec_args); 172 if (result) 173 sdev_printk(KERN_ERR, sdev, "SEND DIAGNOSTIC result: %8x\n", 174 result); 175 return result; 176 } 177 178 static int ses_set_page2_descriptor(struct enclosure_device *edev, 179 struct enclosure_component *ecomp, 180 unsigned char *desc) 181 { 182 int i, j, count = 0, descriptor = ecomp->number; 183 struct scsi_device *sdev = to_scsi_device(edev->edev.parent); 184 struct ses_device *ses_dev = edev->scratch; 185 unsigned char *type_ptr = ses_dev->page1_types; 186 unsigned char *desc_ptr = ses_dev->page2 + 8; 187 188 /* Clear everything */ 189 memset(desc_ptr, 0, ses_dev->page2_len - 8); 190 for (i = 0; i < ses_dev->page1_num_types; i++, type_ptr += 4) { 191 for (j = 0; j < type_ptr[1]; j++) { 192 desc_ptr += 4; 193 if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE && 194 type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE) 195 continue; 196 if (count++ == descriptor) { 197 memcpy(desc_ptr, desc, 4); 198 /* set select */ 199 desc_ptr[0] |= 0x80; 200 /* clear reserved, just in case */ 201 desc_ptr[0] &= 0xf0; 202 } 203 } 204 } 205 206 return ses_send_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len); 207 } 208 209 static unsigned char *ses_get_page2_descriptor(struct enclosure_device *edev, 210 struct enclosure_component *ecomp) 211 { 212 int i, j, count = 0, descriptor = ecomp->number; 213 struct scsi_device *sdev = to_scsi_device(edev->edev.parent); 214 struct ses_device *ses_dev = edev->scratch; 215 unsigned char *type_ptr = ses_dev->page1_types; 216 unsigned char *desc_ptr = ses_dev->page2 + 8; 217 218 if (ses_recv_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len) < 0) 219 return NULL; 220 221 for (i = 0; i < ses_dev->page1_num_types; i++, type_ptr += 4) { 222 for (j = 0; j < type_ptr[1]; j++) { 223 desc_ptr += 4; 224 if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE && 225 type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE) 226 continue; 227 if (count++ == descriptor) 228 return desc_ptr; 229 } 230 } 231 return NULL; 232 } 233 234 /* For device slot and array device slot elements, byte 3 bit 6 235 * is "fault sensed" while byte 3 bit 5 is "fault reqstd". As this 236 * code stands these bits are shifted 4 positions right so in 237 * sysfs they will appear as bits 2 and 1 respectively. Strange. */ 238 static void ses_get_fault(struct enclosure_device *edev, 239 struct enclosure_component *ecomp) 240 { 241 unsigned char *desc; 242 243 if (!ses_page2_supported(edev)) { 244 ecomp->fault = 0; 245 return; 246 } 247 desc = ses_get_page2_descriptor(edev, ecomp); 248 if (desc) 249 ecomp->fault = (desc[3] & 0x60) >> 4; 250 } 251 252 static int ses_set_fault(struct enclosure_device *edev, 253 struct enclosure_component *ecomp, 254 enum enclosure_component_setting val) 255 { 256 unsigned char desc[4]; 257 unsigned char *desc_ptr; 258 259 if (!ses_page2_supported(edev)) 260 return -EINVAL; 261 262 desc_ptr = ses_get_page2_descriptor(edev, ecomp); 263 264 if (!desc_ptr) 265 return -EIO; 266 267 init_device_slot_control(desc, ecomp, desc_ptr); 268 269 switch (val) { 270 case ENCLOSURE_SETTING_DISABLED: 271 desc[3] &= 0xdf; 272 break; 273 case ENCLOSURE_SETTING_ENABLED: 274 desc[3] |= 0x20; 275 break; 276 default: 277 /* SES doesn't do the SGPIO blink settings */ 278 return -EINVAL; 279 } 280 281 return ses_set_page2_descriptor(edev, ecomp, desc); 282 } 283 284 static void ses_get_status(struct enclosure_device *edev, 285 struct enclosure_component *ecomp) 286 { 287 unsigned char *desc; 288 289 if (!ses_page2_supported(edev)) { 290 ecomp->status = 0; 291 return; 292 } 293 desc = ses_get_page2_descriptor(edev, ecomp); 294 if (desc) 295 ecomp->status = (desc[0] & 0x0f); 296 } 297 298 static void ses_get_locate(struct enclosure_device *edev, 299 struct enclosure_component *ecomp) 300 { 301 unsigned char *desc; 302 303 if (!ses_page2_supported(edev)) { 304 ecomp->locate = 0; 305 return; 306 } 307 desc = ses_get_page2_descriptor(edev, ecomp); 308 if (desc) 309 ecomp->locate = (desc[2] & 0x02) ? 1 : 0; 310 } 311 312 static int ses_set_locate(struct enclosure_device *edev, 313 struct enclosure_component *ecomp, 314 enum enclosure_component_setting val) 315 { 316 unsigned char desc[4]; 317 unsigned char *desc_ptr; 318 319 if (!ses_page2_supported(edev)) 320 return -EINVAL; 321 322 desc_ptr = ses_get_page2_descriptor(edev, ecomp); 323 324 if (!desc_ptr) 325 return -EIO; 326 327 init_device_slot_control(desc, ecomp, desc_ptr); 328 329 switch (val) { 330 case ENCLOSURE_SETTING_DISABLED: 331 desc[2] &= 0xfd; 332 break; 333 case ENCLOSURE_SETTING_ENABLED: 334 desc[2] |= 0x02; 335 break; 336 default: 337 /* SES doesn't do the SGPIO blink settings */ 338 return -EINVAL; 339 } 340 return ses_set_page2_descriptor(edev, ecomp, desc); 341 } 342 343 static int ses_set_active(struct enclosure_device *edev, 344 struct enclosure_component *ecomp, 345 enum enclosure_component_setting val) 346 { 347 unsigned char desc[4]; 348 unsigned char *desc_ptr; 349 350 if (!ses_page2_supported(edev)) 351 return -EINVAL; 352 353 desc_ptr = ses_get_page2_descriptor(edev, ecomp); 354 355 if (!desc_ptr) 356 return -EIO; 357 358 init_device_slot_control(desc, ecomp, desc_ptr); 359 360 switch (val) { 361 case ENCLOSURE_SETTING_DISABLED: 362 desc[2] &= 0x7f; 363 ecomp->active = 0; 364 break; 365 case ENCLOSURE_SETTING_ENABLED: 366 desc[2] |= 0x80; 367 ecomp->active = 1; 368 break; 369 default: 370 /* SES doesn't do the SGPIO blink settings */ 371 return -EINVAL; 372 } 373 return ses_set_page2_descriptor(edev, ecomp, desc); 374 } 375 376 static int ses_show_id(struct enclosure_device *edev, char *buf) 377 { 378 struct ses_device *ses_dev = edev->scratch; 379 unsigned long long id = get_unaligned_be64(ses_dev->page1+8+4); 380 381 return sprintf(buf, "%#llx\n", id); 382 } 383 384 static void ses_get_power_status(struct enclosure_device *edev, 385 struct enclosure_component *ecomp) 386 { 387 unsigned char *desc; 388 389 if (!ses_page2_supported(edev)) { 390 ecomp->power_status = 0; 391 return; 392 } 393 394 desc = ses_get_page2_descriptor(edev, ecomp); 395 if (desc) 396 ecomp->power_status = (desc[3] & 0x10) ? 0 : 1; 397 } 398 399 static int ses_set_power_status(struct enclosure_device *edev, 400 struct enclosure_component *ecomp, 401 int val) 402 { 403 unsigned char desc[4]; 404 unsigned char *desc_ptr; 405 406 if (!ses_page2_supported(edev)) 407 return -EINVAL; 408 409 desc_ptr = ses_get_page2_descriptor(edev, ecomp); 410 411 if (!desc_ptr) 412 return -EIO; 413 414 init_device_slot_control(desc, ecomp, desc_ptr); 415 416 switch (val) { 417 /* power = 1 is device_off = 0 and vice versa */ 418 case 0: 419 desc[3] |= 0x10; 420 break; 421 case 1: 422 desc[3] &= 0xef; 423 break; 424 default: 425 return -EINVAL; 426 } 427 ecomp->power_status = val; 428 return ses_set_page2_descriptor(edev, ecomp, desc); 429 } 430 431 static struct enclosure_component_callbacks ses_enclosure_callbacks = { 432 .get_fault = ses_get_fault, 433 .set_fault = ses_set_fault, 434 .get_status = ses_get_status, 435 .get_locate = ses_get_locate, 436 .set_locate = ses_set_locate, 437 .get_power_status = ses_get_power_status, 438 .set_power_status = ses_set_power_status, 439 .set_active = ses_set_active, 440 .show_id = ses_show_id, 441 }; 442 443 struct ses_host_edev { 444 struct Scsi_Host *shost; 445 struct enclosure_device *edev; 446 }; 447 448 #if 0 449 int ses_match_host(struct enclosure_device *edev, void *data) 450 { 451 struct ses_host_edev *sed = data; 452 struct scsi_device *sdev; 453 454 if (!scsi_is_sdev_device(edev->edev.parent)) 455 return 0; 456 457 sdev = to_scsi_device(edev->edev.parent); 458 459 if (sdev->host != sed->shost) 460 return 0; 461 462 sed->edev = edev; 463 return 1; 464 } 465 #endif /* 0 */ 466 467 static int ses_process_descriptor(struct enclosure_component *ecomp, 468 unsigned char *desc, int max_desc_len) 469 { 470 int eip = desc[0] & 0x10; 471 int invalid = desc[0] & 0x80; 472 enum scsi_protocol proto = desc[0] & 0x0f; 473 u64 addr = 0; 474 int slot = -1; 475 struct ses_component *scomp = ecomp->scratch; 476 unsigned char *d; 477 478 if (invalid) 479 return 0; 480 481 switch (proto) { 482 case SCSI_PROTOCOL_FCP: 483 if (eip) { 484 if (max_desc_len <= 7) 485 return 1; 486 d = desc + 4; 487 slot = d[3]; 488 } 489 break; 490 case SCSI_PROTOCOL_SAS: 491 492 if (eip) { 493 if (max_desc_len <= 27) 494 return 1; 495 d = desc + 4; 496 slot = d[3]; 497 d = desc + 8; 498 } else { 499 if (max_desc_len <= 23) 500 return 1; 501 d = desc + 4; 502 } 503 504 505 /* only take the phy0 addr */ 506 addr = (u64)d[12] << 56 | 507 (u64)d[13] << 48 | 508 (u64)d[14] << 40 | 509 (u64)d[15] << 32 | 510 (u64)d[16] << 24 | 511 (u64)d[17] << 16 | 512 (u64)d[18] << 8 | 513 (u64)d[19]; 514 break; 515 default: 516 /* FIXME: Need to add more protocols than just SAS */ 517 break; 518 } 519 ecomp->slot = slot; 520 scomp->addr = addr; 521 522 return 0; 523 } 524 525 struct efd { 526 u64 addr; 527 struct device *dev; 528 }; 529 530 static int ses_enclosure_find_by_addr(struct enclosure_device *edev, 531 struct efd *efd) 532 { 533 int i; 534 struct ses_component *scomp; 535 536 for (i = 0; i < edev->components; i++) { 537 scomp = edev->component[i].scratch; 538 if (scomp->addr != efd->addr) 539 continue; 540 541 if (enclosure_add_device(edev, i, efd->dev) == 0) 542 kobject_uevent(&efd->dev->kobj, KOBJ_CHANGE); 543 return 1; 544 } 545 return 0; 546 } 547 548 #define INIT_ALLOC_SIZE 32 549 550 static void ses_enclosure_data_process(struct enclosure_device *edev, 551 struct scsi_device *sdev, 552 int create) 553 { 554 u32 result; 555 unsigned char *buf = NULL, *type_ptr, *desc_ptr, *addl_desc_ptr = NULL; 556 int i, j, page7_len, len, components; 557 struct ses_device *ses_dev = edev->scratch; 558 int types = ses_dev->page1_num_types; 559 unsigned char *hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL); 560 561 if (!hdr_buf) 562 goto simple_populate; 563 564 /* re-read page 10 */ 565 if (ses_dev->page10) 566 ses_recv_diag(sdev, 10, ses_dev->page10, ses_dev->page10_len); 567 /* Page 7 for the descriptors is optional */ 568 result = ses_recv_diag(sdev, 7, hdr_buf, INIT_ALLOC_SIZE); 569 if (result) 570 goto simple_populate; 571 572 page7_len = len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 573 /* add 1 for trailing '\0' we'll use */ 574 buf = kzalloc(len + 1, GFP_KERNEL); 575 if (!buf) 576 goto simple_populate; 577 result = ses_recv_diag(sdev, 7, buf, len); 578 if (result) { 579 simple_populate: 580 kfree(buf); 581 buf = NULL; 582 desc_ptr = NULL; 583 len = 0; 584 page7_len = 0; 585 } else { 586 desc_ptr = buf + 8; 587 len = (desc_ptr[2] << 8) + desc_ptr[3]; 588 /* skip past overall descriptor */ 589 desc_ptr += len + 4; 590 } 591 if (ses_dev->page10 && ses_dev->page10_len > 9) 592 addl_desc_ptr = ses_dev->page10 + 8; 593 type_ptr = ses_dev->page1_types; 594 components = 0; 595 for (i = 0; i < types; i++, type_ptr += 4) { 596 for (j = 0; j < type_ptr[1]; j++) { 597 char *name = NULL; 598 struct enclosure_component *ecomp; 599 int max_desc_len; 600 601 if (desc_ptr) { 602 if (desc_ptr + 3 >= buf + page7_len) { 603 desc_ptr = NULL; 604 } else { 605 len = (desc_ptr[2] << 8) + desc_ptr[3]; 606 desc_ptr += 4; 607 if (desc_ptr + len > buf + page7_len) 608 desc_ptr = NULL; 609 else { 610 /* Add trailing zero - pushes into 611 * reserved space */ 612 desc_ptr[len] = '\0'; 613 name = desc_ptr; 614 } 615 } 616 } 617 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE || 618 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) { 619 620 if (create) 621 ecomp = enclosure_component_alloc( 622 edev, 623 components++, 624 type_ptr[0], 625 name); 626 else if (components < edev->components) 627 ecomp = &edev->component[components++]; 628 else 629 ecomp = ERR_PTR(-EINVAL); 630 631 if (!IS_ERR(ecomp)) { 632 if (addl_desc_ptr) { 633 max_desc_len = ses_dev->page10_len - 634 (addl_desc_ptr - ses_dev->page10); 635 if (ses_process_descriptor(ecomp, 636 addl_desc_ptr, 637 max_desc_len)) 638 addl_desc_ptr = NULL; 639 } 640 if (create) 641 enclosure_component_register( 642 ecomp); 643 } 644 } 645 if (desc_ptr) 646 desc_ptr += len; 647 648 if (addl_desc_ptr && 649 /* only find additional descriptions for specific devices */ 650 (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE || 651 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE || 652 type_ptr[0] == ENCLOSURE_COMPONENT_SAS_EXPANDER || 653 /* these elements are optional */ 654 type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_TARGET_PORT || 655 type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_INITIATOR_PORT || 656 type_ptr[0] == ENCLOSURE_COMPONENT_CONTROLLER_ELECTRONICS)) { 657 addl_desc_ptr += addl_desc_ptr[1] + 2; 658 if (addl_desc_ptr + 1 >= ses_dev->page10 + ses_dev->page10_len) 659 addl_desc_ptr = NULL; 660 } 661 } 662 } 663 kfree(buf); 664 kfree(hdr_buf); 665 } 666 667 static void ses_match_to_enclosure(struct enclosure_device *edev, 668 struct scsi_device *sdev, 669 int refresh) 670 { 671 struct scsi_device *edev_sdev = to_scsi_device(edev->edev.parent); 672 struct efd efd = { 673 .addr = 0, 674 }; 675 676 if (refresh) 677 ses_enclosure_data_process(edev, edev_sdev, 0); 678 679 if (scsi_is_sas_rphy(sdev->sdev_target->dev.parent)) 680 efd.addr = sas_get_address(sdev); 681 682 if (efd.addr) { 683 efd.dev = &sdev->sdev_gendev; 684 685 ses_enclosure_find_by_addr(edev, &efd); 686 } 687 } 688 689 static int ses_intf_add(struct device *cdev) 690 { 691 struct scsi_device *sdev = to_scsi_device(cdev->parent); 692 struct scsi_device *tmp_sdev; 693 unsigned char *buf = NULL, *hdr_buf, *type_ptr, page; 694 struct ses_device *ses_dev; 695 u32 result; 696 int i, types, len, components = 0; 697 int err = -ENOMEM; 698 int num_enclosures; 699 struct enclosure_device *edev; 700 struct ses_component *scomp = NULL; 701 702 if (!scsi_device_enclosure(sdev)) { 703 /* not an enclosure, but might be in one */ 704 struct enclosure_device *prev = NULL; 705 706 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) { 707 ses_match_to_enclosure(edev, sdev, 1); 708 prev = edev; 709 } 710 return -ENODEV; 711 } 712 713 /* TYPE_ENCLOSURE prints a message in probe */ 714 if (sdev->type != TYPE_ENCLOSURE) 715 sdev_printk(KERN_NOTICE, sdev, "Embedded Enclosure Device\n"); 716 717 ses_dev = kzalloc_obj(*ses_dev); 718 hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL); 719 if (!hdr_buf || !ses_dev) 720 goto err_init_free; 721 722 page = 1; 723 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE); 724 if (result) 725 goto recv_failed; 726 727 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 728 buf = kzalloc(len, GFP_KERNEL); 729 if (!buf) 730 goto err_free; 731 732 result = ses_recv_diag(sdev, page, buf, len); 733 if (result) 734 goto recv_failed; 735 736 types = 0; 737 738 /* we always have one main enclosure and the rest are referred 739 * to as secondary subenclosures */ 740 num_enclosures = buf[1] + 1; 741 742 /* begin at the enclosure descriptor */ 743 type_ptr = buf + 8; 744 /* skip all the enclosure descriptors */ 745 for (i = 0; i < num_enclosures && type_ptr < buf + len; i++) { 746 types += type_ptr[2]; 747 type_ptr += type_ptr[3] + 4; 748 } 749 750 ses_dev->page1_types = type_ptr; 751 ses_dev->page1_num_types = types; 752 753 for (i = 0; i < types && type_ptr < buf + len; i++, type_ptr += 4) { 754 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE || 755 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) 756 components += type_ptr[1]; 757 } 758 759 ses_dev->page1 = buf; 760 ses_dev->page1_len = len; 761 buf = NULL; 762 763 page = 2; 764 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE); 765 if (result) 766 goto page2_not_supported; 767 768 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 769 buf = kzalloc(len, GFP_KERNEL); 770 if (!buf) 771 goto err_free; 772 773 /* make sure getting page 2 actually works */ 774 result = ses_recv_diag(sdev, 2, buf, len); 775 if (result) 776 goto recv_failed; 777 ses_dev->page2 = buf; 778 ses_dev->page2_len = len; 779 buf = NULL; 780 781 /* The additional information page --- allows us 782 * to match up the devices */ 783 page = 10; 784 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE); 785 if (!result) { 786 787 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 788 buf = kzalloc(len, GFP_KERNEL); 789 if (!buf) 790 goto err_free; 791 792 result = ses_recv_diag(sdev, page, buf, len); 793 if (result) 794 goto recv_failed; 795 ses_dev->page10 = buf; 796 ses_dev->page10_len = len; 797 buf = NULL; 798 } 799 page2_not_supported: 800 if (components > 0) { 801 scomp = kzalloc_objs(struct ses_component, components); 802 if (!scomp) 803 goto err_free; 804 } 805 806 edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev), 807 components, &ses_enclosure_callbacks); 808 if (IS_ERR(edev)) { 809 err = PTR_ERR(edev); 810 goto err_free; 811 } 812 813 kfree(hdr_buf); 814 815 edev->scratch = ses_dev; 816 for (i = 0; i < components; i++) 817 edev->component[i].scratch = scomp + i; 818 819 ses_enclosure_data_process(edev, sdev, 1); 820 821 /* see if there are any devices matching before 822 * we found the enclosure */ 823 shost_for_each_device(tmp_sdev, sdev->host) { 824 if (tmp_sdev->lun != 0 || scsi_device_enclosure(tmp_sdev)) 825 continue; 826 ses_match_to_enclosure(edev, tmp_sdev, 0); 827 } 828 829 return 0; 830 831 recv_failed: 832 sdev_printk(KERN_ERR, sdev, "Failed to get diagnostic page 0x%x\n", 833 page); 834 err = -ENODEV; 835 err_free: 836 kfree(buf); 837 kfree(scomp); 838 kfree(ses_dev->page10); 839 kfree(ses_dev->page2); 840 kfree(ses_dev->page1); 841 err_init_free: 842 kfree(ses_dev); 843 kfree(hdr_buf); 844 sdev_printk(KERN_ERR, sdev, "Failed to bind enclosure %d\n", err); 845 return err; 846 } 847 848 static void ses_intf_remove_component(struct scsi_device *sdev) 849 { 850 struct enclosure_device *edev, *prev = NULL; 851 852 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) { 853 prev = edev; 854 if (!enclosure_remove_device(edev, &sdev->sdev_gendev)) 855 break; 856 } 857 if (edev) 858 put_device(&edev->edev); 859 } 860 861 static void ses_intf_remove_enclosure(struct scsi_device *sdev) 862 { 863 struct enclosure_device *edev; 864 struct ses_device *ses_dev; 865 866 /* exact match to this enclosure */ 867 edev = enclosure_find(&sdev->sdev_gendev, NULL); 868 if (!edev) 869 return; 870 871 ses_dev = edev->scratch; 872 edev->scratch = NULL; 873 874 kfree(ses_dev->page10); 875 kfree(ses_dev->page1); 876 kfree(ses_dev->page2); 877 kfree(ses_dev); 878 879 if (edev->components) 880 kfree(edev->component[0].scratch); 881 882 put_device(&edev->edev); 883 enclosure_unregister(edev); 884 } 885 886 static void ses_intf_remove(struct device *cdev) 887 { 888 struct scsi_device *sdev = to_scsi_device(cdev->parent); 889 890 if (!scsi_device_enclosure(sdev)) 891 ses_intf_remove_component(sdev); 892 else 893 ses_intf_remove_enclosure(sdev); 894 } 895 896 static struct class_interface ses_interface = { 897 .add_dev = ses_intf_add, 898 .remove_dev = ses_intf_remove, 899 }; 900 901 static struct scsi_driver ses_template = { 902 .probe = ses_probe, 903 .gendrv = { 904 .name = "ses", 905 }, 906 }; 907 908 static int __init ses_init(void) 909 { 910 int err; 911 912 err = scsi_register_interface(&ses_interface); 913 if (err) 914 return err; 915 916 err = scsi_register_driver(&ses_template); 917 if (err) 918 goto out_unreg; 919 920 return 0; 921 922 out_unreg: 923 scsi_unregister_interface(&ses_interface); 924 return err; 925 } 926 927 static void __exit ses_exit(void) 928 { 929 scsi_unregister_driver(&ses_template); 930 scsi_unregister_interface(&ses_interface); 931 } 932 933 module_init(ses_init); 934 module_exit(ses_exit); 935 936 MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE); 937 938 MODULE_AUTHOR("James Bottomley"); 939 MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver"); 940 MODULE_LICENSE("GPL v2"); 941