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