device_ops.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602
  1. /*
  2. * drivers/s390/cio/device_ops.c
  3. *
  4. * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
  5. * IBM Corporation
  6. * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
  7. * Cornelia Huck (cornelia.huck@de.ibm.com)
  8. */
  9. #include <linux/module.h>
  10. #include <linux/init.h>
  11. #include <linux/errno.h>
  12. #include <linux/slab.h>
  13. #include <linux/list.h>
  14. #include <linux/device.h>
  15. #include <linux/delay.h>
  16. #include <asm/ccwdev.h>
  17. #include <asm/idals.h>
  18. #include "cio.h"
  19. #include "cio_debug.h"
  20. #include "css.h"
  21. #include "chsc.h"
  22. #include "device.h"
  23. int
  24. ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
  25. {
  26. /*
  27. * The flag usage is mutal exclusive ...
  28. */
  29. if ((flags & CCWDEV_EARLY_NOTIFICATION) &&
  30. (flags & CCWDEV_REPORT_ALL))
  31. return -EINVAL;
  32. cdev->private->options.fast = (flags & CCWDEV_EARLY_NOTIFICATION) != 0;
  33. cdev->private->options.repall = (flags & CCWDEV_REPORT_ALL) != 0;
  34. cdev->private->options.pgroup = (flags & CCWDEV_DO_PATHGROUP) != 0;
  35. cdev->private->options.force = (flags & CCWDEV_ALLOW_FORCE) != 0;
  36. return 0;
  37. }
  38. int
  39. ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
  40. {
  41. struct subchannel *sch;
  42. int ret;
  43. if (!cdev)
  44. return -ENODEV;
  45. if (cdev->private->state == DEV_STATE_NOT_OPER)
  46. return -ENODEV;
  47. if (cdev->private->state != DEV_STATE_ONLINE &&
  48. cdev->private->state != DEV_STATE_WAIT4IO &&
  49. cdev->private->state != DEV_STATE_W4SENSE)
  50. return -EINVAL;
  51. sch = to_subchannel(cdev->dev.parent);
  52. if (!sch)
  53. return -ENODEV;
  54. ret = cio_clear(sch);
  55. if (ret == 0)
  56. cdev->private->intparm = intparm;
  57. return ret;
  58. }
  59. int
  60. ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
  61. unsigned long intparm, __u8 lpm, __u8 key,
  62. unsigned long flags)
  63. {
  64. struct subchannel *sch;
  65. int ret;
  66. if (!cdev)
  67. return -ENODEV;
  68. sch = to_subchannel(cdev->dev.parent);
  69. if (!sch)
  70. return -ENODEV;
  71. if (cdev->private->state == DEV_STATE_NOT_OPER)
  72. return -ENODEV;
  73. if (cdev->private->state == DEV_STATE_VERIFY ||
  74. cdev->private->state == DEV_STATE_CLEAR_VERIFY) {
  75. /* Remember to fake irb when finished. */
  76. if (!cdev->private->flags.fake_irb) {
  77. cdev->private->flags.fake_irb = 1;
  78. cdev->private->intparm = intparm;
  79. return 0;
  80. } else
  81. /* There's already a fake I/O around. */
  82. return -EBUSY;
  83. }
  84. if (cdev->private->state != DEV_STATE_ONLINE ||
  85. ((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
  86. !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
  87. cdev->private->flags.doverify)
  88. return -EBUSY;
  89. ret = cio_set_options (sch, flags);
  90. if (ret)
  91. return ret;
  92. ret = cio_start_key (sch, cpa, lpm, key);
  93. if (ret == 0)
  94. cdev->private->intparm = intparm;
  95. return ret;
  96. }
  97. int
  98. ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
  99. unsigned long intparm, __u8 lpm, __u8 key,
  100. unsigned long flags, int expires)
  101. {
  102. int ret;
  103. if (!cdev)
  104. return -ENODEV;
  105. ccw_device_set_timeout(cdev, expires);
  106. ret = ccw_device_start_key(cdev, cpa, intparm, lpm, key, flags);
  107. if (ret != 0)
  108. ccw_device_set_timeout(cdev, 0);
  109. return ret;
  110. }
  111. int
  112. ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
  113. unsigned long intparm, __u8 lpm, unsigned long flags)
  114. {
  115. return ccw_device_start_key(cdev, cpa, intparm, lpm,
  116. PAGE_DEFAULT_KEY, flags);
  117. }
  118. int
  119. ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
  120. unsigned long intparm, __u8 lpm, unsigned long flags,
  121. int expires)
  122. {
  123. return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
  124. PAGE_DEFAULT_KEY, flags,
  125. expires);
  126. }
  127. int
  128. ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
  129. {
  130. struct subchannel *sch;
  131. int ret;
  132. if (!cdev)
  133. return -ENODEV;
  134. if (cdev->private->state == DEV_STATE_NOT_OPER)
  135. return -ENODEV;
  136. if (cdev->private->state != DEV_STATE_ONLINE &&
  137. cdev->private->state != DEV_STATE_WAIT4IO &&
  138. cdev->private->state != DEV_STATE_W4SENSE)
  139. return -EINVAL;
  140. sch = to_subchannel(cdev->dev.parent);
  141. if (!sch)
  142. return -ENODEV;
  143. ret = cio_halt(sch);
  144. if (ret == 0)
  145. cdev->private->intparm = intparm;
  146. return ret;
  147. }
  148. int
  149. ccw_device_resume(struct ccw_device *cdev)
  150. {
  151. struct subchannel *sch;
  152. if (!cdev)
  153. return -ENODEV;
  154. sch = to_subchannel(cdev->dev.parent);
  155. if (!sch)
  156. return -ENODEV;
  157. if (cdev->private->state == DEV_STATE_NOT_OPER)
  158. return -ENODEV;
  159. if (cdev->private->state != DEV_STATE_ONLINE ||
  160. !(sch->schib.scsw.actl & SCSW_ACTL_SUSPENDED))
  161. return -EINVAL;
  162. return cio_resume(sch);
  163. }
  164. /*
  165. * Pass interrupt to device driver.
  166. */
  167. int
  168. ccw_device_call_handler(struct ccw_device *cdev)
  169. {
  170. struct subchannel *sch;
  171. unsigned int stctl;
  172. int ending_status;
  173. sch = to_subchannel(cdev->dev.parent);
  174. /*
  175. * we allow for the device action handler if .
  176. * - we received ending status
  177. * - the action handler requested to see all interrupts
  178. * - we received an intermediate status
  179. * - fast notification was requested (primary status)
  180. * - unsolicited interrupts
  181. */
  182. stctl = cdev->private->irb.scsw.stctl;
  183. ending_status = (stctl & SCSW_STCTL_SEC_STATUS) ||
  184. (stctl == (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)) ||
  185. (stctl == SCSW_STCTL_STATUS_PEND);
  186. if (!ending_status &&
  187. !cdev->private->options.repall &&
  188. !(stctl & SCSW_STCTL_INTER_STATUS) &&
  189. !(cdev->private->options.fast &&
  190. (stctl & SCSW_STCTL_PRIM_STATUS)))
  191. return 0;
  192. /*
  193. * Now we are ready to call the device driver interrupt handler.
  194. */
  195. if (cdev->handler)
  196. cdev->handler(cdev, cdev->private->intparm,
  197. &cdev->private->irb);
  198. /*
  199. * Clear the old and now useless interrupt response block.
  200. */
  201. memset(&cdev->private->irb, 0, sizeof(struct irb));
  202. return 1;
  203. }
  204. /*
  205. * Search for CIW command in extended sense data.
  206. */
  207. struct ciw *
  208. ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
  209. {
  210. int ciw_cnt;
  211. if (cdev->private->flags.esid == 0)
  212. return NULL;
  213. for (ciw_cnt = 0; ciw_cnt < MAX_CIWS; ciw_cnt++)
  214. if (cdev->private->senseid.ciw[ciw_cnt].ct == ct)
  215. return cdev->private->senseid.ciw + ciw_cnt;
  216. return NULL;
  217. }
  218. __u8
  219. ccw_device_get_path_mask(struct ccw_device *cdev)
  220. {
  221. struct subchannel *sch;
  222. sch = to_subchannel(cdev->dev.parent);
  223. if (!sch)
  224. return 0;
  225. else
  226. return sch->vpm;
  227. }
  228. static void
  229. ccw_device_wake_up(struct ccw_device *cdev, unsigned long ip, struct irb *irb)
  230. {
  231. if (!ip)
  232. /* unsolicited interrupt */
  233. return;
  234. /* Abuse intparm for error reporting. */
  235. if (IS_ERR(irb))
  236. cdev->private->intparm = -EIO;
  237. else if (irb->scsw.cc == 1)
  238. /* Retry for deferred condition code. */
  239. cdev->private->intparm = -EAGAIN;
  240. else if ((irb->scsw.dstat !=
  241. (DEV_STAT_CHN_END|DEV_STAT_DEV_END)) ||
  242. (irb->scsw.cstat != 0)) {
  243. /*
  244. * We didn't get channel end / device end. Check if path
  245. * verification has been started; we can retry after it has
  246. * finished. We also retry unit checks except for command reject
  247. * or intervention required. Also check for long busy
  248. * conditions.
  249. */
  250. if (cdev->private->flags.doverify ||
  251. cdev->private->state == DEV_STATE_VERIFY)
  252. cdev->private->intparm = -EAGAIN;
  253. if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) &&
  254. !(irb->ecw[0] &
  255. (SNS0_CMD_REJECT | SNS0_INTERVENTION_REQ)))
  256. cdev->private->intparm = -EAGAIN;
  257. else if ((irb->scsw.dstat & DEV_STAT_ATTENTION) &&
  258. (irb->scsw.dstat & DEV_STAT_DEV_END) &&
  259. (irb->scsw.dstat & DEV_STAT_UNIT_EXCEP))
  260. cdev->private->intparm = -EAGAIN;
  261. else
  262. cdev->private->intparm = -EIO;
  263. } else
  264. cdev->private->intparm = 0;
  265. wake_up(&cdev->private->wait_q);
  266. }
  267. static inline int
  268. __ccw_device_retry_loop(struct ccw_device *cdev, struct ccw1 *ccw, long magic, __u8 lpm)
  269. {
  270. int ret;
  271. struct subchannel *sch;
  272. sch = to_subchannel(cdev->dev.parent);
  273. do {
  274. ret = cio_start (sch, ccw, lpm);
  275. if ((ret == -EBUSY) || (ret == -EACCES)) {
  276. /* Try again later. */
  277. spin_unlock_irq(&sch->lock);
  278. msleep(10);
  279. spin_lock_irq(&sch->lock);
  280. continue;
  281. }
  282. if (ret != 0)
  283. /* Non-retryable error. */
  284. break;
  285. /* Wait for end of request. */
  286. cdev->private->intparm = magic;
  287. spin_unlock_irq(&sch->lock);
  288. wait_event(cdev->private->wait_q,
  289. (cdev->private->intparm == -EIO) ||
  290. (cdev->private->intparm == -EAGAIN) ||
  291. (cdev->private->intparm == 0));
  292. spin_lock_irq(&sch->lock);
  293. /* Check at least for channel end / device end */
  294. if (cdev->private->intparm == -EIO) {
  295. /* Non-retryable error. */
  296. ret = -EIO;
  297. break;
  298. }
  299. if (cdev->private->intparm == 0)
  300. /* Success. */
  301. break;
  302. /* Try again later. */
  303. spin_unlock_irq(&sch->lock);
  304. msleep(10);
  305. spin_lock_irq(&sch->lock);
  306. } while (1);
  307. return ret;
  308. }
  309. /**
  310. * read_dev_chars() - read device characteristics
  311. * @param cdev target ccw device
  312. * @param buffer pointer to buffer for rdc data
  313. * @param length size of rdc data
  314. * @returns 0 for success, negative error value on failure
  315. *
  316. * Context:
  317. * called for online device, lock not held
  318. **/
  319. int
  320. read_dev_chars (struct ccw_device *cdev, void **buffer, int length)
  321. {
  322. void (*handler)(struct ccw_device *, unsigned long, struct irb *);
  323. struct subchannel *sch;
  324. int ret;
  325. struct ccw1 *rdc_ccw;
  326. if (!cdev)
  327. return -ENODEV;
  328. if (!buffer || !length)
  329. return -EINVAL;
  330. sch = to_subchannel(cdev->dev.parent);
  331. CIO_TRACE_EVENT (4, "rddevch");
  332. CIO_TRACE_EVENT (4, sch->dev.bus_id);
  333. rdc_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
  334. if (!rdc_ccw)
  335. return -ENOMEM;
  336. rdc_ccw->cmd_code = CCW_CMD_RDC;
  337. rdc_ccw->count = length;
  338. rdc_ccw->flags = CCW_FLAG_SLI;
  339. ret = set_normalized_cda (rdc_ccw, (*buffer));
  340. if (ret != 0) {
  341. kfree(rdc_ccw);
  342. return ret;
  343. }
  344. spin_lock_irq(&sch->lock);
  345. /* Save interrupt handler. */
  346. handler = cdev->handler;
  347. /* Temporarily install own handler. */
  348. cdev->handler = ccw_device_wake_up;
  349. if (cdev->private->state != DEV_STATE_ONLINE)
  350. ret = -ENODEV;
  351. else if (((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
  352. !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
  353. cdev->private->flags.doverify)
  354. ret = -EBUSY;
  355. else
  356. /* 0x00D9C4C3 == ebcdic "RDC" */
  357. ret = __ccw_device_retry_loop(cdev, rdc_ccw, 0x00D9C4C3, 0);
  358. /* Restore interrupt handler. */
  359. cdev->handler = handler;
  360. spin_unlock_irq(&sch->lock);
  361. clear_normalized_cda (rdc_ccw);
  362. kfree(rdc_ccw);
  363. return ret;
  364. }
  365. /*
  366. * Read Configuration data using path mask
  367. */
  368. int
  369. read_conf_data_lpm (struct ccw_device *cdev, void **buffer, int *length, __u8 lpm)
  370. {
  371. void (*handler)(struct ccw_device *, unsigned long, struct irb *);
  372. struct subchannel *sch;
  373. struct ciw *ciw;
  374. char *rcd_buf;
  375. int ret;
  376. struct ccw1 *rcd_ccw;
  377. if (!cdev)
  378. return -ENODEV;
  379. if (!buffer || !length)
  380. return -EINVAL;
  381. sch = to_subchannel(cdev->dev.parent);
  382. CIO_TRACE_EVENT (4, "rdconf");
  383. CIO_TRACE_EVENT (4, sch->dev.bus_id);
  384. /*
  385. * scan for RCD command in extended SenseID data
  386. */
  387. ciw = ccw_device_get_ciw(cdev, CIW_TYPE_RCD);
  388. if (!ciw || ciw->cmd == 0)
  389. return -EOPNOTSUPP;
  390. rcd_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
  391. if (!rcd_ccw)
  392. return -ENOMEM;
  393. rcd_buf = kzalloc(ciw->count, GFP_KERNEL | GFP_DMA);
  394. if (!rcd_buf) {
  395. kfree(rcd_ccw);
  396. return -ENOMEM;
  397. }
  398. rcd_ccw->cmd_code = ciw->cmd;
  399. rcd_ccw->cda = (__u32) __pa (rcd_buf);
  400. rcd_ccw->count = ciw->count;
  401. rcd_ccw->flags = CCW_FLAG_SLI;
  402. spin_lock_irq(&sch->lock);
  403. /* Save interrupt handler. */
  404. handler = cdev->handler;
  405. /* Temporarily install own handler. */
  406. cdev->handler = ccw_device_wake_up;
  407. if (cdev->private->state != DEV_STATE_ONLINE)
  408. ret = -ENODEV;
  409. else if (((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
  410. !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
  411. cdev->private->flags.doverify)
  412. ret = -EBUSY;
  413. else
  414. /* 0x00D9C3C4 == ebcdic "RCD" */
  415. ret = __ccw_device_retry_loop(cdev, rcd_ccw, 0x00D9C3C4, lpm);
  416. /* Restore interrupt handler. */
  417. cdev->handler = handler;
  418. spin_unlock_irq(&sch->lock);
  419. /*
  420. * on success we update the user input parms
  421. */
  422. if (ret) {
  423. kfree (rcd_buf);
  424. *buffer = NULL;
  425. *length = 0;
  426. } else {
  427. *length = ciw->count;
  428. *buffer = rcd_buf;
  429. }
  430. kfree(rcd_ccw);
  431. return ret;
  432. }
  433. /*
  434. * Read Configuration data
  435. */
  436. int
  437. read_conf_data (struct ccw_device *cdev, void **buffer, int *length)
  438. {
  439. return read_conf_data_lpm (cdev, buffer, length, 0);
  440. }
  441. /*
  442. * Try to break the lock on a boxed device.
  443. */
  444. int
  445. ccw_device_stlck(struct ccw_device *cdev)
  446. {
  447. void *buf, *buf2;
  448. unsigned long flags;
  449. struct subchannel *sch;
  450. int ret;
  451. if (!cdev)
  452. return -ENODEV;
  453. if (cdev->drv && !cdev->private->options.force)
  454. return -EINVAL;
  455. sch = to_subchannel(cdev->dev.parent);
  456. CIO_TRACE_EVENT(2, "stl lock");
  457. CIO_TRACE_EVENT(2, cdev->dev.bus_id);
  458. buf = kmalloc(32*sizeof(char), GFP_DMA|GFP_KERNEL);
  459. if (!buf)
  460. return -ENOMEM;
  461. buf2 = kmalloc(32*sizeof(char), GFP_DMA|GFP_KERNEL);
  462. if (!buf2) {
  463. kfree(buf);
  464. return -ENOMEM;
  465. }
  466. spin_lock_irqsave(&sch->lock, flags);
  467. ret = cio_enable_subchannel(sch, 3);
  468. if (ret)
  469. goto out_unlock;
  470. /*
  471. * Setup ccw. We chain an unconditional reserve and a release so we
  472. * only break the lock.
  473. */
  474. cdev->private->iccws[0].cmd_code = CCW_CMD_STLCK;
  475. cdev->private->iccws[0].cda = (__u32) __pa(buf);
  476. cdev->private->iccws[0].count = 32;
  477. cdev->private->iccws[0].flags = CCW_FLAG_CC;
  478. cdev->private->iccws[1].cmd_code = CCW_CMD_RELEASE;
  479. cdev->private->iccws[1].cda = (__u32) __pa(buf2);
  480. cdev->private->iccws[1].count = 32;
  481. cdev->private->iccws[1].flags = 0;
  482. ret = cio_start(sch, cdev->private->iccws, 0);
  483. if (ret) {
  484. cio_disable_subchannel(sch); //FIXME: return code?
  485. goto out_unlock;
  486. }
  487. cdev->private->irb.scsw.actl |= SCSW_ACTL_START_PEND;
  488. spin_unlock_irqrestore(&sch->lock, flags);
  489. wait_event(cdev->private->wait_q, cdev->private->irb.scsw.actl == 0);
  490. spin_lock_irqsave(&sch->lock, flags);
  491. cio_disable_subchannel(sch); //FIXME: return code?
  492. if ((cdev->private->irb.scsw.dstat !=
  493. (DEV_STAT_CHN_END|DEV_STAT_DEV_END)) ||
  494. (cdev->private->irb.scsw.cstat != 0))
  495. ret = -EIO;
  496. /* Clear irb. */
  497. memset(&cdev->private->irb, 0, sizeof(struct irb));
  498. out_unlock:
  499. kfree(buf);
  500. kfree(buf2);
  501. spin_unlock_irqrestore(&sch->lock, flags);
  502. return ret;
  503. }
  504. void *
  505. ccw_device_get_chp_desc(struct ccw_device *cdev, int chp_no)
  506. {
  507. struct subchannel *sch;
  508. sch = to_subchannel(cdev->dev.parent);
  509. return chsc_get_chp_desc(sch, chp_no);
  510. }
  511. // FIXME: these have to go:
  512. int
  513. _ccw_device_get_subchannel_number(struct ccw_device *cdev)
  514. {
  515. return cdev->private->sch_no;
  516. }
  517. int
  518. _ccw_device_get_device_number(struct ccw_device *cdev)
  519. {
  520. return cdev->private->devno;
  521. }
  522. MODULE_LICENSE("GPL");
  523. EXPORT_SYMBOL(ccw_device_set_options);
  524. EXPORT_SYMBOL(ccw_device_clear);
  525. EXPORT_SYMBOL(ccw_device_halt);
  526. EXPORT_SYMBOL(ccw_device_resume);
  527. EXPORT_SYMBOL(ccw_device_start_timeout);
  528. EXPORT_SYMBOL(ccw_device_start);
  529. EXPORT_SYMBOL(ccw_device_start_timeout_key);
  530. EXPORT_SYMBOL(ccw_device_start_key);
  531. EXPORT_SYMBOL(ccw_device_get_ciw);
  532. EXPORT_SYMBOL(ccw_device_get_path_mask);
  533. EXPORT_SYMBOL(read_conf_data);
  534. EXPORT_SYMBOL(read_dev_chars);
  535. EXPORT_SYMBOL(_ccw_device_get_subchannel_number);
  536. EXPORT_SYMBOL(_ccw_device_get_device_number);
  537. EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);
  538. EXPORT_SYMBOL_GPL(read_conf_data_lpm);