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