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 void *data) 532 { 533 struct efd *efd = data; 534 int i; 535 struct ses_component *scomp; 536 537 for (i = 0; i < edev->components; i++) { 538 scomp = edev->component[i].scratch; 539 if (scomp->addr != efd->addr) 540 continue; 541 542 if (enclosure_add_device(edev, i, efd->dev) == 0) 543 kobject_uevent(&efd->dev->kobj, KOBJ_CHANGE); 544 return 1; 545 } 546 return 0; 547 } 548 549 #define INIT_ALLOC_SIZE 32 550 551 static void ses_enclosure_data_process(struct enclosure_device *edev, 552 struct scsi_device *sdev, 553 int create) 554 { 555 u32 result; 556 unsigned char *buf = NULL, *type_ptr, *desc_ptr, *addl_desc_ptr = NULL; 557 int i, j, page7_len, len, components; 558 struct ses_device *ses_dev = edev->scratch; 559 int types = ses_dev->page1_num_types; 560 unsigned char *hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL); 561 562 if (!hdr_buf) 563 goto simple_populate; 564 565 /* re-read page 10 */ 566 if (ses_dev->page10) 567 ses_recv_diag(sdev, 10, ses_dev->page10, ses_dev->page10_len); 568 /* Page 7 for the descriptors is optional */ 569 result = ses_recv_diag(sdev, 7, hdr_buf, INIT_ALLOC_SIZE); 570 if (result) 571 goto simple_populate; 572 573 page7_len = len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 574 /* add 1 for trailing '\0' we'll use */ 575 buf = kzalloc(len + 1, GFP_KERNEL); 576 if (!buf) 577 goto simple_populate; 578 result = ses_recv_diag(sdev, 7, buf, len); 579 if (result) { 580 simple_populate: 581 kfree(buf); 582 buf = NULL; 583 desc_ptr = NULL; 584 len = 0; 585 page7_len = 0; 586 } else { 587 desc_ptr = buf + 8; 588 len = (desc_ptr[2] << 8) + desc_ptr[3]; 589 /* skip past overall descriptor */ 590 desc_ptr += len + 4; 591 } 592 if (ses_dev->page10 && ses_dev->page10_len > 9) 593 addl_desc_ptr = ses_dev->page10 + 8; 594 type_ptr = ses_dev->page1_types; 595 components = 0; 596 for (i = 0; i < types; i++, type_ptr += 4) { 597 for (j = 0; j < type_ptr[1]; j++) { 598 char *name = NULL; 599 struct enclosure_component *ecomp; 600 int max_desc_len; 601 602 if (desc_ptr) { 603 if (desc_ptr + 3 >= buf + page7_len) { 604 desc_ptr = NULL; 605 } else { 606 len = (desc_ptr[2] << 8) + desc_ptr[3]; 607 desc_ptr += 4; 608 if (desc_ptr + len > buf + page7_len) 609 desc_ptr = NULL; 610 else { 611 /* Add trailing zero - pushes into 612 * reserved space */ 613 desc_ptr[len] = '\0'; 614 name = desc_ptr; 615 } 616 } 617 } 618 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE || 619 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) { 620 621 if (create) 622 ecomp = enclosure_component_alloc( 623 edev, 624 components++, 625 type_ptr[0], 626 name); 627 else if (components < edev->components) 628 ecomp = &edev->component[components++]; 629 else 630 ecomp = ERR_PTR(-EINVAL); 631 632 if (!IS_ERR(ecomp)) { 633 if (addl_desc_ptr) { 634 max_desc_len = ses_dev->page10_len - 635 (addl_desc_ptr - ses_dev->page10); 636 if (ses_process_descriptor(ecomp, 637 addl_desc_ptr, 638 max_desc_len)) 639 addl_desc_ptr = NULL; 640 } 641 if (create) 642 enclosure_component_register( 643 ecomp); 644 } 645 } 646 if (desc_ptr) 647 desc_ptr += len; 648 649 if (addl_desc_ptr && 650 /* only find additional descriptions for specific devices */ 651 (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE || 652 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE || 653 type_ptr[0] == ENCLOSURE_COMPONENT_SAS_EXPANDER || 654 /* these elements are optional */ 655 type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_TARGET_PORT || 656 type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_INITIATOR_PORT || 657 type_ptr[0] == ENCLOSURE_COMPONENT_CONTROLLER_ELECTRONICS)) { 658 addl_desc_ptr += addl_desc_ptr[1] + 2; 659 if (addl_desc_ptr + 1 >= ses_dev->page10 + ses_dev->page10_len) 660 addl_desc_ptr = NULL; 661 } 662 } 663 } 664 kfree(buf); 665 kfree(hdr_buf); 666 } 667 668 static void ses_match_to_enclosure(struct enclosure_device *edev, 669 struct scsi_device *sdev, 670 int refresh) 671 { 672 struct scsi_device *edev_sdev = to_scsi_device(edev->edev.parent); 673 struct efd efd = { 674 .addr = 0, 675 }; 676 677 if (refresh) 678 ses_enclosure_data_process(edev, edev_sdev, 0); 679 680 if (scsi_is_sas_rphy(sdev->sdev_target->dev.parent)) 681 efd.addr = sas_get_address(sdev); 682 683 if (efd.addr) { 684 efd.dev = &sdev->sdev_gendev; 685 686 enclosure_for_each_device(ses_enclosure_find_by_addr, &efd); 687 } 688 } 689 690 static int ses_intf_add(struct device *cdev) 691 { 692 struct scsi_device *sdev = to_scsi_device(cdev->parent); 693 struct scsi_device *tmp_sdev; 694 unsigned char *buf = NULL, *hdr_buf, *type_ptr, page; 695 struct ses_device *ses_dev; 696 u32 result; 697 int i, types, len, components = 0; 698 int err = -ENOMEM; 699 int num_enclosures; 700 struct enclosure_device *edev; 701 struct ses_component *scomp = NULL; 702 703 if (!scsi_device_enclosure(sdev)) { 704 /* not an enclosure, but might be in one */ 705 struct enclosure_device *prev = NULL; 706 707 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) { 708 ses_match_to_enclosure(edev, sdev, 1); 709 prev = edev; 710 } 711 return -ENODEV; 712 } 713 714 /* TYPE_ENCLOSURE prints a message in probe */ 715 if (sdev->type != TYPE_ENCLOSURE) 716 sdev_printk(KERN_NOTICE, sdev, "Embedded Enclosure Device\n"); 717 718 ses_dev = kzalloc(sizeof(*ses_dev), GFP_KERNEL); 719 hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL); 720 if (!hdr_buf || !ses_dev) 721 goto err_init_free; 722 723 page = 1; 724 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE); 725 if (result) 726 goto recv_failed; 727 728 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 729 buf = kzalloc(len, GFP_KERNEL); 730 if (!buf) 731 goto err_free; 732 733 result = ses_recv_diag(sdev, page, buf, len); 734 if (result) 735 goto recv_failed; 736 737 types = 0; 738 739 /* we always have one main enclosure and the rest are referred 740 * to as secondary subenclosures */ 741 num_enclosures = buf[1] + 1; 742 743 /* begin at the enclosure descriptor */ 744 type_ptr = buf + 8; 745 /* skip all the enclosure descriptors */ 746 for (i = 0; i < num_enclosures && type_ptr < buf + len; i++) { 747 types += type_ptr[2]; 748 type_ptr += type_ptr[3] + 4; 749 } 750 751 ses_dev->page1_types = type_ptr; 752 ses_dev->page1_num_types = types; 753 754 for (i = 0; i < types && type_ptr < buf + len; i++, type_ptr += 4) { 755 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE || 756 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) 757 components += type_ptr[1]; 758 } 759 760 ses_dev->page1 = buf; 761 ses_dev->page1_len = len; 762 buf = NULL; 763 764 page = 2; 765 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE); 766 if (result) 767 goto page2_not_supported; 768 769 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 770 buf = kzalloc(len, GFP_KERNEL); 771 if (!buf) 772 goto err_free; 773 774 /* make sure getting page 2 actually works */ 775 result = ses_recv_diag(sdev, 2, buf, len); 776 if (result) 777 goto recv_failed; 778 ses_dev->page2 = buf; 779 ses_dev->page2_len = len; 780 buf = NULL; 781 782 /* The additional information page --- allows us 783 * to match up the devices */ 784 page = 10; 785 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE); 786 if (!result) { 787 788 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 789 buf = kzalloc(len, GFP_KERNEL); 790 if (!buf) 791 goto err_free; 792 793 result = ses_recv_diag(sdev, page, buf, len); 794 if (result) 795 goto recv_failed; 796 ses_dev->page10 = buf; 797 ses_dev->page10_len = len; 798 buf = NULL; 799 } 800 page2_not_supported: 801 if (components > 0) { 802 scomp = kcalloc(components, sizeof(struct ses_component), GFP_KERNEL); 803 if (!scomp) 804 goto err_free; 805 } 806 807 edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev), 808 components, &ses_enclosure_callbacks); 809 if (IS_ERR(edev)) { 810 err = PTR_ERR(edev); 811 goto err_free; 812 } 813 814 kfree(hdr_buf); 815 816 edev->scratch = ses_dev; 817 for (i = 0; i < components; i++) 818 edev->component[i].scratch = scomp + i; 819 820 ses_enclosure_data_process(edev, sdev, 1); 821 822 /* see if there are any devices matching before 823 * we found the enclosure */ 824 shost_for_each_device(tmp_sdev, sdev->host) { 825 if (tmp_sdev->lun != 0 || scsi_device_enclosure(tmp_sdev)) 826 continue; 827 ses_match_to_enclosure(edev, tmp_sdev, 0); 828 } 829 830 return 0; 831 832 recv_failed: 833 sdev_printk(KERN_ERR, sdev, "Failed to get diagnostic page 0x%x\n", 834 page); 835 err = -ENODEV; 836 err_free: 837 kfree(buf); 838 kfree(scomp); 839 kfree(ses_dev->page10); 840 kfree(ses_dev->page2); 841 kfree(ses_dev->page1); 842 err_init_free: 843 kfree(ses_dev); 844 kfree(hdr_buf); 845 sdev_printk(KERN_ERR, sdev, "Failed to bind enclosure %d\n", err); 846 return err; 847 } 848 849 static void ses_intf_remove_component(struct scsi_device *sdev) 850 { 851 struct enclosure_device *edev, *prev = NULL; 852 853 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) { 854 prev = edev; 855 if (!enclosure_remove_device(edev, &sdev->sdev_gendev)) 856 break; 857 } 858 if (edev) 859 put_device(&edev->edev); 860 } 861 862 static void ses_intf_remove_enclosure(struct scsi_device *sdev) 863 { 864 struct enclosure_device *edev; 865 struct ses_device *ses_dev; 866 867 /* exact match to this enclosure */ 868 edev = enclosure_find(&sdev->sdev_gendev, NULL); 869 if (!edev) 870 return; 871 872 ses_dev = edev->scratch; 873 edev->scratch = NULL; 874 875 kfree(ses_dev->page10); 876 kfree(ses_dev->page1); 877 kfree(ses_dev->page2); 878 kfree(ses_dev); 879 880 if (edev->components) 881 kfree(edev->component[0].scratch); 882 883 put_device(&edev->edev); 884 enclosure_unregister(edev); 885 } 886 887 static void ses_intf_remove(struct device *cdev) 888 { 889 struct scsi_device *sdev = to_scsi_device(cdev->parent); 890 891 if (!scsi_device_enclosure(sdev)) 892 ses_intf_remove_component(sdev); 893 else 894 ses_intf_remove_enclosure(sdev); 895 } 896 897 static struct class_interface ses_interface = { 898 .add_dev = ses_intf_add, 899 .remove_dev = ses_intf_remove, 900 }; 901 902 static struct scsi_driver ses_template = { 903 .probe = ses_probe, 904 .gendrv = { 905 .name = "ses", 906 }, 907 }; 908 909 static int __init ses_init(void) 910 { 911 int err; 912 913 err = scsi_register_interface(&ses_interface); 914 if (err) 915 return err; 916 917 err = scsi_register_driver(&ses_template); 918 if (err) 919 goto out_unreg; 920 921 return 0; 922 923 out_unreg: 924 scsi_unregister_interface(&ses_interface); 925 return err; 926 } 927 928 static void __exit ses_exit(void) 929 { 930 scsi_unregister_driver(&ses_template); 931 scsi_unregister_interface(&ses_interface); 932 } 933 934 module_init(ses_init); 935 module_exit(ses_exit); 936 937 MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE); 938 939 MODULE_AUTHOR("James Bottomley"); 940 MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver"); 941 MODULE_LICENSE("GPL v2"); 942