1 /* 2 * SCSI Enclosure Services 3 * 4 * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com> 5 * 6 **----------------------------------------------------------------------------- 7 ** 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. 11 ** 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. 16 ** 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. 20 ** 21 **----------------------------------------------------------------------------- 22 */ 23 24 #include <linux/module.h> 25 #include <linux/kernel.h> 26 #include <linux/enclosure.h> 27 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> 34 35 struct ses_device { 36 unsigned char *page1; 37 unsigned char *page2; 38 unsigned char *page10; 39 short page1_len; 40 short page2_len; 41 short page10_len; 42 }; 43 44 struct ses_component { 45 u64 addr; 46 unsigned char *desc; 47 }; 48 49 static int ses_probe(struct device *dev) 50 { 51 struct scsi_device *sdev = to_scsi_device(dev); 52 int err = -ENODEV; 53 54 if (sdev->type != TYPE_ENCLOSURE) 55 goto out; 56 57 err = 0; 58 sdev_printk(KERN_NOTICE, sdev, "Attached Enclosure device\n"); 59 60 out: 61 return err; 62 } 63 64 #define SES_TIMEOUT (30 * HZ) 65 #define SES_RETRIES 3 66 67 static int ses_recv_diag(struct scsi_device *sdev, int page_code, 68 void *buf, int bufflen) 69 { 70 unsigned char cmd[] = { 71 RECEIVE_DIAGNOSTIC, 72 1, /* Set PCV bit */ 73 page_code, 74 bufflen >> 8, 75 bufflen & 0xff, 76 0 77 }; 78 79 return scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buf, bufflen, 80 NULL, SES_TIMEOUT, SES_RETRIES, NULL); 81 } 82 83 static int ses_send_diag(struct scsi_device *sdev, int page_code, 84 void *buf, int bufflen) 85 { 86 u32 result; 87 88 unsigned char cmd[] = { 89 SEND_DIAGNOSTIC, 90 0x10, /* Set PF bit */ 91 0, 92 bufflen >> 8, 93 bufflen & 0xff, 94 0 95 }; 96 97 result = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, buf, bufflen, 98 NULL, SES_TIMEOUT, SES_RETRIES, NULL); 99 if (result) 100 sdev_printk(KERN_ERR, sdev, "SEND DIAGNOSTIC result: %8x\n", 101 result); 102 return result; 103 } 104 105 static int ses_set_page2_descriptor(struct enclosure_device *edev, 106 struct enclosure_component *ecomp, 107 unsigned char *desc) 108 { 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; 114 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++) { 119 desc_ptr += 4; 120 if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE && 121 type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE) 122 continue; 123 if (count++ == descriptor) { 124 memcpy(desc_ptr, desc, 4); 125 /* set select */ 126 desc_ptr[0] |= 0x80; 127 /* clear reserved, just in case */ 128 desc_ptr[0] &= 0xf0; 129 } 130 } 131 } 132 133 return ses_send_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len); 134 } 135 136 static unsigned char *ses_get_page2_descriptor(struct enclosure_device *edev, 137 struct enclosure_component *ecomp) 138 { 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; 144 145 ses_recv_diag(sdev, 2, ses_dev->page2, ses_dev->page2_len); 146 147 for (i = 0; i < ses_dev->page1[10]; i++, type_ptr += 4) { 148 for (j = 0; j < type_ptr[1]; j++) { 149 desc_ptr += 4; 150 if (type_ptr[0] != ENCLOSURE_COMPONENT_DEVICE && 151 type_ptr[0] != ENCLOSURE_COMPONENT_ARRAY_DEVICE) 152 continue; 153 if (count++ == descriptor) 154 return desc_ptr; 155 } 156 } 157 return NULL; 158 } 159 160 static void ses_get_fault(struct enclosure_device *edev, 161 struct enclosure_component *ecomp) 162 { 163 unsigned char *desc; 164 165 desc = ses_get_page2_descriptor(edev, ecomp); 166 if (desc) 167 ecomp->fault = (desc[3] & 0x60) >> 4; 168 } 169 170 static int ses_set_fault(struct enclosure_device *edev, 171 struct enclosure_component *ecomp, 172 enum enclosure_component_setting val) 173 { 174 unsigned char desc[4] = {0 }; 175 176 switch (val) { 177 case ENCLOSURE_SETTING_DISABLED: 178 /* zero is disabled */ 179 break; 180 case ENCLOSURE_SETTING_ENABLED: 181 desc[2] = 0x02; 182 break; 183 default: 184 /* SES doesn't do the SGPIO blink settings */ 185 return -EINVAL; 186 } 187 188 return ses_set_page2_descriptor(edev, ecomp, desc); 189 } 190 191 static void ses_get_status(struct enclosure_device *edev, 192 struct enclosure_component *ecomp) 193 { 194 unsigned char *desc; 195 196 desc = ses_get_page2_descriptor(edev, ecomp); 197 if (desc) 198 ecomp->status = (desc[0] & 0x0f); 199 } 200 201 static void ses_get_locate(struct enclosure_device *edev, 202 struct enclosure_component *ecomp) 203 { 204 unsigned char *desc; 205 206 desc = ses_get_page2_descriptor(edev, ecomp); 207 if (desc) 208 ecomp->locate = (desc[2] & 0x02) ? 1 : 0; 209 } 210 211 static int ses_set_locate(struct enclosure_device *edev, 212 struct enclosure_component *ecomp, 213 enum enclosure_component_setting val) 214 { 215 unsigned char desc[4] = {0 }; 216 217 switch (val) { 218 case ENCLOSURE_SETTING_DISABLED: 219 /* zero is disabled */ 220 break; 221 case ENCLOSURE_SETTING_ENABLED: 222 desc[2] = 0x02; 223 break; 224 default: 225 /* SES doesn't do the SGPIO blink settings */ 226 return -EINVAL; 227 } 228 return ses_set_page2_descriptor(edev, ecomp, desc); 229 } 230 231 static int ses_set_active(struct enclosure_device *edev, 232 struct enclosure_component *ecomp, 233 enum enclosure_component_setting val) 234 { 235 unsigned char desc[4] = {0 }; 236 237 switch (val) { 238 case ENCLOSURE_SETTING_DISABLED: 239 /* zero is disabled */ 240 ecomp->active = 0; 241 break; 242 case ENCLOSURE_SETTING_ENABLED: 243 desc[2] = 0x80; 244 ecomp->active = 1; 245 break; 246 default: 247 /* SES doesn't do the SGPIO blink settings */ 248 return -EINVAL; 249 } 250 return ses_set_page2_descriptor(edev, ecomp, desc); 251 } 252 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, 260 }; 261 262 struct ses_host_edev { 263 struct Scsi_Host *shost; 264 struct enclosure_device *edev; 265 }; 266 267 #if 0 268 int ses_match_host(struct enclosure_device *edev, void *data) 269 { 270 struct ses_host_edev *sed = data; 271 struct scsi_device *sdev; 272 273 if (!scsi_is_sdev_device(edev->edev.parent)) 274 return 0; 275 276 sdev = to_scsi_device(edev->edev.parent); 277 278 if (sdev->host != sed->shost) 279 return 0; 280 281 sed->edev = edev; 282 return 1; 283 } 284 #endif /* 0 */ 285 286 static void ses_process_descriptor(struct enclosure_component *ecomp, 287 unsigned char *desc) 288 { 289 int eip = desc[0] & 0x10; 290 int invalid = desc[0] & 0x80; 291 enum scsi_protocol proto = desc[0] & 0x0f; 292 u64 addr = 0; 293 struct ses_component *scomp = ecomp->scratch; 294 unsigned char *d; 295 296 scomp->desc = desc; 297 298 if (invalid) 299 return; 300 301 switch (proto) { 302 case SCSI_PROTOCOL_SAS: 303 if (eip) 304 d = desc + 8; 305 else 306 d = desc + 4; 307 /* only take the phy0 addr */ 308 addr = (u64)d[12] << 56 | 309 (u64)d[13] << 48 | 310 (u64)d[14] << 40 | 311 (u64)d[15] << 32 | 312 (u64)d[16] << 24 | 313 (u64)d[17] << 16 | 314 (u64)d[18] << 8 | 315 (u64)d[19]; 316 break; 317 default: 318 /* FIXME: Need to add more protocols than just SAS */ 319 break; 320 } 321 scomp->addr = addr; 322 } 323 324 struct efd { 325 u64 addr; 326 struct device *dev; 327 }; 328 329 static int ses_enclosure_find_by_addr(struct enclosure_device *edev, 330 void *data) 331 { 332 struct efd *efd = data; 333 int i; 334 struct ses_component *scomp; 335 336 if (!edev->component[0].scratch) 337 return 0; 338 339 for (i = 0; i < edev->components; i++) { 340 scomp = edev->component[i].scratch; 341 if (scomp->addr != efd->addr) 342 continue; 343 344 enclosure_add_device(edev, i, efd->dev); 345 return 1; 346 } 347 return 0; 348 } 349 350 #define INIT_ALLOC_SIZE 32 351 352 static void ses_enclosure_data_process(struct enclosure_device *edev, 353 struct scsi_device *sdev, 354 int create) 355 { 356 u32 result; 357 unsigned char *buf = NULL, *type_ptr, *desc_ptr, *addl_desc_ptr = NULL; 358 int i, j, page7_len, len, components; 359 struct ses_device *ses_dev = edev->scratch; 360 int types = ses_dev->page1[10]; 361 unsigned char *hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL); 362 363 if (!hdr_buf) 364 goto simple_populate; 365 366 /* re-read page 10 */ 367 if (ses_dev->page10) 368 ses_recv_diag(sdev, 10, ses_dev->page10, ses_dev->page10_len); 369 /* Page 7 for the descriptors is optional */ 370 result = ses_recv_diag(sdev, 7, hdr_buf, INIT_ALLOC_SIZE); 371 if (result) 372 goto simple_populate; 373 374 page7_len = len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 375 /* add 1 for trailing '\0' we'll use */ 376 buf = kzalloc(len + 1, GFP_KERNEL); 377 if (!buf) 378 goto simple_populate; 379 result = ses_recv_diag(sdev, 7, buf, len); 380 if (result) { 381 simple_populate: 382 kfree(buf); 383 buf = NULL; 384 desc_ptr = NULL; 385 len = 0; 386 page7_len = 0; 387 } else { 388 desc_ptr = buf + 8; 389 len = (desc_ptr[2] << 8) + desc_ptr[3]; 390 /* skip past overall descriptor */ 391 desc_ptr += len + 4; 392 if (ses_dev->page10) 393 addl_desc_ptr = ses_dev->page10 + 8; 394 } 395 type_ptr = ses_dev->page1 + 12 + ses_dev->page1[11]; 396 components = 0; 397 for (i = 0; i < types; i++, type_ptr += 4) { 398 for (j = 0; j < type_ptr[1]; j++) { 399 char *name = NULL; 400 struct enclosure_component *ecomp; 401 402 if (desc_ptr) { 403 if (desc_ptr >= buf + page7_len) { 404 desc_ptr = NULL; 405 } else { 406 len = (desc_ptr[2] << 8) + desc_ptr[3]; 407 desc_ptr += 4; 408 /* Add trailing zero - pushes into 409 * reserved space */ 410 desc_ptr[len] = '\0'; 411 name = desc_ptr; 412 } 413 } 414 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE || 415 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) { 416 417 if (create) 418 ecomp = enclosure_component_register(edev, 419 components++, 420 type_ptr[0], 421 name); 422 else 423 ecomp = &edev->component[components++]; 424 425 if (!IS_ERR(ecomp) && addl_desc_ptr) 426 ses_process_descriptor(ecomp, 427 addl_desc_ptr); 428 } 429 if (desc_ptr) 430 desc_ptr += len; 431 432 if (addl_desc_ptr) 433 addl_desc_ptr += addl_desc_ptr[1] + 2; 434 435 } 436 } 437 kfree(buf); 438 kfree(hdr_buf); 439 } 440 441 static void ses_match_to_enclosure(struct enclosure_device *edev, 442 struct scsi_device *sdev) 443 { 444 unsigned char *buf; 445 unsigned char *desc; 446 unsigned int vpd_len; 447 struct efd efd = { 448 .addr = 0, 449 }; 450 451 buf = kmalloc(INIT_ALLOC_SIZE, GFP_KERNEL); 452 if (!buf || scsi_get_vpd_page(sdev, 0x83, buf, INIT_ALLOC_SIZE)) 453 goto free; 454 455 ses_enclosure_data_process(edev, to_scsi_device(edev->edev.parent), 0); 456 457 vpd_len = ((buf[2] << 8) | buf[3]) + 4; 458 kfree(buf); 459 buf = kmalloc(vpd_len, GFP_KERNEL); 460 if (!buf ||scsi_get_vpd_page(sdev, 0x83, buf, vpd_len)) 461 goto free; 462 463 desc = buf + 4; 464 while (desc < buf + vpd_len) { 465 enum scsi_protocol proto = desc[0] >> 4; 466 u8 code_set = desc[0] & 0x0f; 467 u8 piv = desc[1] & 0x80; 468 u8 assoc = (desc[1] & 0x30) >> 4; 469 u8 type = desc[1] & 0x0f; 470 u8 len = desc[3]; 471 472 if (piv && code_set == 1 && assoc == 1 473 && proto == SCSI_PROTOCOL_SAS && type == 3 && len == 8) 474 efd.addr = (u64)desc[4] << 56 | 475 (u64)desc[5] << 48 | 476 (u64)desc[6] << 40 | 477 (u64)desc[7] << 32 | 478 (u64)desc[8] << 24 | 479 (u64)desc[9] << 16 | 480 (u64)desc[10] << 8 | 481 (u64)desc[11]; 482 483 desc += len + 4; 484 } 485 if (!efd.addr) 486 goto free; 487 488 efd.dev = &sdev->sdev_gendev; 489 490 enclosure_for_each_device(ses_enclosure_find_by_addr, &efd); 491 free: 492 kfree(buf); 493 } 494 495 static int ses_intf_add(struct device *cdev, 496 struct class_interface *intf) 497 { 498 struct scsi_device *sdev = to_scsi_device(cdev->parent); 499 struct scsi_device *tmp_sdev; 500 unsigned char *buf = NULL, *hdr_buf, *type_ptr; 501 struct ses_device *ses_dev; 502 u32 result; 503 int i, types, len, components = 0; 504 int err = -ENOMEM; 505 struct enclosure_device *edev; 506 struct ses_component *scomp = NULL; 507 508 if (!scsi_device_enclosure(sdev)) { 509 /* not an enclosure, but might be in one */ 510 struct enclosure_device *prev = NULL; 511 512 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) { 513 ses_match_to_enclosure(edev, sdev); 514 prev = edev; 515 } 516 return -ENODEV; 517 } 518 519 /* TYPE_ENCLOSURE prints a message in probe */ 520 if (sdev->type != TYPE_ENCLOSURE) 521 sdev_printk(KERN_NOTICE, sdev, "Embedded Enclosure Device\n"); 522 523 ses_dev = kzalloc(sizeof(*ses_dev), GFP_KERNEL); 524 hdr_buf = kzalloc(INIT_ALLOC_SIZE, GFP_KERNEL); 525 if (!hdr_buf || !ses_dev) 526 goto err_init_free; 527 528 result = ses_recv_diag(sdev, 1, hdr_buf, INIT_ALLOC_SIZE); 529 if (result) 530 goto recv_failed; 531 532 if (hdr_buf[1] != 0) { 533 /* FIXME: need subenclosure support; I've just never 534 * seen a device with subenclosures and it makes the 535 * traversal routines more complex */ 536 sdev_printk(KERN_ERR, sdev, 537 "FIXME driver has no support for subenclosures (%d)\n", 538 hdr_buf[1]); 539 goto err_free; 540 } 541 542 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 543 buf = kzalloc(len, GFP_KERNEL); 544 if (!buf) 545 goto err_free; 546 547 result = ses_recv_diag(sdev, 1, buf, len); 548 if (result) 549 goto recv_failed; 550 551 types = buf[10]; 552 553 type_ptr = buf + 12 + buf[11]; 554 555 for (i = 0; i < types; i++, type_ptr += 4) { 556 if (type_ptr[0] == ENCLOSURE_COMPONENT_DEVICE || 557 type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) 558 components += type_ptr[1]; 559 } 560 ses_dev->page1 = buf; 561 ses_dev->page1_len = len; 562 buf = NULL; 563 564 result = ses_recv_diag(sdev, 2, hdr_buf, INIT_ALLOC_SIZE); 565 if (result) 566 goto recv_failed; 567 568 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 569 buf = kzalloc(len, GFP_KERNEL); 570 if (!buf) 571 goto err_free; 572 573 /* make sure getting page 2 actually works */ 574 result = ses_recv_diag(sdev, 2, buf, len); 575 if (result) 576 goto recv_failed; 577 ses_dev->page2 = buf; 578 ses_dev->page2_len = len; 579 buf = NULL; 580 581 /* The additional information page --- allows us 582 * to match up the devices */ 583 result = ses_recv_diag(sdev, 10, hdr_buf, INIT_ALLOC_SIZE); 584 if (!result) { 585 586 len = (hdr_buf[2] << 8) + hdr_buf[3] + 4; 587 buf = kzalloc(len, GFP_KERNEL); 588 if (!buf) 589 goto err_free; 590 591 result = ses_recv_diag(sdev, 10, buf, len); 592 if (result) 593 goto recv_failed; 594 ses_dev->page10 = buf; 595 ses_dev->page10_len = len; 596 buf = NULL; 597 } 598 kfree(hdr_buf); 599 600 scomp = kzalloc(sizeof(struct ses_component) * components, GFP_KERNEL); 601 if (!scomp) 602 goto err_free; 603 604 edev = enclosure_register(cdev->parent, dev_name(&sdev->sdev_gendev), 605 components, &ses_enclosure_callbacks); 606 if (IS_ERR(edev)) { 607 err = PTR_ERR(edev); 608 goto err_free; 609 } 610 611 edev->scratch = ses_dev; 612 for (i = 0; i < components; i++) 613 edev->component[i].scratch = scomp + i; 614 615 ses_enclosure_data_process(edev, sdev, 1); 616 617 /* see if there are any devices matching before 618 * we found the enclosure */ 619 shost_for_each_device(tmp_sdev, sdev->host) { 620 if (tmp_sdev->lun != 0 || scsi_device_enclosure(tmp_sdev)) 621 continue; 622 ses_match_to_enclosure(edev, tmp_sdev); 623 } 624 625 return 0; 626 627 recv_failed: 628 sdev_printk(KERN_ERR, sdev, "Failed to get diagnostic page 0x%x\n", 629 result); 630 err = -ENODEV; 631 err_free: 632 kfree(buf); 633 kfree(scomp); 634 kfree(ses_dev->page10); 635 kfree(ses_dev->page2); 636 kfree(ses_dev->page1); 637 err_init_free: 638 kfree(ses_dev); 639 kfree(hdr_buf); 640 sdev_printk(KERN_ERR, sdev, "Failed to bind enclosure %d\n", err); 641 return err; 642 } 643 644 static int ses_remove(struct device *dev) 645 { 646 return 0; 647 } 648 649 static void ses_intf_remove_component(struct scsi_device *sdev) 650 { 651 struct enclosure_device *edev, *prev = NULL; 652 653 while ((edev = enclosure_find(&sdev->host->shost_gendev, prev)) != NULL) { 654 prev = edev; 655 if (!enclosure_remove_device(edev, &sdev->sdev_gendev)) 656 break; 657 } 658 if (edev) 659 put_device(&edev->edev); 660 } 661 662 static void ses_intf_remove_enclosure(struct scsi_device *sdev) 663 { 664 struct enclosure_device *edev; 665 struct ses_device *ses_dev; 666 667 /* exact match to this enclosure */ 668 edev = enclosure_find(&sdev->sdev_gendev, NULL); 669 if (!edev) 670 return; 671 672 ses_dev = edev->scratch; 673 edev->scratch = NULL; 674 675 kfree(ses_dev->page10); 676 kfree(ses_dev->page1); 677 kfree(ses_dev->page2); 678 kfree(ses_dev); 679 680 kfree(edev->component[0].scratch); 681 682 put_device(&edev->edev); 683 enclosure_unregister(edev); 684 } 685 686 static void ses_intf_remove(struct device *cdev, 687 struct class_interface *intf) 688 { 689 struct scsi_device *sdev = to_scsi_device(cdev->parent); 690 691 if (!scsi_device_enclosure(sdev)) 692 ses_intf_remove_component(sdev); 693 else 694 ses_intf_remove_enclosure(sdev); 695 } 696 697 static struct class_interface ses_interface = { 698 .add_dev = ses_intf_add, 699 .remove_dev = ses_intf_remove, 700 }; 701 702 static struct scsi_driver ses_template = { 703 .owner = THIS_MODULE, 704 .gendrv = { 705 .name = "ses", 706 .probe = ses_probe, 707 .remove = ses_remove, 708 }, 709 }; 710 711 static int __init ses_init(void) 712 { 713 int err; 714 715 err = scsi_register_interface(&ses_interface); 716 if (err) 717 return err; 718 719 err = scsi_register_driver(&ses_template.gendrv); 720 if (err) 721 goto out_unreg; 722 723 return 0; 724 725 out_unreg: 726 scsi_unregister_interface(&ses_interface); 727 return err; 728 } 729 730 static void __exit ses_exit(void) 731 { 732 scsi_unregister_driver(&ses_template.gendrv); 733 scsi_unregister_interface(&ses_interface); 734 } 735 736 module_init(ses_init); 737 module_exit(ses_exit); 738 739 MODULE_ALIAS_SCSI_DEVICE(TYPE_ENCLOSURE); 740 741 MODULE_AUTHOR("James Bottomley"); 742 MODULE_DESCRIPTION("SCSI Enclosure Services (ses) driver"); 743 MODULE_LICENSE("GPL v2"); 744