drivers/scsi/ses.c

   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");