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,void * data)530 static int ses_enclosure_find_by_addr(struct enclosure_device *edev,
531 void *data)
532 {
533 struct efd *efd = data;
534 int i;
535 struct ses_component *scomp;
536
537 for (i = 0; i < edev->components; i++) {
538 scomp = edev->component[i].scratch;
539 if (scomp->addr != efd->addr)
540 continue;
541
542 if (enclosure_add_device(edev, i, efd->dev) == 0)
543 kobject_uevent(&efd->dev->kobj, KOBJ_CHANGE);
544 return 1;
545 }
546 return 0;
547 }
548
549 #define INIT_ALLOC_SIZE 32
550
ses_enclosure_data_process(struct enclosure_device * edev,struct scsi_device * sdev,int create)551 static void ses_enclosure_data_process(struct enclosure_device *edev,
552 struct scsi_device *sdev,
553 int create)
554 {
555 u32 result;
556 unsigned char *buf = NULL, *type_ptr, *desc_ptr, *addl_desc_ptr = NULL;
557 int i, j, page7_len, len, components;
558 struct ses_device *ses_dev = edev->scratch;
559 int types = ses_dev->page1_num_types;
560 unsigned char *hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
561
562 if (!hdr_buf)
563 goto simple_populate;
564
565 /* re-read page 10 */
566 if (ses_dev->page10)
567 ses_recv_diag(sdev, 10, ses_dev->page10, ses_dev->page10_len);
568 /* Page 7 for the descriptors is optional */
569 result = ses_recv_diag(sdev, 7, hdr_buf, INIT_ALLOC_SIZE);
570 if (result)
571 goto simple_populate;
572
573 page7_len = len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
574 /* add 1 for trailing '\0' we'll use */
575 buf = kzalloc(len + 1, GFP_KERNEL);
576 if (!buf)
577 goto simple_populate;
578 result = ses_recv_diag(sdev, 7, buf, len);
579 if (result) {
580 simple_populate:
581 kfree(buf);
582 buf = NULL;
583 desc_ptr = NULL;
584 len = 0;
585 page7_len = 0;
586 } else {
587 desc_ptr = buf + 8;
588 len = (desc_ptr[2] << 8) + desc_ptr[3];
589 /* skip past overall descriptor */
590 desc_ptr += len + 4;
591 }
592 if (ses_dev->page10 && ses_dev->page10_len > 9)
593 addl_desc_ptr = ses_dev->page10 + 8;
594 type_ptr = ses_dev->page1_types;
595 components = 0;
596 for (i = 0; i < types; i++, type_ptr += 4) {
597 for (j = 0; j < type_ptr[1]; j++) {
598 char *name = NULL;
599 struct enclosure_component *ecomp;
600 int max_desc_len;
601
602 if (desc_ptr) {
603 if (desc_ptr + 3 >= buf + page7_len) {
604 desc_ptr = NULL;
605 } else {
606 len = (desc_ptr[2] << 8) + desc_ptr[3];
607 desc_ptr += 4;
608 if (desc_ptr + len > buf + page7_len)
609 desc_ptr = NULL;
610 else {
611 /* Add trailing zero - pushes into
612 * reserved space */
613 desc_ptr[len] = '\0';
614 name = desc_ptr;
615 }
616 }
617 }
618 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
619 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) {
620
621 if (create)
622 ecomp = enclosure_component_alloc(
623 edev,
624 components++,
625 type_ptr[0],
626 name);
627 else if (components < edev->components)
628 ecomp = &edev->component[components++];
629 else
630 ecomp = ERR_PTR(-EINVAL);
631
632 if (!IS_ERR(ecomp)) {
633 if (addl_desc_ptr) {
634 max_desc_len = ses_dev->page10_len -
635 (addl_desc_ptr - ses_dev->page10);
636 if (ses_process_descriptor(ecomp,
637 addl_desc_ptr,
638 max_desc_len))
639 addl_desc_ptr = NULL;
640 }
641 if (create)
642 enclosure_component_register(
643 ecomp);
644 }
645 }
646 if (desc_ptr)
647 desc_ptr += len;
648
649 if (addl_desc_ptr &&
650 /* only find additional descriptions for specific devices */
651 (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
652 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE ||
653 type_ptr[0] == ENCLOSURE_COMPONENT_SAS_EXPANDER ||
654 /* these elements are optional */
655 type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_TARGET_PORT ||
656 type_ptr[0] == ENCLOSURE_COMPONENT_SCSI_INITIATOR_PORT ||
657 type_ptr[0] == ENCLOSURE_COMPONENT_CONTROLLER_ELECTRONICS)) {
658 addl_desc_ptr += addl_desc_ptr[1] + 2;
659 if (addl_desc_ptr + 1 >= ses_dev->page10 + ses_dev->page10_len)
660 addl_desc_ptr = NULL;
661 }
662 }
663 }
664 kfree(buf);
665 kfree(hdr_buf);
666 }
667
ses_match_to_enclosure(struct enclosure_device * edev,struct scsi_device * sdev,int refresh)668 static void ses_match_to_enclosure(struct enclosure_device *edev,
669 struct scsi_device *sdev,
670 int refresh)
671 {
672 struct scsi_device *edev_sdev = to_scsi_device(edev->edev.parent);
673 struct efd efd = {
674 .addr = 0,
675 };
676
677 if (refresh)
678 ses_enclosure_data_process(edev, edev_sdev, 0);
679
680 if (scsi_is_sas_rphy(sdev->sdev_target->dev.parent))
681 efd.addr = sas_get_address(sdev);
682
683 if (efd.addr) {
684 efd.dev = &sdev->sdev_gendev;
685
686 enclosure_for_each_device(ses_enclosure_find_by_addr, &efd);
687 }
688 }
689
ses_intf_add(struct device * cdev)690 static int ses_intf_add(struct device *cdev)
691 {
692 struct scsi_device *sdev = to_scsi_device(cdev->parent);
693 struct scsi_device *tmp_sdev;
694 unsigned char *buf = NULL, *hdr_buf, *type_ptr, page;
695 struct ses_device *ses_dev;
696 u32 result;
697 int i, types, len, components = 0;
698 int err = -ENOMEM;
699 int num_enclosures;
700 struct enclosure_device *edev;
701 struct ses_component *scomp = NULL;
702
703 if (!scsi_device_enclosure(sdev)) {
704 /* not an enclosure, but might be in one */
705 struct enclosure_device *prev = NULL;
706
707 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) {
708 ses_match_to_enclosure(edev, sdev, 1);
709 prev = edev;
710 }
711 return -ENODEV;
712 }
713
714 /* TYPE_ENCLOSURE prints a message in probe */
715 if (sdev->type != TYPE_ENCLOSURE)
716 sdev_printk(KERN_NOTICE, sdev, "Embedded Enclosure Device\n");
717
718 ses_dev = kzalloc_obj(*ses_dev, GFP_KERNEL);
719 hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
720 if (!hdr_buf || !ses_dev)
721 goto err_init_free;
722
723 page = 1;
724 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
725 if (result)
726 goto recv_failed;
727
728 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
729 buf = kzalloc(len, GFP_KERNEL);
730 if (!buf)
731 goto err_free;
732
733 result = ses_recv_diag(sdev, page, buf, len);
734 if (result)
735 goto recv_failed;
736
737 types = 0;
738
739 /* we always have one main enclosure and the rest are referred
740 * to as secondary subenclosures */
741 num_enclosures = buf[1] + 1;
742
743 /* begin at the enclosure descriptor */
744 type_ptr = buf + 8;
745 /* skip all the enclosure descriptors */
746 for (i = 0; i < num_enclosures && type_ptr < buf + len; i++) {
747 types += type_ptr[2];
748 type_ptr += type_ptr[3] + 4;
749 }
750
751 ses_dev->page1_types = type_ptr;
752 ses_dev->page1_num_types = types;
753
754 for (i = 0; i < types && type_ptr < buf + len; i++, type_ptr += 4) {
755 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE ||
756 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE)
757 components += type_ptr[1];
758 }
759
760 ses_dev->page1 = buf;
761 ses_dev->page1_len = len;
762 buf = NULL;
763
764 page = 2;
765 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
766 if (result)
767 goto page2_not_supported;
768
769 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
770 buf = kzalloc(len, GFP_KERNEL);
771 if (!buf)
772 goto err_free;
773
774 /* make sure getting page 2 actually works */
775 result = ses_recv_diag(sdev, 2, buf, len);
776 if (result)
777 goto recv_failed;
778 ses_dev->page2 = buf;
779 ses_dev->page2_len = len;
780 buf = NULL;
781
782 /* The additional information page --- allows us
783 * to match up the devices */
784 page = 10;
785 result = ses_recv_diag(sdev, page, hdr_buf, INIT_ALLOC_SIZE);
786 if (!result) {
787
788 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4;
789 buf = kzalloc(len, GFP_KERNEL);
790 if (!buf)
791 goto err_free;
792
793 result = ses_recv_diag(sdev, page, buf, len);
794 if (result)
795 goto recv_failed;
796 ses_dev->page10 = buf;
797 ses_dev->page10_len = len;
798 buf = NULL;
799 }
800 page2_not_supported:
801 if (components > 0) {
802 scomp = kzalloc_objs(struct ses_component, components,
803 GFP_KERNEL);
804 if (!scomp)
805 goto err_free;
806 }
807
808 edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev),
809 components, &ses_enclosure_callbacks);
810 if (IS_ERR(edev)) {
811 err = PTR_ERR(edev);
812 goto err_free;
813 }
814
815 kfree(hdr_buf);
816
817 edev->scratch = ses_dev;
818 for (i = 0; i < components; i++)
819 edev->component[i].scratch = scomp + i;
820
821 ses_enclosure_data_process(edev, sdev, 1);
822
823 /* see if there are any devices matching before
824 * we found the enclosure */
825 shost_for_each_device(tmp_sdev, sdev->host) {
826 if (tmp_sdev->lun != 0 || scsi_device_enclosure(tmp_sdev))
827 continue;
828 ses_match_to_enclosure(edev, tmp_sdev, 0);
829 }
830
831 return 0;
832
833 recv_failed:
834 sdev_printk(KERN_ERR, sdev, "Failed to get diagnostic page 0x%x\n",
835 page);
836 err = -ENODEV;
837 err_free:
838 kfree(buf);
839 kfree(scomp);
840 kfree(ses_dev->page10);
841 kfree(ses_dev->page2);
842 kfree(ses_dev->page1);
843 err_init_free:
844 kfree(ses_dev);
845 kfree(hdr_buf);
846 sdev_printk(KERN_ERR, sdev, "Failed to bind enclosure %d\n", err);
847 return err;
848 }
849
ses_intf_remove_component(struct scsi_device * sdev)850 static void ses_intf_remove_component(struct scsi_device *sdev)
851 {
852 struct enclosure_device *edev, *prev = NULL;
853
854 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) {
855 prev = edev;
856 if (!enclosure_remove_device(edev, &sdev->sdev_gendev))
857 break;
858 }
859 if (edev)
860 put_device(&edev->edev);
861 }
862
ses_intf_remove_enclosure(struct scsi_device * sdev)863 static void ses_intf_remove_enclosure(struct scsi_device *sdev)
864 {
865 struct enclosure_device *edev;
866 struct ses_device *ses_dev;
867
868 /* exact match to this enclosure */
869 edev = enclosure_find(&sdev->sdev_gendev, NULL);
870 if (!edev)
871 return;
872
873 ses_dev = edev->scratch;
874 edev->scratch = NULL;
875
876 kfree(ses_dev->page10);
877 kfree(ses_dev->page1);
878 kfree(ses_dev->page2);
879 kfree(ses_dev);
880
881 if (edev->components)
882 kfree(edev->component[0].scratch);
883
884 put_device(&edev->edev);
885 enclosure_unregister(edev);
886 }
887
ses_intf_remove(struct device * cdev)888 static void ses_intf_remove(struct device *cdev)
889 {
890 struct scsi_device *sdev = to_scsi_device(cdev->parent);
891
892 if (!scsi_device_enclosure(sdev))
893 ses_intf_remove_component(sdev);
894 else
895 ses_intf_remove_enclosure(sdev);
896 }
897
898 static struct class_interface ses_interface = {
899 .add_dev = ses_intf_add,
900 .remove_dev = ses_intf_remove,
901 };
902
903 static struct scsi_driver ses_template = {
904 .probe = ses_probe,
905 .gendrv = {
906 .name = "ses",
907 },
908 };
909
ses_init(void)910 static int __init ses_init(void)
911 {
912 int err;
913
914 err = scsi_register_interface(&ses_interface);
915 if (err)
916 return err;
917
918 err = scsi_register_driver(&ses_template);
919 if (err)
920 goto out_unreg;
921
922 return 0;
923
924 out_unreg:
925 scsi_unregister_interface(&ses_interface);
926 return err;
927 }
928
ses_exit(void)929 static void __exit ses_exit(void)
930 {
931 scsi_unregister_driver(&ses_template);
932 scsi_unregister_interface(&ses_interface);
933 }
934
935 module_init(ses_init);
936 module_exit(ses_exit);
937
938 MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE);
939
940 MODULE_AUTHOR("James Bottomley");
941 MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver");
942 MODULE_LICENSE("GPL v2");
943