2 * SCSI Enclosure Services
4 * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com>
6 **-----------------------------------------------------------------------------
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.
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.
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.
21 **-----------------------------------------------------------------------------
24 #include <linux/slab.h>
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/enclosure.h>
29 #include <scsi/scsi.h>
30 #include <scsi/scsi_cmnd.h>
31 #include <scsi/scsi_dbg.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_driver.h>
34 #include <scsi/scsi_host.h>
39 unsigned char *page10
;
45 struct ses_component
{
50 static int ses_probe(struct device
*dev
)
52 struct scsi_device
*sdev
= to_scsi_device(dev
);
55 if (sdev
->type
!= TYPE_ENCLOSURE
)
59 sdev_printk(KERN_NOTICE
, sdev
, "Attached Enclosure device\n");
65 #define SES_TIMEOUT (30 * HZ)
68 static int ses_recv_diag(struct scsi_device
*sdev
, int page_code
,
69 void *buf
, int bufflen
)
71 unsigned char cmd
[] = {
80 return scsi_execute_req(sdev
, cmd
, DMA_FROM_DEVICE
, buf
, bufflen
,
81 NULL
, SES_TIMEOUT
, SES_RETRIES
, NULL
);
84 static int ses_send_diag(struct scsi_device
*sdev
, int page_code
,
85 void *buf
, int bufflen
)
89 unsigned char cmd
[] = {
91 0x10, /* Set PF bit */
98 result
= scsi_execute_req(sdev
, cmd
, DMA_TO_DEVICE
, buf
, bufflen
,
99 NULL
, SES_TIMEOUT
, SES_RETRIES
, NULL
);
101 sdev_printk(KERN_ERR
, sdev
, "SEND DIAGNOSTIC result: %8x\n",
106 static int ses_set_page2_descriptor(struct enclosure_device
*edev
,
107 struct enclosure_component
*ecomp
,
110 int i
, j
, count
= 0, descriptor
= ecomp
->number
;
111 struct scsi_device
*sdev
= to_scsi_device(edev
->edev
.parent
);
112 struct ses_device
*ses_dev
= edev
->scratch
;
113 unsigned char *type_ptr
= ses_dev
->page1
+ 12 + ses_dev
->page1
[11];
114 unsigned char *desc_ptr
= ses_dev
->page2
+ 8;
116 /* Clear everything */
117 memset(desc_ptr
, 0, ses_dev
->page2_len
- 8);
118 for (i
= 0; i
< ses_dev
->page1
[10]; i
++, type_ptr
+= 4) {
119 for (j
= 0; j
< type_ptr
[1]; j
++) {
121 if (type_ptr
[0] != ENCLOSURE_COMPONENT_DEVICE
&&
122 type_ptr
[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE
)
124 if (count
++ == descriptor
) {
125 memcpy(desc_ptr
, desc
, 4);
128 /* clear reserved, just in case */
134 return ses_send_diag(sdev
, 2, ses_dev
->page2
, ses_dev
->page2_len
);
137 static unsigned char *ses_get_page2_descriptor(struct enclosure_device
*edev
,
138 struct enclosure_component
*ecomp
)
140 int i
, j
, count
= 0, descriptor
= ecomp
->number
;
141 struct scsi_device
*sdev
= to_scsi_device(edev
->edev
.parent
);
142 struct ses_device
*ses_dev
= edev
->scratch
;
143 unsigned char *type_ptr
= ses_dev
->page1
+ 12 + ses_dev
->page1
[11];
144 unsigned char *desc_ptr
= ses_dev
->page2
+ 8;
146 ses_recv_diag(sdev
, 2, ses_dev
->page2
, ses_dev
->page2_len
);
148 for (i
= 0; i
< ses_dev
->page1
[10]; i
++, type_ptr
+= 4) {
149 for (j
= 0; j
< type_ptr
[1]; j
++) {
151 if (type_ptr
[0] != ENCLOSURE_COMPONENT_DEVICE
&&
152 type_ptr
[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE
)
154 if (count
++ == descriptor
)
161 static void ses_get_fault(struct enclosure_device
*edev
,
162 struct enclosure_component
*ecomp
)
166 desc
= ses_get_page2_descriptor(edev
, ecomp
);
168 ecomp
->fault
= (desc
[3] & 0x60) >> 4;
171 static int ses_set_fault(struct enclosure_device
*edev
,
172 struct enclosure_component
*ecomp
,
173 enum enclosure_component_setting val
)
175 unsigned char desc
[4] = {0 };
178 case ENCLOSURE_SETTING_DISABLED
:
179 /* zero is disabled */
181 case ENCLOSURE_SETTING_ENABLED
:
185 /* SES doesn't do the SGPIO blink settings */
189 return ses_set_page2_descriptor(edev
, ecomp
, desc
);
192 static void ses_get_status(struct enclosure_device
*edev
,
193 struct enclosure_component
*ecomp
)
197 desc
= ses_get_page2_descriptor(edev
, ecomp
);
199 ecomp
->status
= (desc
[0] & 0x0f);
202 static void ses_get_locate(struct enclosure_device
*edev
,
203 struct enclosure_component
*ecomp
)
207 desc
= ses_get_page2_descriptor(edev
, ecomp
);
209 ecomp
->locate
= (desc
[2] & 0x02) ? 1 : 0;
212 static int ses_set_locate(struct enclosure_device
*edev
,
213 struct enclosure_component
*ecomp
,
214 enum enclosure_component_setting val
)
216 unsigned char desc
[4] = {0 };
219 case ENCLOSURE_SETTING_DISABLED
:
220 /* zero is disabled */
222 case ENCLOSURE_SETTING_ENABLED
:
226 /* SES doesn't do the SGPIO blink settings */
229 return ses_set_page2_descriptor(edev
, ecomp
, desc
);
232 static int ses_set_active(struct enclosure_device
*edev
,
233 struct enclosure_component
*ecomp
,
234 enum enclosure_component_setting val
)
236 unsigned char desc
[4] = {0 };
239 case ENCLOSURE_SETTING_DISABLED
:
240 /* zero is disabled */
243 case ENCLOSURE_SETTING_ENABLED
:
248 /* SES doesn't do the SGPIO blink settings */
251 return ses_set_page2_descriptor(edev
, ecomp
, desc
);
254 static struct enclosure_component_callbacks ses_enclosure_callbacks
= {
255 .get_fault
= ses_get_fault
,
256 .set_fault
= ses_set_fault
,
257 .get_status
= ses_get_status
,
258 .get_locate
= ses_get_locate
,
259 .set_locate
= ses_set_locate
,
260 .set_active
= ses_set_active
,
263 struct ses_host_edev
{
264 struct Scsi_Host
*shost
;
265 struct enclosure_device
*edev
;
269 static void ses_process_descriptor(struct enclosure_component
*ecomp
,
272 int eip
= desc
[0] & 0x10;
273 int invalid
= desc
[0] & 0x80;
274 enum scsi_protocol proto
= desc
[0] & 0x0f;
276 struct ses_component
*scomp
= ecomp
->scratch
;
285 case SCSI_PROTOCOL_SAS
:
290 /* only take the phy0 addr */
291 addr
= (u64
)d
[12] << 56 |
311 static int ses_enclosure_find_by_addr(struct enclosure_device
*edev
,
314 struct efd
*efd
= data
;
316 struct ses_component
*scomp
;
318 if (!edev
->component
[0].scratch
)
321 for (i
= 0; i
< edev
->components
; i
++) {
322 scomp
= edev
->component
[i
].scratch
;
323 if (scomp
->addr
!= efd
->addr
)
326 enclosure_add_device(edev
, i
, efd
->dev
);
332 #define INIT_ALLOC_SIZE 32
334 static void ses_enclosure_data_process(struct enclosure_device
*edev
,
335 struct scsi_device
*sdev
,
339 unsigned char *buf
= NULL
, *type_ptr
, *desc_ptr
, *addl_desc_ptr
= NULL
;
340 int i
, j
, page7_len
, len
, components
;
341 struct ses_device
*ses_dev
= edev
->scratch
;
342 int types
= ses_dev
->page1
[10];
343 unsigned char *hdr_buf
= kzalloc(INIT_ALLOC_SIZE
, GFP_KERNEL
);
346 goto simple_populate
;
348 /* re-read page 10 */
350 ses_recv_diag(sdev
, 10, ses_dev
->page10
, ses_dev
->page10_len
);
351 /* Page 7 for the descriptors is optional */
352 result
= ses_recv_diag(sdev
, 7, hdr_buf
, INIT_ALLOC_SIZE
);
354 goto simple_populate
;
356 page7_len
= len
= (hdr_buf
[2] << 8) + hdr_buf
[3] + 4;
357 /* add 1 for trailing '\0' we'll use */
358 buf
= kzalloc(len
+ 1, GFP_KERNEL
);
360 goto simple_populate
;
361 result
= ses_recv_diag(sdev
, 7, buf
, len
);
371 len
= (desc_ptr
[2] << 8) + desc_ptr
[3];
372 /* skip past overall descriptor */
375 addl_desc_ptr
= ses_dev
->page10
+ 8;
377 type_ptr
= ses_dev
->page1
+ 12 + ses_dev
->page1
[11];
379 for (i
= 0; i
< types
; i
++, type_ptr
+= 4) {
380 for (j
= 0; j
< type_ptr
[1]; j
++) {
382 struct enclosure_component
*ecomp
;
385 if (desc_ptr
>= buf
+ page7_len
) {
388 len
= (desc_ptr
[2] << 8) + desc_ptr
[3];
390 /* Add trailing zero - pushes into
392 desc_ptr
[len
] = '\0';
396 if (type_ptr
[0] == ENCLOSURE_COMPONENT_DEVICE
||
397 type_ptr
[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE
) {
400 ecomp
= enclosure_component_register(edev
,
405 ecomp
= &edev
->component
[components
++];
407 if (!IS_ERR(ecomp
) && addl_desc_ptr
)
408 ses_process_descriptor(ecomp
,
415 addl_desc_ptr
+= addl_desc_ptr
[1] + 2;
423 static void ses_match_to_enclosure(struct enclosure_device
*edev
,
424 struct scsi_device
*sdev
)
428 unsigned int vpd_len
;
433 buf
= kmalloc(INIT_ALLOC_SIZE
, GFP_KERNEL
);
434 if (!buf
|| scsi_get_vpd_page(sdev
, 0x83, buf
, INIT_ALLOC_SIZE
))
437 ses_enclosure_data_process(edev
, to_scsi_device(edev
->edev
.parent
), 0);
439 vpd_len
= ((buf
[2] << 8) | buf
[3]) + 4;
441 buf
= kmalloc(vpd_len
, GFP_KERNEL
);
442 if (!buf
||scsi_get_vpd_page(sdev
, 0x83, buf
, vpd_len
))
446 while (desc
< buf
+ vpd_len
) {
447 enum scsi_protocol proto
= desc
[0] >> 4;
448 u8 code_set
= desc
[0] & 0x0f;
449 u8 piv
= desc
[1] & 0x80;
450 u8 assoc
= (desc
[1] & 0x30) >> 4;
451 u8 type
= desc
[1] & 0x0f;
454 if (piv
&& code_set
== 1 && assoc
== 1
455 && proto
== SCSI_PROTOCOL_SAS
&& type
== 3 && len
== 8)
456 efd
.addr
= (u64
)desc
[4] << 56 |
470 efd
.dev
= &sdev
->sdev_gendev
;
472 enclosure_for_each_device(ses_enclosure_find_by_addr
, &efd
);
477 static int ses_intf_add(struct device
*cdev
,
478 struct class_interface
*intf
)
480 struct scsi_device
*sdev
= to_scsi_device(cdev
->parent
);
481 struct scsi_device
*tmp_sdev
;
482 unsigned char *buf
= NULL
, *hdr_buf
, *type_ptr
;
483 struct ses_device
*ses_dev
;
485 int i
, types
, len
, components
= 0;
487 struct enclosure_device
*edev
;
488 struct ses_component
*scomp
= NULL
;
490 if (!scsi_device_enclosure(sdev
)) {
491 /* not an enclosure, but might be in one */
492 struct enclosure_device
*prev
= NULL
;
494 while ((edev
= enclosure_find(&sdev
->host
->shost_gendev
, prev
)) != NULL
) {
495 ses_match_to_enclosure(edev
, sdev
);
501 /* TYPE_ENCLOSURE prints a message in probe */
502 if (sdev
->type
!= TYPE_ENCLOSURE
)
503 sdev_printk(KERN_NOTICE
, sdev
, "Embedded Enclosure Device\n");
505 ses_dev
= kzalloc(sizeof(*ses_dev
), GFP_KERNEL
);
506 hdr_buf
= kzalloc(INIT_ALLOC_SIZE
, GFP_KERNEL
);
507 if (!hdr_buf
|| !ses_dev
)
510 result
= ses_recv_diag(sdev
, 1, hdr_buf
, INIT_ALLOC_SIZE
);
514 if (hdr_buf
[1] != 0) {
515 sdev_printk(KERN_ERR
, sdev
,
516 "FIXME driver has no support for subenclosures (%d)\n",
521 len
= (hdr_buf
[2] << 8) + hdr_buf
[3] + 4;
522 buf
= kzalloc(len
, GFP_KERNEL
);
526 result
= ses_recv_diag(sdev
, 1, buf
, len
);
532 type_ptr
= buf
+ 12 + buf
[11];
534 for (i
= 0; i
< types
; i
++, type_ptr
+= 4) {
535 if (type_ptr
[0] == ENCLOSURE_COMPONENT_DEVICE
||
536 type_ptr
[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE
)
537 components
+= type_ptr
[1];
539 ses_dev
->page1
= buf
;
540 ses_dev
->page1_len
= len
;
543 result
= ses_recv_diag(sdev
, 2, hdr_buf
, INIT_ALLOC_SIZE
);
547 len
= (hdr_buf
[2] << 8) + hdr_buf
[3] + 4;
548 buf
= kzalloc(len
, GFP_KERNEL
);
552 /* make sure getting page 2 actually works */
553 result
= ses_recv_diag(sdev
, 2, buf
, len
);
556 ses_dev
->page2
= buf
;
557 ses_dev
->page2_len
= len
;
560 /* The additional information page --- allows us
561 * to match up the devices */
562 result
= ses_recv_diag(sdev
, 10, hdr_buf
, INIT_ALLOC_SIZE
);
565 len
= (hdr_buf
[2] << 8) + hdr_buf
[3] + 4;
566 buf
= kzalloc(len
, GFP_KERNEL
);
570 result
= ses_recv_diag(sdev
, 10, buf
, len
);
573 ses_dev
->page10
= buf
;
574 ses_dev
->page10_len
= len
;
577 scomp
= kzalloc(sizeof(struct ses_component
) * components
, GFP_KERNEL
);
581 edev
= enclosure_register(cdev
->parent
, dev_name(&sdev
->sdev_gendev
),
582 components
, &ses_enclosure_callbacks
);
590 edev
->scratch
= ses_dev
;
591 for (i
= 0; i
< components
; i
++)
592 edev
->component
[i
].scratch
= scomp
+ i
;
594 ses_enclosure_data_process(edev
, sdev
, 1);
596 /* see if there are any devices matching before
597 * we found the enclosure */
598 shost_for_each_device(tmp_sdev
, sdev
->host
) {
599 if (tmp_sdev
->lun
!= 0 || scsi_device_enclosure(tmp_sdev
))
601 ses_match_to_enclosure(edev
, tmp_sdev
);
607 sdev_printk(KERN_ERR
, sdev
, "Failed to get diagnostic page 0x%x\n",
613 kfree(ses_dev
->page10
);
614 kfree(ses_dev
->page2
);
615 kfree(ses_dev
->page1
);
619 sdev_printk(KERN_ERR
, sdev
, "Failed to bind enclosure %d\n", err
);
623 static int ses_remove(struct device
*dev
)
628 static void ses_intf_remove_component(struct scsi_device
*sdev
)
630 struct enclosure_device
*edev
, *prev
= NULL
;
632 while ((edev
= enclosure_find(&sdev
->host
->shost_gendev
, prev
)) != NULL
) {
634 if (!enclosure_remove_device(edev
, &sdev
->sdev_gendev
))
638 put_device(&edev
->edev
);
641 static void ses_intf_remove_enclosure(struct scsi_device
*sdev
)
643 struct enclosure_device
*edev
;
644 struct ses_device
*ses_dev
;
646 /* exact match to this enclosure */
647 edev
= enclosure_find(&sdev
->sdev_gendev
, NULL
);
651 ses_dev
= edev
->scratch
;
652 edev
->scratch
= NULL
;
654 kfree(ses_dev
->page10
);
655 kfree(ses_dev
->page1
);
656 kfree(ses_dev
->page2
);
659 kfree(edev
->component
[0].scratch
);
661 put_device(&edev
->edev
);
662 enclosure_unregister(edev
);
665 static void ses_intf_remove(struct device
*cdev
,
666 struct class_interface
*intf
)
668 struct scsi_device
*sdev
= to_scsi_device(cdev
->parent
);
670 if (!scsi_device_enclosure(sdev
))
671 ses_intf_remove_component(sdev
);
673 ses_intf_remove_enclosure(sdev
);
676 static struct class_interface ses_interface
= {
677 .add_dev
= ses_intf_add
,
678 .remove_dev
= ses_intf_remove
,
681 static struct scsi_driver ses_template
= {
682 .owner
= THIS_MODULE
,
686 .remove
= ses_remove
,
690 static int __init
ses_init(void)
694 err
= scsi_register_interface(&ses_interface
);
698 err
= scsi_register_driver(&ses_template
.gendrv
);
705 scsi_unregister_interface(&ses_interface
);
709 static void __exit
ses_exit(void)
711 scsi_unregister_driver(&ses_template
.gendrv
);
712 scsi_unregister_interface(&ses_interface
);
715 module_init(ses_init
);
716 module_exit(ses_exit
);
718 MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE
);
720 MODULE_AUTHOR("James Bottomley");
721 MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver");
722 MODULE_LICENSE("GPL v2");