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