Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * SCSI Enclosure Services
0004  *
0005  * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com>
0006  */
0007 
0008 #include <linux/slab.h>
0009 #include <linux/module.h>
0010 #include <linux/kernel.h>
0011 #include <linux/enclosure.h>
0012 #include <asm/unaligned.h>
0013 
0014 #include <scsi/scsi.h>
0015 #include <scsi/scsi_cmnd.h>
0016 #include <scsi/scsi_dbg.h>
0017 #include <scsi/scsi_device.h>
0018 #include <scsi/scsi_driver.h>
0019 #include <scsi/scsi_host.h>
0020 
0021 #include <scsi/scsi_transport_sas.h>
0022 
0023 struct ses_device {
0024     unsigned char *page1;
0025     unsigned char *page1_types;
0026     unsigned char *page2;
0027     unsigned char *page10;
0028     short page1_len;
0029     short page1_num_types;
0030     short page2_len;
0031     short page10_len;
0032 };
0033 
0034 struct ses_component {
0035     u64 addr;
0036 };
0037 
0038 static bool ses_page2_supported(struct enclosure_device *edev)
0039 {
0040     struct ses_device *ses_dev = edev->scratch;
0041 
0042     return (ses_dev->page2 != NULL);
0043 }
0044 
0045 static int ses_probe(struct device *dev)
0046 {
0047     struct scsi_device *sdev = to_scsi_device(dev);
0048     int err = -ENODEV;
0049 
0050     if (sdev->type != TYPE_ENCLOSURE)
0051         goto out;
0052 
0053     err = 0;
0054     sdev_printk(KERN_NOTICE, sdev, "Attached Enclosure device\n");
0055 
0056  out:
0057     return err;
0058 }
0059 
0060 #define SES_TIMEOUT (30 * HZ)
0061 #define SES_RETRIES 3
0062 
0063 static void init_device_slot_control(unsigned char *dest_desc,
0064                      struct enclosure_component *ecomp,
0065                      unsigned char *status)
0066 {
0067     memcpy(dest_desc, status, 4);
0068     dest_desc[0] = 0;
0069     /* only clear byte 1 for ENCLOSURE_COMPONENT_DEVICE */
0070     if (ecomp->type == ENCLOSURE_COMPONENT_DEVICE)
0071         dest_desc[1] = 0;
0072     dest_desc[2] &= 0xde;
0073     dest_desc[3] &= 0x3c;
0074 }
0075 
0076 
0077 static int ses_recv_diag(struct scsi_device *sdev, int page_code,
0078              void *buf, int bufflen)
0079 {
0080     int ret;
0081     unsigned char cmd[] = {
0082         RECEIVE_DIAGNOSTIC,
0083         1,      /* Set PCV bit */
0084         page_code,
0085         bufflen >> 8,
0086         bufflen & 0xff,
0087         0
0088     };
0089     unsigned char recv_page_code;
0090     unsigned int retries = SES_RETRIES;
0091     struct scsi_sense_hdr sshdr;
0092 
0093     do {
0094         ret = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buf, bufflen,
0095                        &sshdr, SES_TIMEOUT, 1, NULL);
0096     } while (ret > 0 && --retries && scsi_sense_valid(&sshdr) &&
0097          (sshdr.sense_key == NOT_READY ||
0098           (sshdr.sense_key == UNIT_ATTENTION && sshdr.asc == 0x29)));
0099 
0100     if (unlikely(ret))
0101         return ret;
0102 
0103     recv_page_code = ((unsigned char *)buf)[0];
0104 
0105     if (likely(recv_page_code == page_code))
0106         return ret;
0107 
0108     /* successful diagnostic but wrong page code.  This happens to some
0109      * USB devices, just print a message and pretend there was an error */
0110 
0111     sdev_printk(KERN_ERR, sdev,
0112             "Wrong diagnostic page; asked for %d got %u\n",
0113             page_code, recv_page_code);
0114 
0115     return -EINVAL;
0116 }
0117 
0118 static int ses_send_diag(struct scsi_device *sdev, int page_code,
0119              void *buf, int bufflen)
0120 {
0121     int result;
0122 
0123     unsigned char cmd[] = {
0124         SEND_DIAGNOSTIC,
0125         0x10,       /* Set PF bit */
0126         0,
0127         bufflen >> 8,
0128         bufflen & 0xff,
0129         0
0130     };
0131     struct scsi_sense_hdr sshdr;
0132     unsigned int retries = SES_RETRIES;
0133 
0134     do {
0135         result = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, buf, bufflen,
0136                       &sshdr, SES_TIMEOUT, 1, NULL);
0137     } while (result > 0 && --retries && scsi_sense_valid(&sshdr) &&
0138          (sshdr.sense_key == NOT_READY ||
0139           (sshdr.sense_key == UNIT_ATTENTION && sshdr.asc == 0x29)));
0140 
0141     if (result)
0142         sdev_printk(KERN_ERR, sdev, "SEND DIAGNOSTIC result: %8x\n",
0143                 result);
0144     return result;
0145 }
0146 
0147 static int ses_set_page2_descriptor(struct enclosure_device *edev,
0148                       struct enclosure_component *ecomp,
0149                       unsigned char *desc)
0150 {
0151     int i, j, count = 0, descriptor = ecomp->number;
0152     struct scsi_device *sdev = to_scsi_device(edev->edev.parent);
0153     struct ses_device *ses_dev = edev->scratch;
0154     unsigned char *type_ptr = ses_dev->page1_types;
0155     unsigned char *desc_ptr = ses_dev->page2 + 8;
0156 
0157     /* Clear everything */
0158     memset(desc_ptr, 0, ses_dev->page2_len - 8);
0159     for (i = 0; i < ses_dev->page1_num_types; i++, type_ptr += 4) {
0160         for (j = 0; j < type_ptr[1]; j++) {
0161             desc_ptr += 4;
0162             if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE &&
0163                 type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE)
0164                 continue;
0165             if (count++ == descriptor) {
0166                 memcpy(desc_ptr, desc, 4);
0167                 /* set select */
0168                 desc_ptr[0] |= 0x80;
0169                 /* clear reserved, just in case */
0170                 desc_ptr[0] &= 0xf0;
0171             }
0172         }
0173     }
0174 
0175     return ses_send_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len);
0176 }
0177 
0178 static unsigned char *ses_get_page2_descriptor(struct enclosure_device *edev,
0179                       struct enclosure_component *ecomp)
0180 {
0181     int i, j, count = 0, descriptor = ecomp->number;
0182     struct scsi_device *sdev = to_scsi_device(edev->edev.parent);
0183     struct ses_device *ses_dev = edev->scratch;
0184     unsigned char *type_ptr = ses_dev->page1_types;
0185     unsigned char *desc_ptr = ses_dev->page2 + 8;
0186 
0187     if (ses_recv_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len) < 0)
0188         return NULL;
0189 
0190     for (i = 0; i < ses_dev->page1_num_types; i++, type_ptr += 4) {
0191         for (j = 0; j < type_ptr[1]; j++) {
0192             desc_ptr += 4;
0193             if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE &&
0194                 type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE)
0195                 continue;
0196             if (count++ == descriptor)
0197                 return desc_ptr;
0198         }
0199     }
0200     return NULL;
0201 }
0202 
0203 /* For device slot and array device slot elements, byte 3 bit 6
0204  * is "fault sensed" while byte 3 bit 5 is "fault reqstd". As this
0205  * code stands these bits are shifted 4 positions right so in
0206  * sysfs they will appear as bits 2 and 1 respectively. Strange. */
0207 static void ses_get_fault(struct enclosure_device *edev,
0208               struct enclosure_component *ecomp)
0209 {
0210     unsigned char *desc;
0211 
0212     if (!ses_page2_supported(edev)) {
0213         ecomp->fault = 0;
0214         return;
0215     }
0216     desc = ses_get_page2_descriptor(edev, ecomp);
0217     if (desc)
0218         ecomp->fault = (desc[3] & 0x60) >> 4;
0219 }
0220 
0221 static int ses_set_fault(struct enclosure_device *edev,
0222               struct enclosure_component *ecomp,
0223              enum enclosure_component_setting val)
0224 {
0225     unsigned char desc[4];
0226     unsigned char *desc_ptr;
0227 
0228     if (!ses_page2_supported(edev))
0229         return -EINVAL;
0230 
0231     desc_ptr = ses_get_page2_descriptor(edev, ecomp);
0232 
0233     if (!desc_ptr)
0234         return -EIO;
0235 
0236     init_device_slot_control(desc, ecomp, desc_ptr);
0237 
0238     switch (val) {
0239     case ENCLOSURE_SETTING_DISABLED:
0240         desc[3] &= 0xdf;
0241         break;
0242     case ENCLOSURE_SETTING_ENABLED:
0243         desc[3] |= 0x20;
0244         break;
0245     default:
0246         /* SES doesn't do the SGPIO blink settings */
0247         return -EINVAL;
0248     }
0249 
0250     return ses_set_page2_descriptor(edev, ecomp, desc);
0251 }
0252 
0253 static void ses_get_status(struct enclosure_device *edev,
0254                struct enclosure_component *ecomp)
0255 {
0256     unsigned char *desc;
0257 
0258     if (!ses_page2_supported(edev)) {
0259         ecomp->status = 0;
0260         return;
0261     }
0262     desc = ses_get_page2_descriptor(edev, ecomp);
0263     if (desc)
0264         ecomp->status = (desc[0] & 0x0f);
0265 }
0266 
0267 static void ses_get_locate(struct enclosure_device *edev,
0268                struct enclosure_component *ecomp)
0269 {
0270     unsigned char *desc;
0271 
0272     if (!ses_page2_supported(edev)) {
0273         ecomp->locate = 0;
0274         return;
0275     }
0276     desc = ses_get_page2_descriptor(edev, ecomp);
0277     if (desc)
0278         ecomp->locate = (desc[2] & 0x02) ? 1 : 0;
0279 }
0280 
0281 static int ses_set_locate(struct enclosure_device *edev,
0282               struct enclosure_component *ecomp,
0283               enum enclosure_component_setting val)
0284 {
0285     unsigned char desc[4];
0286     unsigned char *desc_ptr;
0287 
0288     if (!ses_page2_supported(edev))
0289         return -EINVAL;
0290 
0291     desc_ptr = ses_get_page2_descriptor(edev, ecomp);
0292 
0293     if (!desc_ptr)
0294         return -EIO;
0295 
0296     init_device_slot_control(desc, ecomp, desc_ptr);
0297 
0298     switch (val) {
0299     case ENCLOSURE_SETTING_DISABLED:
0300         desc[2] &= 0xfd;
0301         break;
0302     case ENCLOSURE_SETTING_ENABLED:
0303         desc[2] |= 0x02;
0304         break;
0305     default:
0306         /* SES doesn't do the SGPIO blink settings */
0307         return -EINVAL;
0308     }
0309     return ses_set_page2_descriptor(edev, ecomp, desc);
0310 }
0311 
0312 static int ses_set_active(struct enclosure_device *edev,
0313               struct enclosure_component *ecomp,
0314               enum enclosure_component_setting val)
0315 {
0316     unsigned char desc[4];
0317     unsigned char *desc_ptr;
0318 
0319     if (!ses_page2_supported(edev))
0320         return -EINVAL;
0321 
0322     desc_ptr = ses_get_page2_descriptor(edev, ecomp);
0323 
0324     if (!desc_ptr)
0325         return -EIO;
0326 
0327     init_device_slot_control(desc, ecomp, desc_ptr);
0328 
0329     switch (val) {
0330     case ENCLOSURE_SETTING_DISABLED:
0331         desc[2] &= 0x7f;
0332         ecomp->active = 0;
0333         break;
0334     case ENCLOSURE_SETTING_ENABLED:
0335         desc[2] |= 0x80;
0336         ecomp->active = 1;
0337         break;
0338     default:
0339         /* SES doesn't do the SGPIO blink settings */
0340         return -EINVAL;
0341     }
0342     return ses_set_page2_descriptor(edev, ecomp, desc);
0343 }
0344 
0345 static int ses_show_id(struct enclosure_device *edev, char *buf)
0346 {
0347     struct ses_device *ses_dev = edev->scratch;
0348     unsigned long long id = get_unaligned_be64(ses_dev->page1+8+4);
0349 
0350     return sprintf(buf, "%#llx\n", id);
0351 }
0352 
0353 static void ses_get_power_status(struct enclosure_device *edev,
0354                  struct enclosure_component *ecomp)
0355 {
0356     unsigned char *desc;
0357 
0358     if (!ses_page2_supported(edev)) {
0359         ecomp->power_status = 0;
0360         return;
0361     }
0362 
0363     desc = ses_get_page2_descriptor(edev, ecomp);
0364     if (desc)
0365         ecomp->power_status = (desc[3] & 0x10) ? 0 : 1;
0366 }
0367 
0368 static int ses_set_power_status(struct enclosure_device *edev,
0369                 struct enclosure_component *ecomp,
0370                 int val)
0371 {
0372     unsigned char desc[4];
0373     unsigned char *desc_ptr;
0374 
0375     if (!ses_page2_supported(edev))
0376         return -EINVAL;
0377 
0378     desc_ptr = ses_get_page2_descriptor(edev, ecomp);
0379 
0380     if (!desc_ptr)
0381         return -EIO;
0382 
0383     init_device_slot_control(desc, ecomp, desc_ptr);
0384 
0385     switch (val) {
0386     /* power = 1 is device_off = 0 and vice versa */
0387     case 0:
0388         desc[3] |= 0x10;
0389         break;
0390     case 1:
0391         desc[3] &= 0xef;
0392         break;
0393     default:
0394         return -EINVAL;
0395     }
0396     ecomp->power_status = val;
0397     return ses_set_page2_descriptor(edev, ecomp, desc);
0398 }
0399 
0400 static struct enclosure_component_callbacks ses_enclosure_callbacks = {
0401     .get_fault      = ses_get_fault,
0402     .set_fault      = ses_set_fault,
0403     .get_status     = ses_get_status,
0404     .get_locate     = ses_get_locate,
0405     .set_locate     = ses_set_locate,
0406     .get_power_status   = ses_get_power_status,
0407     .set_power_status   = ses_set_power_status,
0408     .set_active     = ses_set_active,
0409     .show_id        = ses_show_id,
0410 };
0411 
0412 struct ses_host_edev {
0413     struct Scsi_Host *shost;
0414     struct enclosure_device *edev;
0415 };
0416 
0417 #if 0
0418 int ses_match_host(struct enclosure_device *edev, void *data)
0419 {
0420     struct ses_host_edev *sed = data;
0421     struct scsi_device *sdev;
0422 
0423     if (!scsi_is_sdev_device(edev->edev.parent))
0424         return 0;
0425 
0426     sdev = to_scsi_device(edev->edev.parent);
0427 
0428     if (sdev->host != sed->shost)
0429         return 0;
0430 
0431     sed->edev = edev;
0432     return 1;
0433 }
0434 #endif  /*  0  */
0435 
0436 static void ses_process_descriptor(struct enclosure_component *ecomp,
0437                    unsigned char *desc)
0438 {
0439     int eip = desc[0] & 0x10;
0440     int invalid = desc[0] & 0x80;
0441     enum scsi_protocol proto = desc[0] & 0x0f;
0442     u64 addr = 0;
0443     int slot = -1;
0444     struct ses_component *scomp = ecomp->scratch;
0445     unsigned char *d;
0446 
0447     if (invalid)
0448         return;
0449 
0450     switch (proto) {
0451     case SCSI_PROTOCOL_FCP:
0452         if (eip) {
0453             d = desc + 4;
0454             slot = d[3];
0455         }
0456         break;
0457     case SCSI_PROTOCOL_SAS:
0458         if (eip) {
0459             d = desc + 4;
0460             slot = d[3];
0461             d = desc + 8;
0462         } else
0463             d = desc + 4;
0464         /* only take the phy0 addr */
0465         addr = (u64)d[12] << 56 |
0466             (u64)d[13] << 48 |
0467             (u64)d[14] << 40 |
0468             (u64)d[15] << 32 |
0469             (u64)d[16] << 24 |
0470             (u64)d[17] << 16 |
0471             (u64)d[18] << 8 |
0472             (u64)d[19];
0473         break;
0474     default:
0475         /* FIXME: Need to add more protocols than just SAS */
0476         break;
0477     }
0478     ecomp->slot = slot;
0479     scomp->addr = addr;
0480 }
0481 
0482 struct efd {
0483     u64 addr;
0484     struct device *dev;
0485 };
0486 
0487 static int ses_enclosure_find_by_addr(struct enclosure_device *edev,
0488                       void *data)
0489 {
0490     struct efd *efd = data;
0491     int i;
0492     struct ses_component *scomp;
0493 
0494     if (!edev->component[0].scratch)
0495         return 0;
0496 
0497     for (i = 0; i < edev->components; i++) {
0498         scomp = edev->component[i].scratch;
0499         if (scomp->addr != efd->addr)
0500             continue;
0501 
0502         if (enclosure_add_device(edev, i, efd->dev) == 0)
0503             kobject_uevent(&efd->dev->kobj, KOBJ_CHANGE);
0504         return 1;
0505     }
0506     return 0;
0507 }
0508 
0509 #define INIT_ALLOC_SIZE 32
0510 
0511 static void ses_enclosure_data_process(struct enclosure_device *edev,
0512                        struct scsi_device *sdev,
0513                        int create)
0514 {
0515     u32 result;
0516     unsigned char *buf = NULL, *type_ptr, *desc_ptr, *addl_desc_ptr = NULL;
0517     int i, j, page7_len, len, components;
0518     struct ses_device *ses_dev = edev->scratch;
0519     int types = ses_dev->page1_num_types;
0520     unsigned char *hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
0521 
0522     if (!hdr_buf)
0523         goto simple_populate;
0524 
0525     /* re-read page 10 */
0526     if (ses_dev->page10)
0527         ses_recv_diag(sdev, 10, ses_dev->page10, ses_dev->page10_len);
0528     /* Page 7 for the descriptors is optional */
0529     result = ses_recv_diag(sdev, 7, hdr_buf, INIT_ALLOC_SIZE);
0530     if (result)
0531         goto simple_populate;
0532 
0533     page7_len = len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
0534     /* add 1 for trailing '\0' we'll use */
0535     buf = kzalloc(len + 1, GFP_KERNEL);
0536     if (!buf)
0537         goto simple_populate;
0538     result = ses_recv_diag(sdev, 7, buf, len);
0539     if (result) {
0540  simple_populate:
0541         kfree(buf);
0542         buf = NULL;
0543         desc_ptr = NULL;
0544         len = 0;
0545         page7_len = 0;
0546     } else {
0547         desc_ptr = buf + 8;
0548         len = (desc_ptr[2] << 8) + desc_ptr[3];
0549         /* skip past overall descriptor */
0550         desc_ptr += len + 4;
0551     }
0552     if (ses_dev->page10)
0553         addl_desc_ptr = ses_dev->page10 + 8;
0554     type_ptr = ses_dev->page1_types;
0555     components = 0;
0556     for (i = 0; i < types; i++, type_ptr += 4) {
0557         for (j = 0; j < type_ptr[1]; j++) {
0558             char *name = NULL;
0559             struct enclosure_component *ecomp;
0560 
0561             if (desc_ptr) {
0562                 if (desc_ptr >= buf + page7_len) {
0563                     desc_ptr = NULL;
0564                 } else {
0565                     len = (desc_ptr[2] << 8) + desc_ptr[3];
0566                     desc_ptr += 4;
0567                     /* Add trailing zero - pushes into
0568                      * reserved space */
0569                     desc_ptr[len] = '\0';
0570                     name = desc_ptr;
0571                 }
0572             }
0573             if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
0574                 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) {
0575 
0576                 if (create)
0577                     ecomp = enclosure_component_alloc(
0578                         edev,
0579                         components++,
0580                         type_ptr[0],
0581                         name);
0582                 else
0583                     ecomp = &edev->component[components++];
0584 
0585                 if (!IS_ERR(ecomp)) {
0586                     if (addl_desc_ptr)
0587                         ses_process_descriptor(
0588                             ecomp,
0589                             addl_desc_ptr);
0590                     if (create)
0591                         enclosure_component_register(
0592                             ecomp);
0593                 }
0594             }
0595             if (desc_ptr)
0596                 desc_ptr += len;
0597 
0598             if (addl_desc_ptr &&
0599                 /* only find additional descriptions for specific devices */
0600                 (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
0601                  type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE ||
0602                  type_ptr[0] == ENCLOSURE_COMPONENT_SAS_EXPANDER ||
0603                  /* these elements are optional */
0604                  type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_TARGET_PORT ||
0605                  type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_INITIATOR_PORT ||
0606                  type_ptr[0] == ENCLOSURE_COMPONENT_CONTROLLER_ELECTRONICS))
0607                 addl_desc_ptr += addl_desc_ptr[1] + 2;
0608 
0609         }
0610     }
0611     kfree(buf);
0612     kfree(hdr_buf);
0613 }
0614 
0615 static void ses_match_to_enclosure(struct enclosure_device *edev,
0616                    struct scsi_device *sdev,
0617                    int refresh)
0618 {
0619     struct scsi_device *edev_sdev = to_scsi_device(edev->edev.parent);
0620     struct efd efd = {
0621         .addr = 0,
0622     };
0623 
0624     if (refresh)
0625         ses_enclosure_data_process(edev, edev_sdev, 0);
0626 
0627     if (scsi_is_sas_rphy(sdev->sdev_target->dev.parent))
0628         efd.addr = sas_get_address(sdev);
0629 
0630     if (efd.addr) {
0631         efd.dev = &sdev->sdev_gendev;
0632 
0633         enclosure_for_each_device(ses_enclosure_find_by_addr, &efd);
0634     }
0635 }
0636 
0637 static int ses_intf_add(struct device *cdev,
0638             struct class_interface *intf)
0639 {
0640     struct scsi_device *sdev = to_scsi_device(cdev->parent);
0641     struct scsi_device *tmp_sdev;
0642     unsigned char *buf = NULL, *hdr_buf, *type_ptr, page;
0643     struct ses_device *ses_dev;
0644     u32 result;
0645     int i, types, len, components = 0;
0646     int err = -ENOMEM;
0647     int num_enclosures;
0648     struct enclosure_device *edev;
0649     struct ses_component *scomp = NULL;
0650 
0651     if (!scsi_device_enclosure(sdev)) {
0652         /* not an enclosure, but might be in one */
0653         struct enclosure_device *prev = NULL;
0654 
0655         while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) {
0656             ses_match_to_enclosure(edev, sdev, 1);
0657             prev = edev;
0658         }
0659         return -ENODEV;
0660     }
0661 
0662     /* TYPE_ENCLOSURE prints a message in probe */
0663     if (sdev->type != TYPE_ENCLOSURE)
0664         sdev_printk(KERN_NOTICE, sdev, "Embedded Enclosure Device\n");
0665 
0666     ses_dev = kzalloc(sizeof(*ses_dev), GFP_KERNEL);
0667     hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
0668     if (!hdr_buf || !ses_dev)
0669         goto err_init_free;
0670 
0671     page = 1;
0672     result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
0673     if (result)
0674         goto recv_failed;
0675 
0676     len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
0677     buf = kzalloc(len, GFP_KERNEL);
0678     if (!buf)
0679         goto err_free;
0680 
0681     result = ses_recv_diag(sdev, page, buf, len);
0682     if (result)
0683         goto recv_failed;
0684 
0685     types = 0;
0686 
0687     /* we always have one main enclosure and the rest are referred
0688      * to as secondary subenclosures */
0689     num_enclosures = buf[1] + 1;
0690 
0691     /* begin at the enclosure descriptor */
0692     type_ptr = buf + 8;
0693     /* skip all the enclosure descriptors */
0694     for (i = 0; i < num_enclosures && type_ptr < buf + len; i++) {
0695         types += type_ptr[2];
0696         type_ptr += type_ptr[3] + 4;
0697     }
0698 
0699     ses_dev->page1_types = type_ptr;
0700     ses_dev->page1_num_types = types;
0701 
0702     for (i = 0; i < types && type_ptr < buf + len; i++, type_ptr += 4) {
0703         if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
0704             type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE)
0705             components += type_ptr[1];
0706     }
0707     ses_dev->page1 = buf;
0708     ses_dev->page1_len = len;
0709     buf = NULL;
0710 
0711     page = 2;
0712     result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
0713     if (result)
0714         goto page2_not_supported;
0715 
0716     len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
0717     buf = kzalloc(len, GFP_KERNEL);
0718     if (!buf)
0719         goto err_free;
0720 
0721     /* make sure getting page 2 actually works */
0722     result = ses_recv_diag(sdev, 2, buf, len);
0723     if (result)
0724         goto recv_failed;
0725     ses_dev->page2 = buf;
0726     ses_dev->page2_len = len;
0727     buf = NULL;
0728 
0729     /* The additional information page --- allows us
0730      * to match up the devices */
0731     page = 10;
0732     result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
0733     if (!result) {
0734 
0735         len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
0736         buf = kzalloc(len, GFP_KERNEL);
0737         if (!buf)
0738             goto err_free;
0739 
0740         result = ses_recv_diag(sdev, page, buf, len);
0741         if (result)
0742             goto recv_failed;
0743         ses_dev->page10 = buf;
0744         ses_dev->page10_len = len;
0745         buf = NULL;
0746     }
0747 page2_not_supported:
0748     scomp = kcalloc(components, sizeof(struct ses_component), GFP_KERNEL);
0749     if (!scomp)
0750         goto err_free;
0751 
0752     edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev),
0753                   components, &ses_enclosure_callbacks);
0754     if (IS_ERR(edev)) {
0755         err = PTR_ERR(edev);
0756         goto err_free;
0757     }
0758 
0759     kfree(hdr_buf);
0760 
0761     edev->scratch = ses_dev;
0762     for (i = 0; i < components; i++)
0763         edev->component[i].scratch = scomp + i;
0764 
0765     ses_enclosure_data_process(edev, sdev, 1);
0766 
0767     /* see if there are any devices matching before
0768      * we found the enclosure */
0769     shost_for_each_device(tmp_sdev, sdev->host) {
0770         if (tmp_sdev->lun != 0 || scsi_device_enclosure(tmp_sdev))
0771             continue;
0772         ses_match_to_enclosure(edev, tmp_sdev, 0);
0773     }
0774 
0775     return 0;
0776 
0777  recv_failed:
0778     sdev_printk(KERN_ERR, sdev, "Failed to get diagnostic page 0x%x\n",
0779             page);
0780     err = -ENODEV;
0781  err_free:
0782     kfree(buf);
0783     kfree(scomp);
0784     kfree(ses_dev->page10);
0785     kfree(ses_dev->page2);
0786     kfree(ses_dev->page1);
0787  err_init_free:
0788     kfree(ses_dev);
0789     kfree(hdr_buf);
0790     sdev_printk(KERN_ERR, sdev, "Failed to bind enclosure %d\n", err);
0791     return err;
0792 }
0793 
0794 static int ses_remove(struct device *dev)
0795 {
0796     return 0;
0797 }
0798 
0799 static void ses_intf_remove_component(struct scsi_device *sdev)
0800 {
0801     struct enclosure_device *edev, *prev = NULL;
0802 
0803     while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) {
0804         prev = edev;
0805         if (!enclosure_remove_device(edev, &sdev->sdev_gendev))
0806             break;
0807     }
0808     if (edev)
0809         put_device(&edev->edev);
0810 }
0811 
0812 static void ses_intf_remove_enclosure(struct scsi_device *sdev)
0813 {
0814     struct enclosure_device *edev;
0815     struct ses_device *ses_dev;
0816 
0817     /*  exact match to this enclosure */
0818     edev = enclosure_find(&sdev->sdev_gendev, NULL);
0819     if (!edev)
0820         return;
0821 
0822     ses_dev = edev->scratch;
0823     edev->scratch = NULL;
0824 
0825     kfree(ses_dev->page10);
0826     kfree(ses_dev->page1);
0827     kfree(ses_dev->page2);
0828     kfree(ses_dev);
0829 
0830     kfree(edev->component[0].scratch);
0831 
0832     put_device(&edev->edev);
0833     enclosure_unregister(edev);
0834 }
0835 
0836 static void ses_intf_remove(struct device *cdev,
0837                 struct class_interface *intf)
0838 {
0839     struct scsi_device *sdev = to_scsi_device(cdev->parent);
0840 
0841     if (!scsi_device_enclosure(sdev))
0842         ses_intf_remove_component(sdev);
0843     else
0844         ses_intf_remove_enclosure(sdev);
0845 }
0846 
0847 static struct class_interface ses_interface = {
0848     .add_dev    = ses_intf_add,
0849     .remove_dev = ses_intf_remove,
0850 };
0851 
0852 static struct scsi_driver ses_template = {
0853     .gendrv = {
0854         .name       = "ses",
0855         .owner      = THIS_MODULE,
0856         .probe      = ses_probe,
0857         .remove     = ses_remove,
0858     },
0859 };
0860 
0861 static int __init ses_init(void)
0862 {
0863     int err;
0864 
0865     err = scsi_register_interface(&ses_interface);
0866     if (err)
0867         return err;
0868 
0869     err = scsi_register_driver(&ses_template.gendrv);
0870     if (err)
0871         goto out_unreg;
0872 
0873     return 0;
0874 
0875  out_unreg:
0876     scsi_unregister_interface(&ses_interface);
0877     return err;
0878 }
0879 
0880 static void __exit ses_exit(void)
0881 {
0882     scsi_unregister_driver(&ses_template.gendrv);
0883     scsi_unregister_interface(&ses_interface);
0884 }
0885 
0886 module_init(ses_init);
0887 module_exit(ses_exit);
0888 
0889 MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE);
0890 
0891 MODULE_AUTHOR("James Bottomley");
0892 MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver");
0893 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!