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/module.h>
25 #include <linux/kernel.h>
26 #include <linux/enclosure.h>
28 #include <scsi/scsi.h>
29 #include <scsi/scsi_cmnd.h>
30 #include <scsi/scsi_dbg.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_driver.h>
33 #include <scsi/scsi_host.h>
38 unsigned char *page10
;
44 struct ses_component
{
49 static int ses_probe(struct device
*dev
)
51 struct scsi_device
*sdev
= to_scsi_device(dev
);
54 if (sdev
->type
!= TYPE_ENCLOSURE
)
58 sdev_printk(KERN_NOTICE
, sdev
, "Attached Enclosure device\n");
64 #define SES_TIMEOUT (30 * HZ)
67 static int ses_recv_diag(struct scsi_device
*sdev
, int page_code
,
68 void *buf
, int bufflen
)
70 unsigned char cmd
[] = {
79 return scsi_execute_req(sdev
, cmd
, DMA_FROM_DEVICE
, buf
, bufflen
,
80 NULL
, SES_TIMEOUT
, SES_RETRIES
, NULL
);
83 static int ses_send_diag(struct scsi_device
*sdev
, int page_code
,
84 void *buf
, int bufflen
)
88 unsigned char cmd
[] = {
90 0x10, /* Set PF bit */
97 result
= scsi_execute_req(sdev
, cmd
, DMA_TO_DEVICE
, buf
, bufflen
,
98 NULL
, SES_TIMEOUT
, SES_RETRIES
, NULL
);
100 sdev_printk(KERN_ERR
, sdev
, "SEND DIAGNOSTIC result: %8x\n",
105 static int ses_set_page2_descriptor(struct enclosure_device
*edev
,
106 struct enclosure_component
*ecomp
,
109 int i
, j
, count
= 0, descriptor
= ecomp
->number
;
110 struct scsi_device
*sdev
= to_scsi_device(edev
->edev
.parent
);
111 struct ses_device
*ses_dev
= edev
->scratch
;
112 unsigned char *type_ptr
= ses_dev
->page1
+ 12 + ses_dev
->page1
[11];
113 unsigned char *desc_ptr
= ses_dev
->page2
+ 8;
115 /* Clear everything */
116 memset(desc_ptr
, 0, ses_dev
->page2_len
- 8);
117 for (i
= 0; i
< ses_dev
->page1
[10]; i
++, type_ptr
+= 4) {
118 for (j
= 0; j
< type_ptr
[1]; j
++) {
120 if (type_ptr
[0] != ENCLOSURE_COMPONENT_DEVICE
&&
121 type_ptr
[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE
)
123 if (count
++ == descriptor
) {
124 memcpy(desc_ptr
, desc
, 4);
127 /* clear reserved, just in case */
133 return ses_send_diag(sdev
, 2, ses_dev
->page2
, ses_dev
->page2_len
);
136 static unsigned char *ses_get_page2_descriptor(struct enclosure_device
*edev
,
137 struct enclosure_component
*ecomp
)
139 int i
, j
, count
= 0, descriptor
= ecomp
->number
;
140 struct scsi_device
*sdev
= to_scsi_device(edev
->edev
.parent
);
141 struct ses_device
*ses_dev
= edev
->scratch
;
142 unsigned char *type_ptr
= ses_dev
->page1
+ 12 + ses_dev
->page1
[11];
143 unsigned char *desc_ptr
= ses_dev
->page2
+ 8;
145 ses_recv_diag(sdev
, 2, ses_dev
->page2
, ses_dev
->page2_len
);
147 for (i
= 0; i
< ses_dev
->page1
[10]; i
++, type_ptr
+= 4) {
148 for (j
= 0; j
< type_ptr
[1]; j
++) {
150 if (type_ptr
[0] != ENCLOSURE_COMPONENT_DEVICE
&&
151 type_ptr
[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE
)
153 if (count
++ == descriptor
)
160 static void ses_get_fault(struct enclosure_device
*edev
,
161 struct enclosure_component
*ecomp
)
165 desc
= ses_get_page2_descriptor(edev
, ecomp
);
167 ecomp
->fault
= (desc
[3] & 0x60) >> 4;
170 static int ses_set_fault(struct enclosure_device
*edev
,
171 struct enclosure_component
*ecomp
,
172 enum enclosure_component_setting val
)
174 unsigned char desc
[4] = {0 };
177 case ENCLOSURE_SETTING_DISABLED
:
178 /* zero is disabled */
180 case ENCLOSURE_SETTING_ENABLED
:
184 /* SES doesn't do the SGPIO blink settings */
188 return ses_set_page2_descriptor(edev
, ecomp
, desc
);
191 static void ses_get_status(struct enclosure_device
*edev
,
192 struct enclosure_component
*ecomp
)
196 desc
= ses_get_page2_descriptor(edev
, ecomp
);
198 ecomp
->status
= (desc
[0] & 0x0f);
201 static void ses_get_locate(struct enclosure_device
*edev
,
202 struct enclosure_component
*ecomp
)
206 desc
= ses_get_page2_descriptor(edev
, ecomp
);
208 ecomp
->locate
= (desc
[2] & 0x02) ? 1 : 0;
211 static int ses_set_locate(struct enclosure_device
*edev
,
212 struct enclosure_component
*ecomp
,
213 enum enclosure_component_setting val
)
215 unsigned char desc
[4] = {0 };
218 case ENCLOSURE_SETTING_DISABLED
:
219 /* zero is disabled */
221 case ENCLOSURE_SETTING_ENABLED
:
225 /* SES doesn't do the SGPIO blink settings */
228 return ses_set_page2_descriptor(edev
, ecomp
, desc
);
231 static int ses_set_active(struct enclosure_device
*edev
,
232 struct enclosure_component
*ecomp
,
233 enum enclosure_component_setting val
)
235 unsigned char desc
[4] = {0 };
238 case ENCLOSURE_SETTING_DISABLED
:
239 /* zero is disabled */
242 case ENCLOSURE_SETTING_ENABLED
:
247 /* SES doesn't do the SGPIO blink settings */
250 return ses_set_page2_descriptor(edev
, ecomp
, desc
);
253 static struct enclosure_component_callbacks ses_enclosure_callbacks
= {
254 .get_fault
= ses_get_fault
,
255 .set_fault
= ses_set_fault
,
256 .get_status
= ses_get_status
,
257 .get_locate
= ses_get_locate
,
258 .set_locate
= ses_set_locate
,
259 .set_active
= ses_set_active
,
262 struct ses_host_edev
{
263 struct Scsi_Host
*shost
;
264 struct enclosure_device
*edev
;
267 int ses_match_host(struct enclosure_device
*edev
, void *data
)
269 struct ses_host_edev
*sed
= data
;
270 struct scsi_device
*sdev
;
272 if (!scsi_is_sdev_device(edev
->edev
.parent
))
275 sdev
= to_scsi_device(edev
->edev
.parent
);
277 if (sdev
->host
!= sed
->shost
)
284 static void ses_process_descriptor(struct enclosure_component
*ecomp
,
287 int eip
= desc
[0] & 0x10;
288 int invalid
= desc
[0] & 0x80;
289 enum scsi_protocol proto
= desc
[0] & 0x0f;
291 struct ses_component
*scomp
= ecomp
->scratch
;
300 case SCSI_PROTOCOL_SAS
:
305 /* only take the phy0 addr */
306 addr
= (u64
)d
[12] << 56 |
316 /* FIXME: Need to add more protocols than just SAS */
327 static int ses_enclosure_find_by_addr(struct enclosure_device
*edev
,
330 struct efd
*efd
= data
;
332 struct ses_component
*scomp
;
334 if (!edev
->component
[0].scratch
)
337 for (i
= 0; i
< edev
->components
; i
++) {
338 scomp
= edev
->component
[i
].scratch
;
339 if (scomp
->addr
!= efd
->addr
)
342 enclosure_add_device(edev
, i
, efd
->dev
);
348 static void ses_match_to_enclosure(struct enclosure_device
*edev
,
349 struct scsi_device
*sdev
)
353 unsigned int vpd_len
;
358 buf
= scsi_get_vpd_page(sdev
, 0x83);
362 vpd_len
= ((buf
[2] << 8) | buf
[3]) + 4;
365 while (desc
< buf
+ vpd_len
) {
366 enum scsi_protocol proto
= desc
[0] >> 4;
367 u8 code_set
= desc
[0] & 0x0f;
368 u8 piv
= desc
[1] & 0x80;
369 u8 assoc
= (desc
[1] & 0x30) >> 4;
370 u8 type
= desc
[1] & 0x0f;
373 if (piv
&& code_set
== 1 && assoc
== 1
374 && proto
== SCSI_PROTOCOL_SAS
&& type
== 3 && len
== 8)
375 efd
.addr
= (u64
)desc
[4] << 56 |
389 efd
.dev
= &sdev
->sdev_gendev
;
391 enclosure_for_each_device(ses_enclosure_find_by_addr
, &efd
);
396 #define INIT_ALLOC_SIZE 32
398 static int ses_intf_add(struct device
*cdev
,
399 struct class_interface
*intf
)
401 struct scsi_device
*sdev
= to_scsi_device(cdev
->parent
);
402 struct scsi_device
*tmp_sdev
;
403 unsigned char *buf
= NULL
, *hdr_buf
, *type_ptr
, *desc_ptr
= NULL
,
404 *addl_desc_ptr
= NULL
;
405 struct ses_device
*ses_dev
;
407 int i
, j
, types
, len
, page7_len
= 0, components
= 0;
409 struct enclosure_device
*edev
;
410 struct ses_component
*scomp
= NULL
;
412 if (!scsi_device_enclosure(sdev
)) {
413 /* not an enclosure, but might be in one */
414 edev
= enclosure_find(&sdev
->host
->shost_gendev
);
416 ses_match_to_enclosure(edev
, sdev
);
417 put_device(&edev
->edev
);
422 /* TYPE_ENCLOSURE prints a message in probe */
423 if (sdev
->type
!= TYPE_ENCLOSURE
)
424 sdev_printk(KERN_NOTICE
, sdev
, "Embedded Enclosure Device\n");
426 ses_dev
= kzalloc(sizeof(*ses_dev
), GFP_KERNEL
);
427 hdr_buf
= kzalloc(INIT_ALLOC_SIZE
, GFP_KERNEL
);
428 if (!hdr_buf
|| !ses_dev
)
431 result
= ses_recv_diag(sdev
, 1, hdr_buf
, INIT_ALLOC_SIZE
);
435 if (hdr_buf
[1] != 0) {
436 /* FIXME: need subenclosure support; I've just never
437 * seen a device with subenclosures and it makes the
438 * traversal routines more complex */
439 sdev_printk(KERN_ERR
, sdev
,
440 "FIXME driver has no support for subenclosures (%d)\n",
445 len
= (hdr_buf
[2] << 8) + hdr_buf
[3] + 4;
446 buf
= kzalloc(len
, GFP_KERNEL
);
450 result
= ses_recv_diag(sdev
, 1, buf
, len
);
456 type_ptr
= buf
+ 12 + buf
[11];
458 for (i
= 0; i
< types
; i
++, type_ptr
+= 4) {
459 if (type_ptr
[0] == ENCLOSURE_COMPONENT_DEVICE
||
460 type_ptr
[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE
)
461 components
+= type_ptr
[1];
463 ses_dev
->page1
= buf
;
464 ses_dev
->page1_len
= len
;
467 result
= ses_recv_diag(sdev
, 2, hdr_buf
, INIT_ALLOC_SIZE
);
471 len
= (hdr_buf
[2] << 8) + hdr_buf
[3] + 4;
472 buf
= kzalloc(len
, GFP_KERNEL
);
476 /* make sure getting page 2 actually works */
477 result
= ses_recv_diag(sdev
, 2, buf
, len
);
480 ses_dev
->page2
= buf
;
481 ses_dev
->page2_len
= len
;
484 /* The additional information page --- allows us
485 * to match up the devices */
486 result
= ses_recv_diag(sdev
, 10, hdr_buf
, INIT_ALLOC_SIZE
);
489 len
= (hdr_buf
[2] << 8) + hdr_buf
[3] + 4;
490 buf
= kzalloc(len
, GFP_KERNEL
);
494 result
= ses_recv_diag(sdev
, 10, buf
, len
);
497 ses_dev
->page10
= buf
;
498 ses_dev
->page10_len
= len
;
502 scomp
= kzalloc(sizeof(struct ses_component
) * components
, GFP_KERNEL
);
506 edev
= enclosure_register(cdev
->parent
, dev_name(&sdev
->sdev_gendev
),
507 components
, &ses_enclosure_callbacks
);
513 edev
->scratch
= ses_dev
;
514 for (i
= 0; i
< components
; i
++)
515 edev
->component
[i
].scratch
= scomp
+ i
;
517 /* Page 7 for the descriptors is optional */
518 result
= ses_recv_diag(sdev
, 7, hdr_buf
, INIT_ALLOC_SIZE
);
520 goto simple_populate
;
522 page7_len
= len
= (hdr_buf
[2] << 8) + hdr_buf
[3] + 4;
523 /* add 1 for trailing '\0' we'll use */
524 buf
= kzalloc(len
+ 1, GFP_KERNEL
);
526 goto simple_populate
;
527 result
= ses_recv_diag(sdev
, 7, buf
, len
);
533 addl_desc_ptr
= NULL
;
536 len
= (desc_ptr
[2] << 8) + desc_ptr
[3];
537 /* skip past overall descriptor */
540 addl_desc_ptr
= ses_dev
->page10
+ 8;
542 type_ptr
= ses_dev
->page1
+ 12 + ses_dev
->page1
[11];
544 for (i
= 0; i
< types
; i
++, type_ptr
+= 4) {
545 for (j
= 0; j
< type_ptr
[1]; j
++) {
547 struct enclosure_component
*ecomp
;
550 if (desc_ptr
>= buf
+ page7_len
) {
553 len
= (desc_ptr
[2] << 8) + desc_ptr
[3];
555 /* Add trailing zero - pushes into
557 desc_ptr
[len
] = '\0';
561 if (type_ptr
[0] == ENCLOSURE_COMPONENT_DEVICE
||
562 type_ptr
[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE
) {
564 ecomp
= enclosure_component_register(edev
,
569 if (!IS_ERR(ecomp
) && addl_desc_ptr
)
570 ses_process_descriptor(ecomp
,
577 addl_desc_ptr
+= addl_desc_ptr
[1] + 2;
584 /* see if there are any devices matching before
585 * we found the enclosure */
586 shost_for_each_device(tmp_sdev
, sdev
->host
) {
587 if (tmp_sdev
->lun
!= 0 || scsi_device_enclosure(tmp_sdev
))
589 ses_match_to_enclosure(edev
, tmp_sdev
);
595 sdev_printk(KERN_ERR
, sdev
, "Failed to get diagnostic page 0x%x\n",
601 kfree(ses_dev
->page10
);
602 kfree(ses_dev
->page2
);
603 kfree(ses_dev
->page1
);
607 sdev_printk(KERN_ERR
, sdev
, "Failed to bind enclosure %d\n", err
);
611 static int ses_remove(struct device
*dev
)
616 static void ses_intf_remove(struct device
*cdev
,
617 struct class_interface
*intf
)
619 struct scsi_device
*sdev
= to_scsi_device(cdev
->parent
);
620 struct enclosure_device
*edev
;
621 struct ses_device
*ses_dev
;
623 if (!scsi_device_enclosure(sdev
))
626 edev
= enclosure_find(cdev
->parent
);
630 ses_dev
= edev
->scratch
;
631 edev
->scratch
= NULL
;
633 kfree(ses_dev
->page10
);
634 kfree(ses_dev
->page1
);
635 kfree(ses_dev
->page2
);
638 kfree(edev
->component
[0].scratch
);
640 put_device(&edev
->edev
);
641 enclosure_unregister(edev
);
644 static struct class_interface ses_interface
= {
645 .add_dev
= ses_intf_add
,
646 .remove_dev
= ses_intf_remove
,
649 static struct scsi_driver ses_template
= {
650 .owner
= THIS_MODULE
,
654 .remove
= ses_remove
,
658 static int __init
ses_init(void)
662 err
= scsi_register_interface(&ses_interface
);
666 err
= scsi_register_driver(&ses_template
.gendrv
);
673 scsi_unregister_interface(&ses_interface
);
677 static void __exit
ses_exit(void)
679 scsi_unregister_driver(&ses_template
.gendrv
);
680 scsi_unregister_interface(&ses_interface
);
683 module_init(ses_init
);
684 module_exit(ses_exit
);
686 MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE
);
688 MODULE_AUTHOR("James Bottomley");
689 MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver");
690 MODULE_LICENSE("GPL v2");