1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * SCSI Enclosure Services
4 *
5 * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com>
6 */
7
8 #include <linux/slab.h>
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/enclosure.h>
12 #include <linux/unaligned.h>
13
14 #include <scsi/scsi.h>
15 #include <scsi/scsi_cmnd.h>
16 #include <scsi/scsi_dbg.h>
17 #include <scsi/scsi_device.h>
18 #include <scsi/scsi_driver.h>
19 #include <scsi/scsi_host.h>
20
21 #include <scsi/scsi_transport_sas.h>
22
23 struct ses_device {
24 unsigned char *page1;
25 unsigned char *page1_types;
26 unsigned char *page2;
27 unsigned char *page10;
28 short page1_len;
29 short page1_num_types;
30 short page2_len;
31 short page10_len;
32 };
33
34 struct ses_component {
35 u64 addr;
36 };
37
ses_page2_supported(struct enclosure_device * edev)38 static bool ses_page2_supported(struct enclosure_device *edev)
39 {
40 struct ses_device *ses_dev = edev->scratch;
41
42 return (ses_dev->page2 != NULL);
43 }
44
ses_probe(struct scsi_device * sdev)45 static int ses_probe(struct scsi_device *sdev)
46 {
47 int err = -ENODEV;
48
49 if (sdev->type != TYPE_ENCLOSURE)
50 goto out;
51
52 err = 0;
53 sdev_printk(KERN_NOTICE, sdev, "Attached Enclosure device\n");
54
55 out:
56 return err;
57 }
58
59 #define SES_TIMEOUT (30 * HZ)
60 #define SES_RETRIES 3
61
init_device_slot_control(unsigned char * dest_desc,struct enclosure_component * ecomp,unsigned char * status)62 static void init_device_slot_control(unsigned char *dest_desc,
63 struct enclosure_component *ecomp,
64 unsigned char *status)
65 {
66 memcpy(dest_desc, status, 4);
67 dest_desc[0] = 0;
68 /* only clear byte 1 for ENCLOSURE_COMPONENT_DEVICE */
69 if (ecomp->type == ENCLOSURE_COMPONENT_DEVICE)
70 dest_desc[1] = 0;
71 dest_desc[2] &= 0xde;
72 dest_desc[3] &= 0x3c;
73 }
74
75
ses_recv_diag(struct scsi_device * sdev,int page_code,void * buf,int bufflen)76 static int ses_recv_diag(struct scsi_device *sdev, int page_code,
77 void *buf, int bufflen)
78 {
79 int ret;
80 unsigned char cmd[] = {
81 RECEIVE_DIAGNOSTIC,
82 1, /* Set PCV bit */
83 page_code,
84 bufflen >> 8,
85 bufflen & 0xff,
86 0
87 };
88 unsigned char recv_page_code;
89 struct scsi_failure failure_defs[] = {
90 {
91 .sense = UNIT_ATTENTION,
92 .asc = 0x29,
93 .ascq = SCMD_FAILURE_ASCQ_ANY,
94 .allowed = SES_RETRIES,
95 .result = SAM_STAT_CHECK_CONDITION,
96 },
97 {
98 .sense = NOT_READY,
99 .asc = SCMD_FAILURE_ASC_ANY,
100 .ascq = SCMD_FAILURE_ASCQ_ANY,
101 .allowed = SES_RETRIES,
102 .result = SAM_STAT_CHECK_CONDITION,
103 },
104 {}
105 };
106 struct scsi_failures failures = {
107 .failure_definitions = failure_defs,
108 };
109 const struct scsi_exec_args exec_args = {
110 .failures = &failures,
111 };
112
113 ret = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_IN, buf, bufflen,
114 SES_TIMEOUT, 1, &exec_args);
115 if (unlikely(ret))
116 return ret;
117
118 recv_page_code = ((unsigned char *)buf)[0];
119
120 if (likely(recv_page_code == page_code))
121 return ret;
122
123 /* successful diagnostic but wrong page code. This happens to some
124 * USB devices, just print a message and pretend there was an error */
125
126 sdev_printk(KERN_ERR, sdev,
127 "Wrong diagnostic page; asked for %d got %u\n",
128 page_code, recv_page_code);
129
130 return -EINVAL;
131 }
132
ses_send_diag(struct scsi_device * sdev,int page_code,void * buf,int bufflen)133 static int ses_send_diag(struct scsi_device *sdev, int page_code,
134 void *buf, int bufflen)
135 {
136 int result;
137
138 unsigned char cmd[] = {
139 SEND_DIAGNOSTIC,
140 0x10, /* Set PF bit */
141 0,
142 bufflen >> 8,
143 bufflen & 0xff,
144 0
145 };
146 struct scsi_failure failure_defs[] = {
147 {
148 .sense = UNIT_ATTENTION,
149 .asc = 0x29,
150 .ascq = SCMD_FAILURE_ASCQ_ANY,
151 .allowed = SES_RETRIES,
152 .result = SAM_STAT_CHECK_CONDITION,
153 },
154 {
155 .sense = NOT_READY,
156 .asc = SCMD_FAILURE_ASC_ANY,
157 .ascq = SCMD_FAILURE_ASCQ_ANY,
158 .allowed = SES_RETRIES,
159 .result = SAM_STAT_CHECK_CONDITION,
160 },
161 {}
162 };
163 struct scsi_failures failures = {
164 .failure_definitions = failure_defs,
165 };
166 const struct scsi_exec_args exec_args = {
167 .failures = &failures,
168 };
169
170 result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_OUT, buf, bufflen,
171 SES_TIMEOUT, 1, &exec_args);
172 if (result)
173 sdev_printk(KERN_ERR, sdev, "SEND DIAGNOSTIC result: %8x\n",
174 result);
175 return result;
176 }
177
ses_set_page2_descriptor(struct enclosure_device * edev,struct enclosure_component * ecomp,unsigned char * desc)178 static int ses_set_page2_descriptor(struct enclosure_device *edev,
179 struct enclosure_component *ecomp,
180 unsigned char *desc)
181 {
182 int i, j, count = 0, descriptor = ecomp->number;
183 struct scsi_device *sdev = to_scsi_device(edev->edev.parent);
184 struct ses_device *ses_dev = edev->scratch;
185 unsigned char *type_ptr = ses_dev->page1_types;
186 unsigned char *desc_ptr = ses_dev->page2 + 8;
187
188 /* Clear everything */
189 memset(desc_ptr, 0, ses_dev->page2_len - 8);
190 for (i = 0; i < ses_dev->page1_num_types; i++, type_ptr += 4) {
191 for (j = 0; j < type_ptr[1]; j++) {
192 desc_ptr += 4;
193 if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE &&
194 type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE)
195 continue;
196 if (count++ == descriptor) {
197 memcpy(desc_ptr, desc, 4);
198 /* set select */
199 desc_ptr[0] |= 0x80;
200 /* clear reserved, just in case */
201 desc_ptr[0] &= 0xf0;
202 }
203 }
204 }
205
206 return ses_send_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len);
207 }
208
ses_get_page2_descriptor(struct enclosure_device * edev,struct enclosure_component * ecomp)209 static unsigned char *ses_get_page2_descriptor(struct enclosure_device *edev,
210 struct enclosure_component *ecomp)
211 {
212 int i, j, count = 0, descriptor = ecomp->number;
213 struct scsi_device *sdev = to_scsi_device(edev->edev.parent);
214 struct ses_device *ses_dev = edev->scratch;
215 unsigned char *type_ptr = ses_dev->page1_types;
216 unsigned char *desc_ptr = ses_dev->page2 + 8;
217
218 if (ses_recv_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len) < 0)
219 return NULL;
220
221 for (i = 0; i < ses_dev->page1_num_types; i++, type_ptr += 4) {
222 for (j = 0; j < type_ptr[1]; j++) {
223 desc_ptr += 4;
224 if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE &&
225 type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE)
226 continue;
227 if (count++ == descriptor)
228 return desc_ptr;
229 }
230 }
231 return NULL;
232 }
233
234 /* For device slot and array device slot elements, byte 3 bit 6
235 * is "fault sensed" while byte 3 bit 5 is "fault reqstd". As this
236 * code stands these bits are shifted 4 positions right so in
237 * sysfs they will appear as bits 2 and 1 respectively. Strange. */
ses_get_fault(struct enclosure_device * edev,struct enclosure_component * ecomp)238 static void ses_get_fault(struct enclosure_device *edev,
239 struct enclosure_component *ecomp)
240 {
241 unsigned char *desc;
242
243 if (!ses_page2_supported(edev)) {
244 ecomp->fault = 0;
245 return;
246 }
247 desc = ses_get_page2_descriptor(edev, ecomp);
248 if (desc)
249 ecomp->fault = (desc[3] & 0x60) >> 4;
250 }
251
ses_set_fault(struct enclosure_device * edev,struct enclosure_component * ecomp,enum enclosure_component_setting val)252 static int ses_set_fault(struct enclosure_device *edev,
253 struct enclosure_component *ecomp,
254 enum enclosure_component_setting val)
255 {
256 unsigned char desc[4];
257 unsigned char *desc_ptr;
258
259 if (!ses_page2_supported(edev))
260 return -EINVAL;
261
262 desc_ptr = ses_get_page2_descriptor(edev, ecomp);
263
264 if (!desc_ptr)
265 return -EIO;
266
267 init_device_slot_control(desc, ecomp, desc_ptr);
268
269 switch (val) {
270 case ENCLOSURE_SETTING_DISABLED:
271 desc[3] &= 0xdf;
272 break;
273 case ENCLOSURE_SETTING_ENABLED:
274 desc[3] |= 0x20;
275 break;
276 default:
277 /* SES doesn't do the SGPIO blink settings */
278 return -EINVAL;
279 }
280
281 return ses_set_page2_descriptor(edev, ecomp, desc);
282 }
283
ses_get_status(struct enclosure_device * edev,struct enclosure_component * ecomp)284 static void ses_get_status(struct enclosure_device *edev,
285 struct enclosure_component *ecomp)
286 {
287 unsigned char *desc;
288
289 if (!ses_page2_supported(edev)) {
290 ecomp->status = 0;
291 return;
292 }
293 desc = ses_get_page2_descriptor(edev, ecomp);
294 if (desc)
295 ecomp->status = (desc[0] & 0x0f);
296 }
297
ses_get_locate(struct enclosure_device * edev,struct enclosure_component * ecomp)298 static void ses_get_locate(struct enclosure_device *edev,
299 struct enclosure_component *ecomp)
300 {
301 unsigned char *desc;
302
303 if (!ses_page2_supported(edev)) {
304 ecomp->locate = 0;
305 return;
306 }
307 desc = ses_get_page2_descriptor(edev, ecomp);
308 if (desc)
309 ecomp->locate = (desc[2] & 0x02) ? 1 : 0;
310 }
311
ses_set_locate(struct enclosure_device * edev,struct enclosure_component * ecomp,enum enclosure_component_setting val)312 static int ses_set_locate(struct enclosure_device *edev,
313 struct enclosure_component *ecomp,
314 enum enclosure_component_setting val)
315 {
316 unsigned char desc[4];
317 unsigned char *desc_ptr;
318
319 if (!ses_page2_supported(edev))
320 return -EINVAL;
321
322 desc_ptr = ses_get_page2_descriptor(edev, ecomp);
323
324 if (!desc_ptr)
325 return -EIO;
326
327 init_device_slot_control(desc, ecomp, desc_ptr);
328
329 switch (val) {
330 case ENCLOSURE_SETTING_DISABLED:
331 desc[2] &= 0xfd;
332 break;
333 case ENCLOSURE_SETTING_ENABLED:
334 desc[2] |= 0x02;
335 break;
336 default:
337 /* SES doesn't do the SGPIO blink settings */
338 return -EINVAL;
339 }
340 return ses_set_page2_descriptor(edev, ecomp, desc);
341 }
342
ses_set_active(struct enclosure_device * edev,struct enclosure_component * ecomp,enum enclosure_component_setting val)343 static int ses_set_active(struct enclosure_device *edev,
344 struct enclosure_component *ecomp,
345 enum enclosure_component_setting val)
346 {
347 unsigned char desc[4];
348 unsigned char *desc_ptr;
349
350 if (!ses_page2_supported(edev))
351 return -EINVAL;
352
353 desc_ptr = ses_get_page2_descriptor(edev, ecomp);
354
355 if (!desc_ptr)
356 return -EIO;
357
358 init_device_slot_control(desc, ecomp, desc_ptr);
359
360 switch (val) {
361 case ENCLOSURE_SETTING_DISABLED:
362 desc[2] &= 0x7f;
363 ecomp->active = 0;
364 break;
365 case ENCLOSURE_SETTING_ENABLED:
366 desc[2] |= 0x80;
367 ecomp->active = 1;
368 break;
369 default:
370 /* SES doesn't do the SGPIO blink settings */
371 return -EINVAL;
372 }
373 return ses_set_page2_descriptor(edev, ecomp, desc);
374 }
375
ses_show_id(struct enclosure_device * edev,char * buf)376 static int ses_show_id(struct enclosure_device *edev, char *buf)
377 {
378 struct ses_device *ses_dev = edev->scratch;
379 unsigned long long id = get_unaligned_be64(ses_dev->page1+8+4);
380
381 return sprintf(buf, "%#llx\n", id);
382 }
383
ses_get_power_status(struct enclosure_device * edev,struct enclosure_component * ecomp)384 static void ses_get_power_status(struct enclosure_device *edev,
385 struct enclosure_component *ecomp)
386 {
387 unsigned char *desc;
388
389 if (!ses_page2_supported(edev)) {
390 ecomp->power_status = 0;
391 return;
392 }
393
394 desc = ses_get_page2_descriptor(edev, ecomp);
395 if (desc)
396 ecomp->power_status = (desc[3] & 0x10) ? 0 : 1;
397 }
398
ses_set_power_status(struct enclosure_device * edev,struct enclosure_component * ecomp,int val)399 static int ses_set_power_status(struct enclosure_device *edev,
400 struct enclosure_component *ecomp,
401 int val)
402 {
403 unsigned char desc[4];
404 unsigned char *desc_ptr;
405
406 if (!ses_page2_supported(edev))
407 return -EINVAL;
408
409 desc_ptr = ses_get_page2_descriptor(edev, ecomp);
410
411 if (!desc_ptr)
412 return -EIO;
413
414 init_device_slot_control(desc, ecomp, desc_ptr);
415
416 switch (val) {
417 /* power = 1 is device_off = 0 and vice versa */
418 case 0:
419 desc[3] |= 0x10;
420 break;
421 case 1:
422 desc[3] &= 0xef;
423 break;
424 default:
425 return -EINVAL;
426 }
427 ecomp->power_status = val;
428 return ses_set_page2_descriptor(edev, ecomp, desc);
429 }
430
431 static struct enclosure_component_callbacks ses_enclosure_callbacks = {
432 .get_fault = ses_get_fault,
433 .set_fault = ses_set_fault,
434 .get_status = ses_get_status,
435 .get_locate = ses_get_locate,
436 .set_locate = ses_set_locate,
437 .get_power_status = ses_get_power_status,
438 .set_power_status = ses_set_power_status,
439 .set_active = ses_set_active,
440 .show_id = ses_show_id,
441 };
442
443 struct ses_host_edev {
444 struct Scsi_Host *shost;
445 struct enclosure_device *edev;
446 };
447
448 #if 0
449 int ses_match_host(struct enclosure_device *edev, void *data)
450 {
451 struct ses_host_edev *sed = data;
452 struct scsi_device *sdev;
453
454 if (!scsi_is_sdev_device(edev->edev.parent))
455 return 0;
456
457 sdev = to_scsi_device(edev->edev.parent);
458
459 if (sdev->host != sed->shost)
460 return 0;
461
462 sed->edev = edev;
463 return 1;
464 }
465 #endif /* 0 */
466
ses_process_descriptor(struct enclosure_component * ecomp,unsigned char * desc,int max_desc_len)467 static int ses_process_descriptor(struct enclosure_component *ecomp,
468 unsigned char *desc, int max_desc_len)
469 {
470 int eip = desc[0] & 0x10;
471 int invalid = desc[0] & 0x80;
472 enum scsi_protocol proto = desc[0] & 0x0f;
473 u64 addr = 0;
474 int slot = -1;
475 struct ses_component *scomp = ecomp->scratch;
476 unsigned char *d;
477
478 if (invalid)
479 return 0;
480
481 switch (proto) {
482 case SCSI_PROTOCOL_FCP:
483 if (eip) {
484 if (max_desc_len <= 7)
485 return 1;
486 d = desc + 4;
487 slot = d[3];
488 }
489 break;
490 case SCSI_PROTOCOL_SAS:
491
492 if (eip) {
493 if (max_desc_len <= 27)
494 return 1;
495 d = desc + 4;
496 slot = d[3];
497 d = desc + 8;
498 } else {
499 if (max_desc_len <= 23)
500 return 1;
501 d = desc + 4;
502 }
503
504
505 /* only take the phy0 addr */
506 addr = (u64)d[12] << 56 |
507 (u64)d[13] << 48 |
508 (u64)d[14] << 40 |
509 (u64)d[15] << 32 |
510 (u64)d[16] << 24 |
511 (u64)d[17] << 16 |
512 (u64)d[18] << 8 |
513 (u64)d[19];
514 break;
515 default:
516 /* FIXME: Need to add more protocols than just SAS */
517 break;
518 }
519 ecomp->slot = slot;
520 scomp->addr = addr;
521
522 return 0;
523 }
524
525 struct efd {
526 u64 addr;
527 struct device *dev;
528 };
529
ses_enclosure_find_by_addr(struct enclosure_device * edev,struct efd * efd)530 static int ses_enclosure_find_by_addr(struct enclosure_device *edev,
531 struct efd *efd)
532 {
533 int i;
534 struct ses_component *scomp;
535
536 for (i = 0; i < edev->components; i++) {
537 scomp = edev->component[i].scratch;
538 if (scomp->addr != efd->addr)
539 continue;
540
541 if (enclosure_add_device(edev, i, efd->dev) == 0)
542 kobject_uevent(&efd->dev->kobj, KOBJ_CHANGE);
543 return 1;
544 }
545 return 0;
546 }
547
548 #define INIT_ALLOC_SIZE 32
549
ses_enclosure_data_process(struct enclosure_device * edev,struct scsi_device * sdev,int create)550 static void ses_enclosure_data_process(struct enclosure_device *edev,
551 struct scsi_device *sdev,
552 int create)
553 {
554 u32 result;
555 unsigned char *buf = NULL, *type_ptr, *desc_ptr, *addl_desc_ptr = NULL;
556 int i, j, page7_len, len, components;
557 struct ses_device *ses_dev = edev->scratch;
558 int types = ses_dev->page1_num_types;
559 unsigned char *hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
560
561 if (!hdr_buf)
562 goto simple_populate;
563
564 /* re-read page 10 */
565 if (ses_dev->page10)
566 ses_recv_diag(sdev, 10, ses_dev->page10, ses_dev->page10_len);
567 /* Page 7 for the descriptors is optional */
568 result = ses_recv_diag(sdev, 7, hdr_buf, INIT_ALLOC_SIZE);
569 if (result)
570 goto simple_populate;
571
572 page7_len = len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
573 /* add 1 for trailing '\0' we'll use */
574 buf = kzalloc(len + 1, GFP_KERNEL);
575 if (!buf)
576 goto simple_populate;
577 result = ses_recv_diag(sdev, 7, buf, len);
578 if (result) {
579 simple_populate:
580 kfree(buf);
581 buf = NULL;
582 desc_ptr = NULL;
583 len = 0;
584 page7_len = 0;
585 } else {
586 desc_ptr = buf + 8;
587 len = (desc_ptr[2] << 8) + desc_ptr[3];
588 /* skip past overall descriptor */
589 desc_ptr += len + 4;
590 }
591 if (ses_dev->page10 && ses_dev->page10_len > 9)
592 addl_desc_ptr = ses_dev->page10 + 8;
593 type_ptr = ses_dev->page1_types;
594 components = 0;
595 for (i = 0; i < types; i++, type_ptr += 4) {
596 for (j = 0; j < type_ptr[1]; j++) {
597 char *name = NULL;
598 struct enclosure_component *ecomp;
599 int max_desc_len;
600
601 if (desc_ptr) {
602 if (desc_ptr + 3 >= buf + page7_len) {
603 desc_ptr = NULL;
604 } else {
605 len = (desc_ptr[2] << 8) + desc_ptr[3];
606 desc_ptr += 4;
607 if (desc_ptr + len > buf + page7_len)
608 desc_ptr = NULL;
609 else {
610 /* Add trailing zero - pushes into
611 * reserved space */
612 desc_ptr[len] = '\0';
613 name = desc_ptr;
614 }
615 }
616 }
617 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
618 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) {
619
620 if (create)
621 ecomp = enclosure_component_alloc(
622 edev,
623 components++,
624 type_ptr[0],
625 name);
626 else if (components < edev->components)
627 ecomp = &edev->component[components++];
628 else
629 ecomp = ERR_PTR(-EINVAL);
630
631 if (!IS_ERR(ecomp)) {
632 if (addl_desc_ptr) {
633 max_desc_len = ses_dev->page10_len -
634 (addl_desc_ptr - ses_dev->page10);
635 if (ses_process_descriptor(ecomp,
636 addl_desc_ptr,
637 max_desc_len))
638 addl_desc_ptr = NULL;
639 }
640 if (create)
641 enclosure_component_register(
642 ecomp);
643 }
644 }
645 if (desc_ptr)
646 desc_ptr += len;
647
648 if (addl_desc_ptr &&
649 /* only find additional descriptions for specific devices */
650 (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
651 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE ||
652 type_ptr[0] == ENCLOSURE_COMPONENT_SAS_EXPANDER ||
653 /* these elements are optional */
654 type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_TARGET_PORT ||
655 type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_INITIATOR_PORT ||
656 type_ptr[0] == ENCLOSURE_COMPONENT_CONTROLLER_ELECTRONICS)) {
657 addl_desc_ptr += addl_desc_ptr[1] + 2;
658 if (addl_desc_ptr + 1 >= ses_dev->page10 + ses_dev->page10_len)
659 addl_desc_ptr = NULL;
660 }
661 }
662 }
663 kfree(buf);
664 kfree(hdr_buf);
665 }
666
ses_match_to_enclosure(struct enclosure_device * edev,struct scsi_device * sdev,int refresh)667 static void ses_match_to_enclosure(struct enclosure_device *edev,
668 struct scsi_device *sdev,
669 int refresh)
670 {
671 struct scsi_device *edev_sdev = to_scsi_device(edev->edev.parent);
672 struct efd efd = {
673 .addr = 0,
674 };
675
676 if (refresh)
677 ses_enclosure_data_process(edev, edev_sdev, 0);
678
679 if (scsi_is_sas_rphy(sdev->sdev_target->dev.parent))
680 efd.addr = sas_get_address(sdev);
681
682 if (efd.addr) {
683 efd.dev = &sdev->sdev_gendev;
684
685 ses_enclosure_find_by_addr(edev, &efd);
686 }
687 }
688
ses_intf_add(struct device * cdev)689 static int ses_intf_add(struct device *cdev)
690 {
691 struct scsi_device *sdev = to_scsi_device(cdev->parent);
692 struct scsi_device *tmp_sdev;
693 unsigned char *buf = NULL, *hdr_buf, *type_ptr, page;
694 struct ses_device *ses_dev;
695 u32 result;
696 int i, types, len, components = 0;
697 int err = -ENOMEM;
698 int num_enclosures;
699 struct enclosure_device *edev;
700 struct ses_component *scomp = NULL;
701
702 if (!scsi_device_enclosure(sdev)) {
703 /* not an enclosure, but might be in one */
704 struct enclosure_device *prev = NULL;
705
706 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) {
707 ses_match_to_enclosure(edev, sdev, 1);
708 prev = edev;
709 }
710 return -ENODEV;
711 }
712
713 /* TYPE_ENCLOSURE prints a message in probe */
714 if (sdev->type != TYPE_ENCLOSURE)
715 sdev_printk(KERN_NOTICE, sdev, "Embedded Enclosure Device\n");
716
717 ses_dev = kzalloc_obj(*ses_dev);
718 hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
719 if (!hdr_buf || !ses_dev)
720 goto err_init_free;
721
722 page = 1;
723 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
724 if (result)
725 goto recv_failed;
726
727 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
728 buf = kzalloc(len, GFP_KERNEL);
729 if (!buf)
730 goto err_free;
731
732 result = ses_recv_diag(sdev, page, buf, len);
733 if (result)
734 goto recv_failed;
735
736 types = 0;
737
738 /* we always have one main enclosure and the rest are referred
739 * to as secondary subenclosures */
740 num_enclosures = buf[1] + 1;
741
742 /* begin at the enclosure descriptor */
743 type_ptr = buf + 8;
744 /* skip all the enclosure descriptors */
745 for (i = 0; i < num_enclosures && type_ptr < buf + len; i++) {
746 types += type_ptr[2];
747 type_ptr += type_ptr[3] + 4;
748 }
749
750 ses_dev->page1_types = type_ptr;
751 ses_dev->page1_num_types = types;
752
753 for (i = 0; i < types && type_ptr < buf + len; i++, type_ptr += 4) {
754 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
755 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE)
756 components += type_ptr[1];
757 }
758
759 ses_dev->page1 = buf;
760 ses_dev->page1_len = len;
761 buf = NULL;
762
763 page = 2;
764 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
765 if (result)
766 goto page2_not_supported;
767
768 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
769 buf = kzalloc(len, GFP_KERNEL);
770 if (!buf)
771 goto err_free;
772
773 /* make sure getting page 2 actually works */
774 result = ses_recv_diag(sdev, 2, buf, len);
775 if (result)
776 goto recv_failed;
777 ses_dev->page2 = buf;
778 ses_dev->page2_len = len;
779 buf = NULL;
780
781 /* The additional information page --- allows us
782 * to match up the devices */
783 page = 10;
784 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
785 if (!result) {
786
787 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
788 buf = kzalloc(len, GFP_KERNEL);
789 if (!buf)
790 goto err_free;
791
792 result = ses_recv_diag(sdev, page, buf, len);
793 if (result)
794 goto recv_failed;
795 ses_dev->page10 = buf;
796 ses_dev->page10_len = len;
797 buf = NULL;
798 }
799 page2_not_supported:
800 if (components > 0) {
801 scomp = kzalloc_objs(struct ses_component, components);
802 if (!scomp)
803 goto err_free;
804 }
805
806 edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev),
807 components, &ses_enclosure_callbacks);
808 if (IS_ERR(edev)) {
809 err = PTR_ERR(edev);
810 goto err_free;
811 }
812
813 kfree(hdr_buf);
814
815 edev->scratch = ses_dev;
816 for (i = 0; i < components; i++)
817 edev->component[i].scratch = scomp + i;
818
819 ses_enclosure_data_process(edev, sdev, 1);
820
821 /* see if there are any devices matching before
822 * we found the enclosure */
823 shost_for_each_device(tmp_sdev, sdev->host) {
824 if (tmp_sdev->lun != 0 || scsi_device_enclosure(tmp_sdev))
825 continue;
826 ses_match_to_enclosure(edev, tmp_sdev, 0);
827 }
828
829 return 0;
830
831 recv_failed:
832 sdev_printk(KERN_ERR, sdev, "Failed to get diagnostic page 0x%x\n",
833 page);
834 err = -ENODEV;
835 err_free:
836 kfree(buf);
837 kfree(scomp);
838 kfree(ses_dev->page10);
839 kfree(ses_dev->page2);
840 kfree(ses_dev->page1);
841 err_init_free:
842 kfree(ses_dev);
843 kfree(hdr_buf);
844 sdev_printk(KERN_ERR, sdev, "Failed to bind enclosure %d\n", err);
845 return err;
846 }
847
ses_intf_remove_component(struct scsi_device * sdev)848 static void ses_intf_remove_component(struct scsi_device *sdev)
849 {
850 struct enclosure_device *edev, *prev = NULL;
851
852 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) {
853 prev = edev;
854 if (!enclosure_remove_device(edev, &sdev->sdev_gendev))
855 break;
856 }
857 if (edev)
858 put_device(&edev->edev);
859 }
860
ses_intf_remove_enclosure(struct scsi_device * sdev)861 static void ses_intf_remove_enclosure(struct scsi_device *sdev)
862 {
863 struct enclosure_device *edev;
864 struct ses_device *ses_dev;
865
866 /* exact match to this enclosure */
867 edev = enclosure_find(&sdev->sdev_gendev, NULL);
868 if (!edev)
869 return;
870
871 ses_dev = edev->scratch;
872 edev->scratch = NULL;
873
874 kfree(ses_dev->page10);
875 kfree(ses_dev->page1);
876 kfree(ses_dev->page2);
877 kfree(ses_dev);
878
879 if (edev->components)
880 kfree(edev->component[0].scratch);
881
882 put_device(&edev->edev);
883 enclosure_unregister(edev);
884 }
885
ses_intf_remove(struct device * cdev)886 static void ses_intf_remove(struct device *cdev)
887 {
888 struct scsi_device *sdev = to_scsi_device(cdev->parent);
889
890 if (!scsi_device_enclosure(sdev))
891 ses_intf_remove_component(sdev);
892 else
893 ses_intf_remove_enclosure(sdev);
894 }
895
896 static struct class_interface ses_interface = {
897 .add_dev = ses_intf_add,
898 .remove_dev = ses_intf_remove,
899 };
900
901 static struct scsi_driver ses_template = {
902 .probe = ses_probe,
903 .gendrv = {
904 .name = "ses",
905 },
906 };
907
ses_init(void)908 static int __init ses_init(void)
909 {
910 int err;
911
912 err = scsi_register_interface(&ses_interface);
913 if (err)
914 return err;
915
916 err = scsi_register_driver(&ses_template);
917 if (err)
918 goto out_unreg;
919
920 return 0;
921
922 out_unreg:
923 scsi_unregister_interface(&ses_interface);
924 return err;
925 }
926
ses_exit(void)927 static void __exit ses_exit(void)
928 {
929 scsi_unregister_driver(&ses_template);
930 scsi_unregister_interface(&ses_interface);
931 }
932
933 module_init(ses_init);
934 module_exit(ses_exit);
935
936 MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE);
937
938 MODULE_AUTHOR("James Bottomley");
939 MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver");
940 MODULE_LICENSE("GPL v2");
941