ses.c 20 KB

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