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