182c29810SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
29927c688SJames Bottomley /*
39927c688SJames Bottomley * SCSI Enclosure Services
49927c688SJames Bottomley *
59927c688SJames Bottomley * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com>
69927c688SJames Bottomley */
79927c688SJames Bottomley
85a0e3ad6STejun Heo #include <linux/slab.h>
99927c688SJames Bottomley #include <linux/module.h>
109927c688SJames Bottomley #include <linux/kernel.h>
119927c688SJames Bottomley #include <linux/enclosure.h>
12c38c007aSHannes Reinecke #include <asm/unaligned.h>
139927c688SJames Bottomley
149927c688SJames Bottomley #include <scsi/scsi.h>
159927c688SJames Bottomley #include <scsi/scsi_cmnd.h>
169927c688SJames Bottomley #include <scsi/scsi_dbg.h>
179927c688SJames Bottomley #include <scsi/scsi_device.h>
189927c688SJames Bottomley #include <scsi/scsi_driver.h>
199927c688SJames Bottomley #include <scsi/scsi_host.h>
209927c688SJames Bottomley
213f8d6f2aSJames Bottomley #include <scsi/scsi_transport_sas.h>
223f8d6f2aSJames Bottomley
239927c688SJames Bottomley struct ses_device {
24691b4773SYinghai Lu unsigned char *page1;
258c3adc79SJames Bottomley unsigned char *page1_types;
26691b4773SYinghai Lu unsigned char *page2;
27691b4773SYinghai Lu unsigned char *page10;
289927c688SJames Bottomley short page1_len;
298c3adc79SJames Bottomley short page1_num_types;
309927c688SJames Bottomley short page2_len;
319927c688SJames Bottomley short page10_len;
329927c688SJames Bottomley };
339927c688SJames Bottomley
349927c688SJames Bottomley struct ses_component {
359927c688SJames Bottomley u64 addr;
369927c688SJames Bottomley };
379927c688SJames Bottomley
ses_page2_supported(struct enclosure_device * edev)38dc56ce12SHannes Reinecke static bool ses_page2_supported(struct enclosure_device *edev)
39dc56ce12SHannes Reinecke {
40dc56ce12SHannes Reinecke struct ses_device *ses_dev = edev->scratch;
41dc56ce12SHannes Reinecke
42dc56ce12SHannes Reinecke return (ses_dev->page2 != NULL);
43dc56ce12SHannes Reinecke }
44dc56ce12SHannes Reinecke
ses_probe(struct device * dev)459927c688SJames Bottomley static int ses_probe(struct device *dev)
469927c688SJames Bottomley {
479927c688SJames Bottomley struct scsi_device *sdev = to_scsi_device(dev);
489927c688SJames Bottomley int err = -ENODEV;
499927c688SJames Bottomley
509927c688SJames Bottomley if (sdev->type != TYPE_ENCLOSURE)
519927c688SJames Bottomley goto out;
529927c688SJames Bottomley
539927c688SJames Bottomley err = 0;
549927c688SJames Bottomley sdev_printk(KERN_NOTICE, sdev, "Attached Enclosure device\n");
559927c688SJames Bottomley
569927c688SJames Bottomley out:
579927c688SJames Bottomley return err;
589927c688SJames Bottomley }
599927c688SJames Bottomley
60c95e62ceSMatthew Wilcox #define SES_TIMEOUT (30 * HZ)
619927c688SJames Bottomley #define SES_RETRIES 3
629927c688SJames Bottomley
init_device_slot_control(unsigned char * dest_desc,struct enclosure_component * ecomp,unsigned char * status)6308024885SSong Liu static void init_device_slot_control(unsigned char *dest_desc,
6408024885SSong Liu struct enclosure_component *ecomp,
6508024885SSong Liu unsigned char *status)
6608024885SSong Liu {
6708024885SSong Liu memcpy(dest_desc, status, 4);
6808024885SSong Liu dest_desc[0] = 0;
6908024885SSong Liu /* only clear byte 1 for ENCLOSURE_COMPONENT_DEVICE */
7008024885SSong Liu if (ecomp->type == ENCLOSURE_COMPONENT_DEVICE)
7108024885SSong Liu dest_desc[1] = 0;
7208024885SSong Liu dest_desc[2] &= 0xde;
7308024885SSong Liu dest_desc[3] &= 0x3c;
7408024885SSong Liu }
7508024885SSong Liu
7608024885SSong Liu
ses_recv_diag(struct scsi_device * sdev,int page_code,void * buf,int bufflen)779927c688SJames Bottomley static int ses_recv_diag(struct scsi_device *sdev, int page_code,
789927c688SJames Bottomley void *buf, int bufflen)
799927c688SJames Bottomley {
803417c1b5SJames Bottomley int ret;
81691b4773SYinghai Lu unsigned char cmd[] = {
829927c688SJames Bottomley RECEIVE_DIAGNOSTIC,
839927c688SJames Bottomley 1, /* Set PCV bit */
849927c688SJames Bottomley page_code,
859927c688SJames Bottomley bufflen >> 8,
869927c688SJames Bottomley bufflen & 0xff,
879927c688SJames Bottomley 0
889927c688SJames Bottomley };
893417c1b5SJames Bottomley unsigned char recv_page_code;
90fbdac19eSWen Xiong unsigned int retries = SES_RETRIES;
91fbdac19eSWen Xiong struct scsi_sense_hdr sshdr;
92ae4145a5SMike Christie const struct scsi_exec_args exec_args = {
93ae4145a5SMike Christie .sshdr = &sshdr,
94ae4145a5SMike Christie };
959927c688SJames Bottomley
96fbdac19eSWen Xiong do {
97ae4145a5SMike Christie ret = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_IN, buf, bufflen,
98ae4145a5SMike Christie SES_TIMEOUT, 1, &exec_args);
99fbdac19eSWen Xiong } while (ret > 0 && --retries && scsi_sense_valid(&sshdr) &&
100fbdac19eSWen Xiong (sshdr.sense_key == NOT_READY ||
101fbdac19eSWen Xiong (sshdr.sense_key == UNIT_ATTENTION && sshdr.asc == 0x29)));
102fbdac19eSWen Xiong
103424f727bSBrian King if (unlikely(ret))
1043417c1b5SJames Bottomley return ret;
1053417c1b5SJames Bottomley
1063417c1b5SJames Bottomley recv_page_code = ((unsigned char *)buf)[0];
1073417c1b5SJames Bottomley
1083417c1b5SJames Bottomley if (likely(recv_page_code == page_code))
1093417c1b5SJames Bottomley return ret;
1103417c1b5SJames Bottomley
1113417c1b5SJames Bottomley /* successful diagnostic but wrong page code. This happens to some
1123417c1b5SJames Bottomley * USB devices, just print a message and pretend there was an error */
1133417c1b5SJames Bottomley
1143417c1b5SJames Bottomley sdev_printk(KERN_ERR, sdev,
1153417c1b5SJames Bottomley "Wrong diagnostic page; asked for %d got %u\n",
1163417c1b5SJames Bottomley page_code, recv_page_code);
1173417c1b5SJames Bottomley
1183417c1b5SJames Bottomley return -EINVAL;
1199927c688SJames Bottomley }
1209927c688SJames Bottomley
ses_send_diag(struct scsi_device * sdev,int page_code,void * buf,int bufflen)1219927c688SJames Bottomley static int ses_send_diag(struct scsi_device *sdev, int page_code,
1229927c688SJames Bottomley void *buf, int bufflen)
1239927c688SJames Bottomley {
124dd689ed5SJiapeng Chong int result;
1259927c688SJames Bottomley
126691b4773SYinghai Lu unsigned char cmd[] = {
1279927c688SJames Bottomley SEND_DIAGNOSTIC,
1289927c688SJames Bottomley 0x10, /* Set PF bit */
1299927c688SJames Bottomley 0,
1309927c688SJames Bottomley bufflen >> 8,
1319927c688SJames Bottomley bufflen & 0xff,
1329927c688SJames Bottomley 0
1339927c688SJames Bottomley };
134fbdac19eSWen Xiong struct scsi_sense_hdr sshdr;
135fbdac19eSWen Xiong unsigned int retries = SES_RETRIES;
136ae4145a5SMike Christie const struct scsi_exec_args exec_args = {
137ae4145a5SMike Christie .sshdr = &sshdr,
138ae4145a5SMike Christie };
1399927c688SJames Bottomley
140fbdac19eSWen Xiong do {
141ae4145a5SMike Christie result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_OUT, buf,
142ae4145a5SMike Christie bufflen, SES_TIMEOUT, 1, &exec_args);
143fbdac19eSWen Xiong } while (result > 0 && --retries && scsi_sense_valid(&sshdr) &&
144fbdac19eSWen Xiong (sshdr.sense_key == NOT_READY ||
145fbdac19eSWen Xiong (sshdr.sense_key == UNIT_ATTENTION && sshdr.asc == 0x29)));
146fbdac19eSWen Xiong
1479927c688SJames Bottomley if (result)
1489927c688SJames Bottomley sdev_printk(KERN_ERR, sdev, "SEND DIAGNOSTIC result: %8x\n",
1499927c688SJames Bottomley result);
1509927c688SJames Bottomley return result;
1519927c688SJames Bottomley }
1529927c688SJames Bottomley
ses_set_page2_descriptor(struct enclosure_device * edev,struct enclosure_component * ecomp,unsigned char * desc)1539927c688SJames Bottomley static int ses_set_page2_descriptor(struct enclosure_device *edev,
1549927c688SJames Bottomley struct enclosure_component *ecomp,
155691b4773SYinghai Lu unsigned char *desc)
1569927c688SJames Bottomley {
1579927c688SJames Bottomley int i, j, count = 0, descriptor = ecomp->number;
158ee959b00STony Jones struct scsi_device *sdev = to_scsi_device(edev->edev.parent);
1599927c688SJames Bottomley struct ses_device *ses_dev = edev->scratch;
1608c3adc79SJames Bottomley unsigned char *type_ptr = ses_dev->page1_types;
161691b4773SYinghai Lu unsigned char *desc_ptr = ses_dev->page2 + 8;
1629927c688SJames Bottomley
1639927c688SJames Bottomley /* Clear everything */
1649927c688SJames Bottomley memset(desc_ptr, 0, ses_dev->page2_len - 8);
1658c3adc79SJames Bottomley for (i = 0; i < ses_dev->page1_num_types; i++, type_ptr += 4) {
1669927c688SJames Bottomley for (j = 0; j < type_ptr[1]; j++) {
1679927c688SJames Bottomley desc_ptr += 4;
1689927c688SJames Bottomley if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE &&
1699927c688SJames Bottomley type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE)
1709927c688SJames Bottomley continue;
1719927c688SJames Bottomley if (count++ == descriptor) {
1729927c688SJames Bottomley memcpy(desc_ptr, desc, 4);
1739927c688SJames Bottomley /* set select */
1749927c688SJames Bottomley desc_ptr[0] |= 0x80;
1759927c688SJames Bottomley /* clear reserved, just in case */
1769927c688SJames Bottomley desc_ptr[0] &= 0xf0;
1779927c688SJames Bottomley }
1789927c688SJames Bottomley }
1799927c688SJames Bottomley }
1809927c688SJames Bottomley
1819927c688SJames Bottomley return ses_send_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len);
1829927c688SJames Bottomley }
1839927c688SJames Bottomley
ses_get_page2_descriptor(struct enclosure_device * edev,struct enclosure_component * ecomp)184691b4773SYinghai Lu static unsigned char *ses_get_page2_descriptor(struct enclosure_device *edev,
1859927c688SJames Bottomley struct enclosure_component *ecomp)
1869927c688SJames Bottomley {
1879927c688SJames Bottomley int i, j, count = 0, descriptor = ecomp->number;
188ee959b00STony Jones struct scsi_device *sdev = to_scsi_device(edev->edev.parent);
1899927c688SJames Bottomley struct ses_device *ses_dev = edev->scratch;
1908c3adc79SJames Bottomley unsigned char *type_ptr = ses_dev->page1_types;
191691b4773SYinghai Lu unsigned char *desc_ptr = ses_dev->page2 + 8;
1929927c688SJames Bottomley
193acf8ab9aSHannes Reinecke if (ses_recv_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len) < 0)
194acf8ab9aSHannes Reinecke return NULL;
1959927c688SJames Bottomley
1968c3adc79SJames Bottomley for (i = 0; i < ses_dev->page1_num_types; i++, type_ptr += 4) {
1979927c688SJames Bottomley for (j = 0; j < type_ptr[1]; j++) {
1989927c688SJames Bottomley desc_ptr += 4;
1999927c688SJames Bottomley if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE &&
2009927c688SJames Bottomley type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE)
2019927c688SJames Bottomley continue;
2029927c688SJames Bottomley if (count++ == descriptor)
2039927c688SJames Bottomley return desc_ptr;
2049927c688SJames Bottomley }
2059927c688SJames Bottomley }
2069927c688SJames Bottomley return NULL;
2079927c688SJames Bottomley }
2089927c688SJames Bottomley
2092a350cabSDouglas Gilbert /* For device slot and array device slot elements, byte 3 bit 6
2102a350cabSDouglas Gilbert * is "fault sensed" while byte 3 bit 5 is "fault reqstd". As this
2112a350cabSDouglas Gilbert * code stands these bits are shifted 4 positions right so in
2122a350cabSDouglas Gilbert * sysfs they will appear as bits 2 and 1 respectively. Strange. */
ses_get_fault(struct enclosure_device * edev,struct enclosure_component * ecomp)2139927c688SJames Bottomley static void ses_get_fault(struct enclosure_device *edev,
2149927c688SJames Bottomley struct enclosure_component *ecomp)
2159927c688SJames Bottomley {
216691b4773SYinghai Lu unsigned char *desc;
2179927c688SJames Bottomley
218dc56ce12SHannes Reinecke if (!ses_page2_supported(edev)) {
219dc56ce12SHannes Reinecke ecomp->fault = 0;
220dc56ce12SHannes Reinecke return;
221dc56ce12SHannes Reinecke }
2229927c688SJames Bottomley desc = ses_get_page2_descriptor(edev, ecomp);
223691b4773SYinghai Lu if (desc)
2249927c688SJames Bottomley ecomp->fault = (desc[3] & 0x60) >> 4;
2259927c688SJames Bottomley }
2269927c688SJames Bottomley
ses_set_fault(struct enclosure_device * edev,struct enclosure_component * ecomp,enum enclosure_component_setting val)2279927c688SJames Bottomley static int ses_set_fault(struct enclosure_device *edev,
2289927c688SJames Bottomley struct enclosure_component *ecomp,
2299927c688SJames Bottomley enum enclosure_component_setting val)
2309927c688SJames Bottomley {
23108024885SSong Liu unsigned char desc[4];
23208024885SSong Liu unsigned char *desc_ptr;
23308024885SSong Liu
234dc56ce12SHannes Reinecke if (!ses_page2_supported(edev))
235dc56ce12SHannes Reinecke return -EINVAL;
236dc56ce12SHannes Reinecke
23708024885SSong Liu desc_ptr = ses_get_page2_descriptor(edev, ecomp);
23808024885SSong Liu
23908024885SSong Liu if (!desc_ptr)
24008024885SSong Liu return -EIO;
24108024885SSong Liu
24208024885SSong Liu init_device_slot_control(desc, ecomp, desc_ptr);
2439927c688SJames Bottomley
2449927c688SJames Bottomley switch (val) {
2459927c688SJames Bottomley case ENCLOSURE_SETTING_DISABLED:
24608024885SSong Liu desc[3] &= 0xdf;
2479927c688SJames Bottomley break;
2489927c688SJames Bottomley case ENCLOSURE_SETTING_ENABLED:
24908024885SSong Liu desc[3] |= 0x20;
2509927c688SJames Bottomley break;
2519927c688SJames Bottomley default:
2529927c688SJames Bottomley /* SES doesn't do the SGPIO blink settings */
2539927c688SJames Bottomley return -EINVAL;
2549927c688SJames Bottomley }
2559927c688SJames Bottomley
2569927c688SJames Bottomley return ses_set_page2_descriptor(edev, ecomp, desc);
2579927c688SJames Bottomley }
2589927c688SJames Bottomley
ses_get_status(struct enclosure_device * edev,struct enclosure_component * ecomp)2599927c688SJames Bottomley static void ses_get_status(struct enclosure_device *edev,
2609927c688SJames Bottomley struct enclosure_component *ecomp)
2619927c688SJames Bottomley {
262691b4773SYinghai Lu unsigned char *desc;
2639927c688SJames Bottomley
264dc56ce12SHannes Reinecke if (!ses_page2_supported(edev)) {
265dc56ce12SHannes Reinecke ecomp->status = 0;
266dc56ce12SHannes Reinecke return;
267dc56ce12SHannes Reinecke }
2689927c688SJames Bottomley desc = ses_get_page2_descriptor(edev, ecomp);
269691b4773SYinghai Lu if (desc)
2709927c688SJames Bottomley ecomp->status = (desc[0] & 0x0f);
2719927c688SJames Bottomley }
2729927c688SJames Bottomley
ses_get_locate(struct enclosure_device * edev,struct enclosure_component * ecomp)2739927c688SJames Bottomley static void ses_get_locate(struct enclosure_device *edev,
2749927c688SJames Bottomley struct enclosure_component *ecomp)
2759927c688SJames Bottomley {
276691b4773SYinghai Lu unsigned char *desc;
2779927c688SJames Bottomley
278dc56ce12SHannes Reinecke if (!ses_page2_supported(edev)) {
279dc56ce12SHannes Reinecke ecomp->locate = 0;
280dc56ce12SHannes Reinecke return;
281dc56ce12SHannes Reinecke }
2829927c688SJames Bottomley desc = ses_get_page2_descriptor(edev, ecomp);
283691b4773SYinghai Lu if (desc)
2849927c688SJames Bottomley ecomp->locate = (desc[2] & 0x02) ? 1 : 0;
2859927c688SJames Bottomley }
2869927c688SJames Bottomley
ses_set_locate(struct enclosure_device * edev,struct enclosure_component * ecomp,enum enclosure_component_setting val)2879927c688SJames Bottomley static int ses_set_locate(struct enclosure_device *edev,
2889927c688SJames Bottomley struct enclosure_component *ecomp,
2899927c688SJames Bottomley enum enclosure_component_setting val)
2909927c688SJames Bottomley {
29108024885SSong Liu unsigned char desc[4];
29208024885SSong Liu unsigned char *desc_ptr;
29308024885SSong Liu
294dc56ce12SHannes Reinecke if (!ses_page2_supported(edev))
295dc56ce12SHannes Reinecke return -EINVAL;
296dc56ce12SHannes Reinecke
29708024885SSong Liu desc_ptr = ses_get_page2_descriptor(edev, ecomp);
29808024885SSong Liu
29908024885SSong Liu if (!desc_ptr)
30008024885SSong Liu return -EIO;
30108024885SSong Liu
30208024885SSong Liu init_device_slot_control(desc, ecomp, desc_ptr);
3039927c688SJames Bottomley
3049927c688SJames Bottomley switch (val) {
3059927c688SJames Bottomley case ENCLOSURE_SETTING_DISABLED:
30608024885SSong Liu desc[2] &= 0xfd;
3079927c688SJames Bottomley break;
3089927c688SJames Bottomley case ENCLOSURE_SETTING_ENABLED:
30908024885SSong Liu desc[2] |= 0x02;
3109927c688SJames Bottomley break;
3119927c688SJames Bottomley default:
3129927c688SJames Bottomley /* SES doesn't do the SGPIO blink settings */
3139927c688SJames Bottomley return -EINVAL;
3149927c688SJames Bottomley }
3159927c688SJames Bottomley return ses_set_page2_descriptor(edev, ecomp, desc);
3169927c688SJames Bottomley }
3179927c688SJames Bottomley
ses_set_active(struct enclosure_device * edev,struct enclosure_component * ecomp,enum enclosure_component_setting val)3189927c688SJames Bottomley static int ses_set_active(struct enclosure_device *edev,
3199927c688SJames Bottomley struct enclosure_component *ecomp,
3209927c688SJames Bottomley enum enclosure_component_setting val)
3219927c688SJames Bottomley {
32208024885SSong Liu unsigned char desc[4];
32308024885SSong Liu unsigned char *desc_ptr;
32408024885SSong Liu
325dc56ce12SHannes Reinecke if (!ses_page2_supported(edev))
326dc56ce12SHannes Reinecke return -EINVAL;
327dc56ce12SHannes Reinecke
32808024885SSong Liu desc_ptr = ses_get_page2_descriptor(edev, ecomp);
32908024885SSong Liu
33008024885SSong Liu if (!desc_ptr)
33108024885SSong Liu return -EIO;
33208024885SSong Liu
33308024885SSong Liu init_device_slot_control(desc, ecomp, desc_ptr);
3349927c688SJames Bottomley
3359927c688SJames Bottomley switch (val) {
3369927c688SJames Bottomley case ENCLOSURE_SETTING_DISABLED:
33708024885SSong Liu desc[2] &= 0x7f;
3389927c688SJames Bottomley ecomp->active = 0;
3399927c688SJames Bottomley break;
3409927c688SJames Bottomley case ENCLOSURE_SETTING_ENABLED:
34108024885SSong Liu desc[2] |= 0x80;
3429927c688SJames Bottomley ecomp->active = 1;
3439927c688SJames Bottomley break;
3449927c688SJames Bottomley default:
3459927c688SJames Bottomley /* SES doesn't do the SGPIO blink settings */
3469927c688SJames Bottomley return -EINVAL;
3479927c688SJames Bottomley }
3489927c688SJames Bottomley return ses_set_page2_descriptor(edev, ecomp, desc);
3499927c688SJames Bottomley }
3509927c688SJames Bottomley
ses_show_id(struct enclosure_device * edev,char * buf)351967f7babSDan Williams static int ses_show_id(struct enclosure_device *edev, char *buf)
352967f7babSDan Williams {
353967f7babSDan Williams struct ses_device *ses_dev = edev->scratch;
354967f7babSDan Williams unsigned long long id = get_unaligned_be64(ses_dev->page1+8+4);
355967f7babSDan Williams
356967f7babSDan Williams return sprintf(buf, "%#llx\n", id);
357967f7babSDan Williams }
358967f7babSDan Williams
ses_get_power_status(struct enclosure_device * edev,struct enclosure_component * ecomp)35908024885SSong Liu static void ses_get_power_status(struct enclosure_device *edev,
36008024885SSong Liu struct enclosure_component *ecomp)
36108024885SSong Liu {
36208024885SSong Liu unsigned char *desc;
36308024885SSong Liu
364dc56ce12SHannes Reinecke if (!ses_page2_supported(edev)) {
365dc56ce12SHannes Reinecke ecomp->power_status = 0;
366dc56ce12SHannes Reinecke return;
367dc56ce12SHannes Reinecke }
368dc56ce12SHannes Reinecke
36908024885SSong Liu desc = ses_get_page2_descriptor(edev, ecomp);
37008024885SSong Liu if (desc)
37108024885SSong Liu ecomp->power_status = (desc[3] & 0x10) ? 0 : 1;
37208024885SSong Liu }
37308024885SSong Liu
ses_set_power_status(struct enclosure_device * edev,struct enclosure_component * ecomp,int val)37408024885SSong Liu static int ses_set_power_status(struct enclosure_device *edev,
37508024885SSong Liu struct enclosure_component *ecomp,
37608024885SSong Liu int val)
37708024885SSong Liu {
37808024885SSong Liu unsigned char desc[4];
37908024885SSong Liu unsigned char *desc_ptr;
38008024885SSong Liu
381dc56ce12SHannes Reinecke if (!ses_page2_supported(edev))
382dc56ce12SHannes Reinecke return -EINVAL;
383dc56ce12SHannes Reinecke
38408024885SSong Liu desc_ptr = ses_get_page2_descriptor(edev, ecomp);
38508024885SSong Liu
38608024885SSong Liu if (!desc_ptr)
38708024885SSong Liu return -EIO;
38808024885SSong Liu
38908024885SSong Liu init_device_slot_control(desc, ecomp, desc_ptr);
39008024885SSong Liu
39108024885SSong Liu switch (val) {
39208024885SSong Liu /* power = 1 is device_off = 0 and vice versa */
39308024885SSong Liu case 0:
39408024885SSong Liu desc[3] |= 0x10;
39508024885SSong Liu break;
39608024885SSong Liu case 1:
39708024885SSong Liu desc[3] &= 0xef;
39808024885SSong Liu break;
39908024885SSong Liu default:
40008024885SSong Liu return -EINVAL;
40108024885SSong Liu }
40208024885SSong Liu ecomp->power_status = val;
40308024885SSong Liu return ses_set_page2_descriptor(edev, ecomp, desc);
40408024885SSong Liu }
40508024885SSong Liu
4069927c688SJames Bottomley static struct enclosure_component_callbacks ses_enclosure_callbacks = {
4079927c688SJames Bottomley .get_fault = ses_get_fault,
4089927c688SJames Bottomley .set_fault = ses_set_fault,
4099927c688SJames Bottomley .get_status = ses_get_status,
4109927c688SJames Bottomley .get_locate = ses_get_locate,
4119927c688SJames Bottomley .set_locate = ses_set_locate,
41208024885SSong Liu .get_power_status = ses_get_power_status,
41308024885SSong Liu .set_power_status = ses_set_power_status,
4149927c688SJames Bottomley .set_active = ses_set_active,
415967f7babSDan Williams .show_id = ses_show_id,
4169927c688SJames Bottomley };
4179927c688SJames Bottomley
4189927c688SJames Bottomley struct ses_host_edev {
4199927c688SJames Bottomley struct Scsi_Host *shost;
4209927c688SJames Bottomley struct enclosure_device *edev;
4219927c688SJames Bottomley };
4229927c688SJames Bottomley
423e0aae1a5SAdrian Bunk #if 0
4249927c688SJames Bottomley int ses_match_host(struct enclosure_device *edev, void *data)
4259927c688SJames Bottomley {
4269927c688SJames Bottomley struct ses_host_edev *sed = data;
4279927c688SJames Bottomley struct scsi_device *sdev;
4289927c688SJames Bottomley
429ee959b00STony Jones if (!scsi_is_sdev_device(edev->edev.parent))
4309927c688SJames Bottomley return 0;
4319927c688SJames Bottomley
432ee959b00STony Jones sdev = to_scsi_device(edev->edev.parent);
4339927c688SJames Bottomley
4349927c688SJames Bottomley if (sdev->host != sed->shost)
4359927c688SJames Bottomley return 0;
4369927c688SJames Bottomley
4379927c688SJames Bottomley sed->edev = edev;
4389927c688SJames Bottomley return 1;
4399927c688SJames Bottomley }
440e0aae1a5SAdrian Bunk #endif /* 0 */
4419927c688SJames Bottomley
ses_process_descriptor(struct enclosure_component * ecomp,unsigned char * desc,int max_desc_len)442db95d4dfSTomas Henzl static int ses_process_descriptor(struct enclosure_component *ecomp,
443db95d4dfSTomas Henzl unsigned char *desc, int max_desc_len)
4449927c688SJames Bottomley {
4459927c688SJames Bottomley int eip = desc[0] & 0x10;
4469927c688SJames Bottomley int invalid = desc[0] & 0x80;
4479927c688SJames Bottomley enum scsi_protocol proto = desc[0] & 0x0f;
4489927c688SJames Bottomley u64 addr = 0;
449921ce7f5SDan Williams int slot = -1;
4509927c688SJames Bottomley struct ses_component *scomp = ecomp->scratch;
4519927c688SJames Bottomley unsigned char *d;
4529927c688SJames Bottomley
4539927c688SJames Bottomley if (invalid)
454db95d4dfSTomas Henzl return 0;
4559927c688SJames Bottomley
4569927c688SJames Bottomley switch (proto) {
457921ce7f5SDan Williams case SCSI_PROTOCOL_FCP:
458921ce7f5SDan Williams if (eip) {
459db95d4dfSTomas Henzl if (max_desc_len <= 7)
460db95d4dfSTomas Henzl return 1;
461921ce7f5SDan Williams d = desc + 4;
462921ce7f5SDan Williams slot = d[3];
463921ce7f5SDan Williams }
464921ce7f5SDan Williams break;
4659927c688SJames Bottomley case SCSI_PROTOCOL_SAS:
466db95d4dfSTomas Henzl
467921ce7f5SDan Williams if (eip) {
468db95d4dfSTomas Henzl if (max_desc_len <= 27)
469db95d4dfSTomas Henzl return 1;
470921ce7f5SDan Williams d = desc + 4;
471921ce7f5SDan Williams slot = d[3];
4729927c688SJames Bottomley d = desc + 8;
473db95d4dfSTomas Henzl } else {
474db95d4dfSTomas Henzl if (max_desc_len <= 23)
475db95d4dfSTomas Henzl return 1;
4769927c688SJames Bottomley d = desc + 4;
477db95d4dfSTomas Henzl }
478db95d4dfSTomas Henzl
479db95d4dfSTomas Henzl
4809927c688SJames Bottomley /* only take the phy0 addr */
4819927c688SJames Bottomley addr = (u64)d[12] << 56 |
4829927c688SJames Bottomley (u64)d[13] << 48 |
4839927c688SJames Bottomley (u64)d[14] << 40 |
4849927c688SJames Bottomley (u64)d[15] << 32 |
4859927c688SJames Bottomley (u64)d[16] << 24 |
4869927c688SJames Bottomley (u64)d[17] << 16 |
4879927c688SJames Bottomley (u64)d[18] << 8 |
4889927c688SJames Bottomley (u64)d[19];
4899927c688SJames Bottomley break;
4909927c688SJames Bottomley default:
4919927c688SJames Bottomley /* FIXME: Need to add more protocols than just SAS */
4929927c688SJames Bottomley break;
4939927c688SJames Bottomley }
494921ce7f5SDan Williams ecomp->slot = slot;
4959927c688SJames Bottomley scomp->addr = addr;
496db95d4dfSTomas Henzl
497db95d4dfSTomas Henzl return 0;
4989927c688SJames Bottomley }
4999927c688SJames Bottomley
5009927c688SJames Bottomley struct efd {
5019927c688SJames Bottomley u64 addr;
5029927c688SJames Bottomley struct device *dev;
5039927c688SJames Bottomley };
5049927c688SJames Bottomley
ses_enclosure_find_by_addr(struct enclosure_device * edev,void * data)5059927c688SJames Bottomley static int ses_enclosure_find_by_addr(struct enclosure_device *edev,
5069927c688SJames Bottomley void *data)
5079927c688SJames Bottomley {
5089927c688SJames Bottomley struct efd *efd = data;
5099927c688SJames Bottomley int i;
5109927c688SJames Bottomley struct ses_component *scomp;
5119927c688SJames Bottomley
5129927c688SJames Bottomley for (i = 0; i < edev->components; i++) {
5139927c688SJames Bottomley scomp = edev->component[i].scratch;
5149927c688SJames Bottomley if (scomp->addr != efd->addr)
5159927c688SJames Bottomley continue;
5169927c688SJames Bottomley
51715a0fbbcSDan Williams if (enclosure_add_device(edev, i, efd->dev) == 0)
51815a0fbbcSDan Williams kobject_uevent(&efd->dev->kobj, KOBJ_CHANGE);
5199927c688SJames Bottomley return 1;
5209927c688SJames Bottomley }
5219927c688SJames Bottomley return 0;
5229927c688SJames Bottomley }
5239927c688SJames Bottomley
52421fab1d0SJames Bottomley #define INIT_ALLOC_SIZE 32
52521fab1d0SJames Bottomley
ses_enclosure_data_process(struct enclosure_device * edev,struct scsi_device * sdev,int create)52621fab1d0SJames Bottomley static void ses_enclosure_data_process(struct enclosure_device *edev,
52721fab1d0SJames Bottomley struct scsi_device *sdev,
52821fab1d0SJames Bottomley int create)
52921fab1d0SJames Bottomley {
53021fab1d0SJames Bottomley u32 result;
53121fab1d0SJames Bottomley unsigned char *buf = NULL, *type_ptr, *desc_ptr, *addl_desc_ptr = NULL;
53221fab1d0SJames Bottomley int i, j, page7_len, len, components;
53321fab1d0SJames Bottomley struct ses_device *ses_dev = edev->scratch;
5348c3adc79SJames Bottomley int types = ses_dev->page1_num_types;
53521fab1d0SJames Bottomley unsigned char *hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
53621fab1d0SJames Bottomley
53721fab1d0SJames Bottomley if (!hdr_buf)
53821fab1d0SJames Bottomley goto simple_populate;
53921fab1d0SJames Bottomley
54021fab1d0SJames Bottomley /* re-read page 10 */
54121fab1d0SJames Bottomley if (ses_dev->page10)
54221fab1d0SJames Bottomley ses_recv_diag(sdev, 10, ses_dev->page10, ses_dev->page10_len);
54321fab1d0SJames Bottomley /* Page 7 for the descriptors is optional */
54421fab1d0SJames Bottomley result = ses_recv_diag(sdev, 7, hdr_buf, INIT_ALLOC_SIZE);
54521fab1d0SJames Bottomley if (result)
54621fab1d0SJames Bottomley goto simple_populate;
54721fab1d0SJames Bottomley
54821fab1d0SJames Bottomley page7_len = len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
54921fab1d0SJames Bottomley /* add 1 for trailing '\0' we'll use */
55021fab1d0SJames Bottomley buf = kzalloc(len + 1, GFP_KERNEL);
55121fab1d0SJames Bottomley if (!buf)
55221fab1d0SJames Bottomley goto simple_populate;
55321fab1d0SJames Bottomley result = ses_recv_diag(sdev, 7, buf, len);
55421fab1d0SJames Bottomley if (result) {
55521fab1d0SJames Bottomley simple_populate:
55621fab1d0SJames Bottomley kfree(buf);
55721fab1d0SJames Bottomley buf = NULL;
55821fab1d0SJames Bottomley desc_ptr = NULL;
55921fab1d0SJames Bottomley len = 0;
56021fab1d0SJames Bottomley page7_len = 0;
56121fab1d0SJames Bottomley } else {
56221fab1d0SJames Bottomley desc_ptr = buf + 8;
56321fab1d0SJames Bottomley len = (desc_ptr[2] << 8) + desc_ptr[3];
56421fab1d0SJames Bottomley /* skip past overall descriptor */
56521fab1d0SJames Bottomley desc_ptr += len + 4;
566877a5597SJohn Hughes }
567db95d4dfSTomas Henzl if (ses_dev->page10 && ses_dev->page10_len > 9)
56821fab1d0SJames Bottomley addl_desc_ptr = ses_dev->page10 + 8;
5698c3adc79SJames Bottomley type_ptr = ses_dev->page1_types;
57021fab1d0SJames Bottomley components = 0;
57121fab1d0SJames Bottomley for (i = 0; i < types; i++, type_ptr += 4) {
57221fab1d0SJames Bottomley for (j = 0; j < type_ptr[1]; j++) {
57321fab1d0SJames Bottomley char *name = NULL;
57421fab1d0SJames Bottomley struct enclosure_component *ecomp;
575db95d4dfSTomas Henzl int max_desc_len;
57621fab1d0SJames Bottomley
57721fab1d0SJames Bottomley if (desc_ptr) {
578801ab13dSTomas Henzl if (desc_ptr + 3 >= buf + page7_len) {
57921fab1d0SJames Bottomley desc_ptr = NULL;
58021fab1d0SJames Bottomley } else {
58121fab1d0SJames Bottomley len = (desc_ptr[2] << 8) + desc_ptr[3];
58221fab1d0SJames Bottomley desc_ptr += 4;
583801ab13dSTomas Henzl if (desc_ptr + len > buf + page7_len)
584801ab13dSTomas Henzl desc_ptr = NULL;
585801ab13dSTomas Henzl else {
58621fab1d0SJames Bottomley /* Add trailing zero - pushes into
58721fab1d0SJames Bottomley * reserved space */
58821fab1d0SJames Bottomley desc_ptr[len] = '\0';
58921fab1d0SJames Bottomley name = desc_ptr;
59021fab1d0SJames Bottomley }
59121fab1d0SJames Bottomley }
592801ab13dSTomas Henzl }
59321fab1d0SJames Bottomley if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
59421fab1d0SJames Bottomley type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) {
59521fab1d0SJames Bottomley
59621fab1d0SJames Bottomley if (create)
597ed09dcc8SDan Williams ecomp = enclosure_component_alloc(
598ed09dcc8SDan Williams edev,
59921fab1d0SJames Bottomley components++,
60021fab1d0SJames Bottomley type_ptr[0],
60121fab1d0SJames Bottomley name);
602*c8e22b7aSJiri Kosina else if (components < edev->components)
60321fab1d0SJames Bottomley ecomp = &edev->component[components++];
604*c8e22b7aSJiri Kosina else
605*c8e22b7aSJiri Kosina ecomp = ERR_PTR(-EINVAL);
60621fab1d0SJames Bottomley
607ed09dcc8SDan Williams if (!IS_ERR(ecomp)) {
608db95d4dfSTomas Henzl if (addl_desc_ptr) {
609db95d4dfSTomas Henzl max_desc_len = ses_dev->page10_len -
610db95d4dfSTomas Henzl (addl_desc_ptr - ses_dev->page10);
611db95d4dfSTomas Henzl if (ses_process_descriptor(ecomp,
612db95d4dfSTomas Henzl addl_desc_ptr,
613db95d4dfSTomas Henzl max_desc_len))
614db95d4dfSTomas Henzl addl_desc_ptr = NULL;
615db95d4dfSTomas Henzl }
616ed09dcc8SDan Williams if (create)
617ed09dcc8SDan Williams enclosure_component_register(
618ed09dcc8SDan Williams ecomp);
619ed09dcc8SDan Williams }
62021fab1d0SJames Bottomley }
62121fab1d0SJames Bottomley if (desc_ptr)
62221fab1d0SJames Bottomley desc_ptr += len;
62321fab1d0SJames Bottomley
6245e103356SJames Bottomley if (addl_desc_ptr &&
6255e103356SJames Bottomley /* only find additional descriptions for specific devices */
6265e103356SJames Bottomley (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
6275e103356SJames Bottomley type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE ||
6285e103356SJames Bottomley type_ptr[0] == ENCLOSURE_COMPONENT_SAS_EXPANDER ||
6295e103356SJames Bottomley /* these elements are optional */
6305e103356SJames Bottomley type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_TARGET_PORT ||
6315e103356SJames Bottomley type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_INITIATOR_PORT ||
6329b4f5028STomas Henzl type_ptr[0] == ENCLOSURE_COMPONENT_CONTROLLER_ELECTRONICS)) {
63321fab1d0SJames Bottomley addl_desc_ptr += addl_desc_ptr[1] + 2;
6349b4f5028STomas Henzl if (addl_desc_ptr + 1 >= ses_dev->page10 + ses_dev->page10_len)
6359b4f5028STomas Henzl addl_desc_ptr = NULL;
6369b4f5028STomas Henzl }
63721fab1d0SJames Bottomley }
63821fab1d0SJames Bottomley }
63921fab1d0SJames Bottomley kfree(buf);
64021fab1d0SJames Bottomley kfree(hdr_buf);
64121fab1d0SJames Bottomley }
64221fab1d0SJames Bottomley
ses_match_to_enclosure(struct enclosure_device * edev,struct scsi_device * sdev,int refresh)6439927c688SJames Bottomley static void ses_match_to_enclosure(struct enclosure_device *edev,
6449c0a5002SLi Dongyang struct scsi_device *sdev,
6459c0a5002SLi Dongyang int refresh)
6469927c688SJames Bottomley {
6479c0a5002SLi Dongyang struct scsi_device *edev_sdev = to_scsi_device(edev->edev.parent);
6489927c688SJames Bottomley struct efd efd = {
6499927c688SJames Bottomley .addr = 0,
6509927c688SJames Bottomley };
6519927c688SJames Bottomley
6529c0a5002SLi Dongyang if (refresh)
6539c0a5002SLi Dongyang ses_enclosure_data_process(edev, edev_sdev, 0);
65421fab1d0SJames Bottomley
6559373eba6SEwan D. Milne if (scsi_is_sas_rphy(sdev->sdev_target->dev.parent))
6563f8d6f2aSJames Bottomley efd.addr = sas_get_address(sdev);
657671a99c8SJames Bottomley
658c38c007aSHannes Reinecke if (efd.addr) {
6599927c688SJames Bottomley efd.dev = &sdev->sdev_gendev;
6609927c688SJames Bottomley
6619927c688SJames Bottomley enclosure_for_each_device(ses_enclosure_find_by_addr, &efd);
662c38c007aSHannes Reinecke }
6639927c688SJames Bottomley }
6649927c688SJames Bottomley
ses_intf_add(struct device * cdev)665ee959b00STony Jones static int ses_intf_add(struct device *cdev)
6669927c688SJames Bottomley {
6679927c688SJames Bottomley struct scsi_device *sdev = to_scsi_device(cdev->parent);
668ee959b00STony Jones struct scsi_device *tmp_sdev;
6699927c688SJames Bottomley unsigned char *buf = NULL, *hdr_buf, *type_ptr, page;
67081b59d75SHannes Reinecke struct ses_device *ses_dev;
6719927c688SJames Bottomley u32 result;
6729927c688SJames Bottomley int i, types, len, components = 0;
67321fab1d0SJames Bottomley int err = -ENOMEM;
6749927c688SJames Bottomley int num_enclosures;
6758c3adc79SJames Bottomley struct enclosure_device *edev;
6769927c688SJames Bottomley struct ses_component *scomp = NULL;
6777c46c20aSYinghai Lu
6789927c688SJames Bottomley if (!scsi_device_enclosure(sdev)) {
6799927c688SJames Bottomley /* not an enclosure, but might be in one */
6809927c688SJames Bottomley struct enclosure_device *prev = NULL;
681163f52b6SJames Bottomley
682163f52b6SJames Bottomley while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) {
683163f52b6SJames Bottomley ses_match_to_enclosure(edev, sdev, 1);
6849c0a5002SLi Dongyang prev = edev;
685163f52b6SJames Bottomley }
6869927c688SJames Bottomley return -ENODEV;
6879927c688SJames Bottomley }
6889927c688SJames Bottomley
6899927c688SJames Bottomley /* TYPE_ENCLOSURE prints a message in probe */
6909927c688SJames Bottomley if (sdev->type != TYPE_ENCLOSURE)
6919927c688SJames Bottomley sdev_printk(KERN_NOTICE, sdev, "Embedded Enclosure Device\n");
6929927c688SJames Bottomley
6939927c688SJames Bottomley ses_dev = kzalloc(sizeof(*ses_dev), GFP_KERNEL);
6949927c688SJames Bottomley hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
6959927c688SJames Bottomley if (!hdr_buf || !ses_dev)
6969927c688SJames Bottomley goto err_init_free;
6979927c688SJames Bottomley
6989927c688SJames Bottomley page = 1;
69981b59d75SHannes Reinecke result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
70081b59d75SHannes Reinecke if (result)
7019927c688SJames Bottomley goto recv_failed;
7029927c688SJames Bottomley
7039927c688SJames Bottomley len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
7049927c688SJames Bottomley buf = kzalloc(len, GFP_KERNEL);
7059927c688SJames Bottomley if (!buf)
7069927c688SJames Bottomley goto err_free;
7079927c688SJames Bottomley
7089927c688SJames Bottomley result = ses_recv_diag(sdev, page, buf, len);
70981b59d75SHannes Reinecke if (result)
7109927c688SJames Bottomley goto recv_failed;
7119927c688SJames Bottomley
7129927c688SJames Bottomley types = 0;
7138c3adc79SJames Bottomley
7149927c688SJames Bottomley /* we always have one main enclosure and the rest are referred
7158c3adc79SJames Bottomley * to as secondary subenclosures */
7168c3adc79SJames Bottomley num_enclosures = buf[1] + 1;
7178c3adc79SJames Bottomley
7189927c688SJames Bottomley /* begin at the enclosure descriptor */
7198c3adc79SJames Bottomley type_ptr = buf + 8;
7208c3adc79SJames Bottomley /* skip all the enclosure descriptors */
7218c3adc79SJames Bottomley for (i = 0; i < num_enclosures && type_ptr < buf + len; i++) {
7228c3adc79SJames Bottomley types += type_ptr[2];
7238c3adc79SJames Bottomley type_ptr += type_ptr[3] + 4;
7248c3adc79SJames Bottomley }
7258c3adc79SJames Bottomley
7268c3adc79SJames Bottomley ses_dev->page1_types = type_ptr;
7278c3adc79SJames Bottomley ses_dev->page1_num_types = types;
7288c3adc79SJames Bottomley
7298c3adc79SJames Bottomley for (i = 0; i < types && type_ptr < buf + len; i++, type_ptr += 4) {
7308c3adc79SJames Bottomley if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
7319927c688SJames Bottomley type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE)
7329927c688SJames Bottomley components += type_ptr[1];
7339927c688SJames Bottomley }
7349927c688SJames Bottomley
7353fe97ff3SJames Bottomley ses_dev->page1 = buf;
7367c46c20aSYinghai Lu ses_dev->page1_len = len;
7377c46c20aSYinghai Lu buf = NULL;
7387c46c20aSYinghai Lu
7399927c688SJames Bottomley page = 2;
74081b59d75SHannes Reinecke result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
74181b59d75SHannes Reinecke if (result)
7429927c688SJames Bottomley goto page2_not_supported;
743dc56ce12SHannes Reinecke
7449927c688SJames Bottomley len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
7459927c688SJames Bottomley buf = kzalloc(len, GFP_KERNEL);
7469927c688SJames Bottomley if (!buf)
7479927c688SJames Bottomley goto err_free;
7489927c688SJames Bottomley
7499927c688SJames Bottomley /* make sure getting page 2 actually works */
7509927c688SJames Bottomley result = ses_recv_diag(sdev, 2, buf, len);
7519927c688SJames Bottomley if (result)
7529927c688SJames Bottomley goto recv_failed;
7539927c688SJames Bottomley ses_dev->page2 = buf;
7549927c688SJames Bottomley ses_dev->page2_len = len;
7559927c688SJames Bottomley buf = NULL;
7567c46c20aSYinghai Lu
7579927c688SJames Bottomley /* The additional information page --- allows us
7589927c688SJames Bottomley * to match up the devices */
7599927c688SJames Bottomley page = 10;
76081b59d75SHannes Reinecke result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
76181b59d75SHannes Reinecke if (!result) {
762691b4773SYinghai Lu
7639927c688SJames Bottomley len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
7649927c688SJames Bottomley buf = kzalloc(len, GFP_KERNEL);
7659927c688SJames Bottomley if (!buf)
7669927c688SJames Bottomley goto err_free;
7679927c688SJames Bottomley
7689927c688SJames Bottomley result = ses_recv_diag(sdev, page, buf, len);
76981b59d75SHannes Reinecke if (result)
7709927c688SJames Bottomley goto recv_failed;
7719927c688SJames Bottomley ses_dev->page10 = buf;
7729927c688SJames Bottomley ses_dev->page10_len = len;
7739927c688SJames Bottomley buf = NULL;
7747c46c20aSYinghai Lu }
775691b4773SYinghai Lu page2_not_supported:
776dc56ce12SHannes Reinecke if (components > 0) {
777*c8e22b7aSJiri Kosina scomp = kcalloc(components, sizeof(struct ses_component), GFP_KERNEL);
7786396bb22SKees Cook if (!scomp)
7799927c688SJames Bottomley goto err_free;
7809927c688SJames Bottomley }
781*c8e22b7aSJiri Kosina
7829927c688SJames Bottomley edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev),
78371610f55SKay Sievers components, &ses_enclosure_callbacks);
7849927c688SJames Bottomley if (IS_ERR(edev)) {
7859927c688SJames Bottomley err = PTR_ERR(edev);
7869927c688SJames Bottomley goto err_free;
7879927c688SJames Bottomley }
7889927c688SJames Bottomley
7899927c688SJames Bottomley kfree(hdr_buf);
7909b3a6549SJulia Lawall
7919b3a6549SJulia Lawall edev->scratch = ses_dev;
7929927c688SJames Bottomley for (i = 0; i < components; i++)
7939927c688SJames Bottomley edev->component[i].scratch = scomp + i;
7947c46c20aSYinghai Lu
7959927c688SJames Bottomley ses_enclosure_data_process(edev, sdev, 1);
79621fab1d0SJames Bottomley
7979927c688SJames Bottomley /* see if there are any devices matching before
7989927c688SJames Bottomley * we found the enclosure */
7999927c688SJames Bottomley shost_for_each_device(tmp_sdev, sdev->host) {
8009927c688SJames Bottomley if (tmp_sdev->lun != 0 || scsi_device_enclosure(tmp_sdev))
8019927c688SJames Bottomley continue;
8029927c688SJames Bottomley ses_match_to_enclosure(edev, tmp_sdev, 0);
8039c0a5002SLi Dongyang }
8049927c688SJames Bottomley
8059927c688SJames Bottomley return 0;
8069927c688SJames Bottomley
8079927c688SJames Bottomley recv_failed:
8089927c688SJames Bottomley sdev_printk(KERN_ERR, sdev, "Failed to get diagnostic page 0x%x\n",
8099927c688SJames Bottomley page);
81081b59d75SHannes Reinecke err = -ENODEV;
8119927c688SJames Bottomley err_free:
8129927c688SJames Bottomley kfree(buf);
8139927c688SJames Bottomley kfree(scomp);
8147c46c20aSYinghai Lu kfree(ses_dev->page10);
8159927c688SJames Bottomley kfree(ses_dev->page2);
8169927c688SJames Bottomley kfree(ses_dev->page1);
8179927c688SJames Bottomley err_init_free:
8189927c688SJames Bottomley kfree(ses_dev);
8199927c688SJames Bottomley kfree(hdr_buf);
8209927c688SJames Bottomley sdev_printk(KERN_ERR, sdev, "Failed to bind enclosure %d\n", err);
8219927c688SJames Bottomley return err;
8229927c688SJames Bottomley }
8239927c688SJames Bottomley
ses_remove(struct device * dev)8249927c688SJames Bottomley static int ses_remove(struct device *dev)
8259927c688SJames Bottomley {
8269927c688SJames Bottomley return 0;
8279927c688SJames Bottomley }
8289927c688SJames Bottomley
ses_intf_remove_component(struct scsi_device * sdev)8299927c688SJames Bottomley static void ses_intf_remove_component(struct scsi_device *sdev)
83043d8eb9cSJames Bottomley {
8319927c688SJames Bottomley struct enclosure_device *edev, *prev = NULL;
83243d8eb9cSJames Bottomley
83343d8eb9cSJames Bottomley while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) {
83443d8eb9cSJames Bottomley prev = edev;
83543d8eb9cSJames Bottomley if (!enclosure_remove_device(edev, &sdev->sdev_gendev))
83643d8eb9cSJames Bottomley break;
83743d8eb9cSJames Bottomley }
83843d8eb9cSJames Bottomley if (edev)
83943d8eb9cSJames Bottomley put_device(&edev->edev);
84043d8eb9cSJames Bottomley }
84143d8eb9cSJames Bottomley
ses_intf_remove_enclosure(struct scsi_device * sdev)84243d8eb9cSJames Bottomley static void ses_intf_remove_enclosure(struct scsi_device *sdev)
84343d8eb9cSJames Bottomley {
84443d8eb9cSJames Bottomley struct enclosure_device *edev;
8459927c688SJames Bottomley struct ses_device *ses_dev;
8469927c688SJames Bottomley
8479927c688SJames Bottomley /* exact match to this enclosure */
848163f52b6SJames Bottomley edev = enclosure_find(&sdev->sdev_gendev, NULL);
84943d8eb9cSJames Bottomley if (!edev)
8509927c688SJames Bottomley return;
8519927c688SJames Bottomley
8529927c688SJames Bottomley ses_dev = edev->scratch;
8539927c688SJames Bottomley edev->scratch = NULL;
8549927c688SJames Bottomley
8559927c688SJames Bottomley kfree(ses_dev->page10);
8567c46c20aSYinghai Lu kfree(ses_dev->page1);
8579927c688SJames Bottomley kfree(ses_dev->page2);
8589927c688SJames Bottomley kfree(ses_dev);
8599927c688SJames Bottomley
8609927c688SJames Bottomley if (edev->components)
861578797f0STomas Henzl kfree(edev->component[0].scratch);
8629927c688SJames Bottomley
8639927c688SJames Bottomley put_device(&edev->edev);
864ee959b00STony Jones enclosure_unregister(edev);
865a5a039b0SCalvin Owens }
8669927c688SJames Bottomley
ses_intf_remove(struct device * cdev)8679927c688SJames Bottomley static void ses_intf_remove(struct device *cdev)
86843d8eb9cSJames Bottomley {
86943d8eb9cSJames Bottomley struct scsi_device *sdev = to_scsi_device(cdev->parent);
87043d8eb9cSJames Bottomley
87143d8eb9cSJames Bottomley if (!scsi_device_enclosure(sdev))
87243d8eb9cSJames Bottomley ses_intf_remove_component(sdev);
87343d8eb9cSJames Bottomley else
87443d8eb9cSJames Bottomley ses_intf_remove_enclosure(sdev);
87543d8eb9cSJames Bottomley }
87643d8eb9cSJames Bottomley
87743d8eb9cSJames Bottomley static struct class_interface ses_interface = {
87843d8eb9cSJames Bottomley .add_dev = ses_intf_add,
8799927c688SJames Bottomley .remove_dev = ses_intf_remove,
880ee959b00STony Jones };
881ee959b00STony Jones
8829927c688SJames Bottomley static struct scsi_driver ses_template = {
8839927c688SJames Bottomley .gendrv = {
8849927c688SJames Bottomley .name = "ses",
8859927c688SJames Bottomley .owner = THIS_MODULE,
8869927c688SJames Bottomley .probe = ses_probe,
8873af6b352SChristoph Hellwig .remove = ses_remove,
8889927c688SJames Bottomley },
8899927c688SJames Bottomley };
8909927c688SJames Bottomley
ses_init(void)8919927c688SJames Bottomley static int __init ses_init(void)
8929927c688SJames Bottomley {
8939927c688SJames Bottomley int err;
8949927c688SJames Bottomley
8959927c688SJames Bottomley err = scsi_register_interface(&ses_interface);
8969927c688SJames Bottomley if (err)
8979927c688SJames Bottomley return err;
8989927c688SJames Bottomley
8999927c688SJames Bottomley err = scsi_register_driver(&ses_template.gendrv);
9009927c688SJames Bottomley if (err)
9019927c688SJames Bottomley goto out_unreg;
9029927c688SJames Bottomley
9039927c688SJames Bottomley return 0;
9049927c688SJames Bottomley
9059927c688SJames Bottomley out_unreg:
9069927c688SJames Bottomley scsi_unregister_interface(&ses_interface);
9079927c688SJames Bottomley return err;
9089927c688SJames Bottomley }
9099927c688SJames Bottomley
ses_exit(void)9109927c688SJames Bottomley static void __exit ses_exit(void)
9119927c688SJames Bottomley {
9129927c688SJames Bottomley scsi_unregister_driver(&ses_template.gendrv);
9139927c688SJames Bottomley scsi_unregister_interface(&ses_interface);
9149927c688SJames Bottomley }
9159927c688SJames Bottomley
9169927c688SJames Bottomley module_init(ses_init);
9179927c688SJames Bottomley module_exit(ses_exit);
9189927c688SJames Bottomley
9199927c688SJames Bottomley MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE);
9209927c688SJames Bottomley
9219927c688SJames Bottomley MODULE_AUTHOR("James Bottomley");
9229927c688SJames Bottomley MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver");
9239927c688SJames Bottomley MODULE_LICENSE("GPL v2");
9249927c688SJames Bottomley