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