ctdaio.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
  4. *
  5. * @File ctdaio.c
  6. *
  7. * @Brief
  8. * This file contains the implementation of Digital Audio Input Output
  9. * resource management object.
  10. *
  11. * @Author Liu Chun
  12. * @Date May 23 2008
  13. */
  14. #include "ctdaio.h"
  15. #include "cthardware.h"
  16. #include "ctimap.h"
  17. #include <linux/slab.h>
  18. #include <linux/kernel.h>
  19. #define DAIO_OUT_MAX SPDIFOO
  20. struct daio_usage {
  21. unsigned short data;
  22. };
  23. struct daio_rsc_idx {
  24. unsigned short left;
  25. unsigned short right;
  26. };
  27. static const struct daio_rsc_idx idx_20k1[NUM_DAIOTYP] = {
  28. [LINEO1] = {.left = 0x00, .right = 0x01},
  29. [LINEO2] = {.left = 0x18, .right = 0x19},
  30. [LINEO3] = {.left = 0x08, .right = 0x09},
  31. [LINEO4] = {.left = 0x10, .right = 0x11},
  32. [LINEIM] = {.left = 0x1b5, .right = 0x1bd},
  33. [SPDIFOO] = {.left = 0x20, .right = 0x21},
  34. [SPDIFIO] = {.left = 0x15, .right = 0x1d},
  35. [SPDIFI1] = {.left = 0x95, .right = 0x9d},
  36. };
  37. static const struct daio_rsc_idx idx_20k2[NUM_DAIOTYP] = {
  38. [LINEO1] = {.left = 0x40, .right = 0x41},
  39. [LINEO2] = {.left = 0x60, .right = 0x61},
  40. [LINEO3] = {.left = 0x50, .right = 0x51},
  41. [LINEO4] = {.left = 0x70, .right = 0x71},
  42. [LINEIM] = {.left = 0x45, .right = 0xc5},
  43. [MIC] = {.left = 0x55, .right = 0xd5},
  44. [SPDIFOO] = {.left = 0x00, .right = 0x01},
  45. [SPDIFIO] = {.left = 0x05, .right = 0x85},
  46. };
  47. static void daio_master(struct rsc *rsc)
  48. {
  49. /* Actually, this is not the resource index of DAIO.
  50. * For DAO, it is the input mapper index. And, for DAI,
  51. * it is the output time-slot index. */
  52. rsc->conj = rsc->idx;
  53. }
  54. static int daio_index(const struct rsc *rsc)
  55. {
  56. return rsc->conj;
  57. }
  58. static void daio_out_next_conj(struct rsc *rsc)
  59. {
  60. rsc->conj += 2;
  61. }
  62. static void daio_in_next_conj_20k1(struct rsc *rsc)
  63. {
  64. rsc->conj += 0x200;
  65. }
  66. static void daio_in_next_conj_20k2(struct rsc *rsc)
  67. {
  68. rsc->conj += 0x100;
  69. }
  70. static const struct rsc_ops daio_out_rsc_ops = {
  71. .master = daio_master,
  72. .next_conj = daio_out_next_conj,
  73. .index = daio_index,
  74. .output_slot = NULL,
  75. };
  76. static const struct rsc_ops daio_in_rsc_ops_20k1 = {
  77. .master = daio_master,
  78. .next_conj = daio_in_next_conj_20k1,
  79. .index = NULL,
  80. .output_slot = daio_index,
  81. };
  82. static const struct rsc_ops daio_in_rsc_ops_20k2 = {
  83. .master = daio_master,
  84. .next_conj = daio_in_next_conj_20k2,
  85. .index = NULL,
  86. .output_slot = daio_index,
  87. };
  88. static unsigned int daio_device_index(enum DAIOTYP type, struct hw *hw)
  89. {
  90. switch (hw->chip_type) {
  91. case ATC20K1:
  92. switch (type) {
  93. case SPDIFOO: return 0;
  94. case SPDIFIO: return 0;
  95. case SPDIFI1: return 1;
  96. case LINEO1: return 4;
  97. case LINEO2: return 7;
  98. case LINEO3: return 5;
  99. case LINEO4: return 6;
  100. case LINEIM: return 7;
  101. default: return -EINVAL;
  102. }
  103. case ATC20K2:
  104. switch (type) {
  105. case SPDIFOO: return 0;
  106. case SPDIFIO: return 0;
  107. case LINEO1: return 4;
  108. case LINEO2: return 7;
  109. case LINEO3: return 5;
  110. case LINEO4: return 6;
  111. case LINEIM: return 4;
  112. case MIC: return 5;
  113. default: return -EINVAL;
  114. }
  115. default:
  116. return -EINVAL;
  117. }
  118. }
  119. static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc);
  120. static int dao_spdif_get_spos(struct dao *dao, unsigned int *spos)
  121. {
  122. dao->hw->dao_get_spos(dao->ctrl_blk, spos);
  123. return 0;
  124. }
  125. static int dao_spdif_set_spos(struct dao *dao, unsigned int spos)
  126. {
  127. dao->hw->dao_set_spos(dao->ctrl_blk, spos);
  128. return 0;
  129. }
  130. static int dao_commit_write(struct dao *dao)
  131. {
  132. dao->hw->dao_commit_write(dao->hw,
  133. daio_device_index(dao->daio.type, dao->hw), dao->ctrl_blk);
  134. return 0;
  135. }
  136. static int dao_set_left_input(struct dao *dao, struct rsc *input)
  137. {
  138. struct imapper *entry;
  139. struct daio *daio = &dao->daio;
  140. int i;
  141. entry = kzalloc((sizeof(*entry) * daio->rscl.msr), GFP_KERNEL);
  142. if (!entry)
  143. return -ENOMEM;
  144. dao->ops->clear_left_input(dao);
  145. /* Program master and conjugate resources */
  146. input->ops->master(input);
  147. daio->rscl.ops->master(&daio->rscl);
  148. for (i = 0; i < daio->rscl.msr; i++, entry++) {
  149. entry->slot = input->ops->output_slot(input);
  150. entry->user = entry->addr = daio->rscl.ops->index(&daio->rscl);
  151. dao->mgr->imap_add(dao->mgr, entry);
  152. dao->imappers[i] = entry;
  153. input->ops->next_conj(input);
  154. daio->rscl.ops->next_conj(&daio->rscl);
  155. }
  156. input->ops->master(input);
  157. daio->rscl.ops->master(&daio->rscl);
  158. return 0;
  159. }
  160. static int dao_set_right_input(struct dao *dao, struct rsc *input)
  161. {
  162. struct imapper *entry;
  163. struct daio *daio = &dao->daio;
  164. int i;
  165. entry = kzalloc((sizeof(*entry) * daio->rscr.msr), GFP_KERNEL);
  166. if (!entry)
  167. return -ENOMEM;
  168. dao->ops->clear_right_input(dao);
  169. /* Program master and conjugate resources */
  170. input->ops->master(input);
  171. daio->rscr.ops->master(&daio->rscr);
  172. for (i = 0; i < daio->rscr.msr; i++, entry++) {
  173. entry->slot = input->ops->output_slot(input);
  174. entry->user = entry->addr = daio->rscr.ops->index(&daio->rscr);
  175. dao->mgr->imap_add(dao->mgr, entry);
  176. dao->imappers[daio->rscl.msr + i] = entry;
  177. input->ops->next_conj(input);
  178. daio->rscr.ops->next_conj(&daio->rscr);
  179. }
  180. input->ops->master(input);
  181. daio->rscr.ops->master(&daio->rscr);
  182. return 0;
  183. }
  184. static int dao_clear_left_input(struct dao *dao)
  185. {
  186. struct imapper *entry;
  187. struct daio *daio = &dao->daio;
  188. int i;
  189. if (!dao->imappers[0])
  190. return 0;
  191. entry = dao->imappers[0];
  192. dao->mgr->imap_delete(dao->mgr, entry);
  193. /* Program conjugate resources */
  194. for (i = 1; i < daio->rscl.msr; i++) {
  195. entry = dao->imappers[i];
  196. dao->mgr->imap_delete(dao->mgr, entry);
  197. dao->imappers[i] = NULL;
  198. }
  199. kfree(dao->imappers[0]);
  200. dao->imappers[0] = NULL;
  201. return 0;
  202. }
  203. static int dao_clear_right_input(struct dao *dao)
  204. {
  205. struct imapper *entry;
  206. struct daio *daio = &dao->daio;
  207. int i;
  208. if (!dao->imappers[daio->rscl.msr])
  209. return 0;
  210. entry = dao->imappers[daio->rscl.msr];
  211. dao->mgr->imap_delete(dao->mgr, entry);
  212. /* Program conjugate resources */
  213. for (i = 1; i < daio->rscr.msr; i++) {
  214. entry = dao->imappers[daio->rscl.msr + i];
  215. dao->mgr->imap_delete(dao->mgr, entry);
  216. dao->imappers[daio->rscl.msr + i] = NULL;
  217. }
  218. kfree(dao->imappers[daio->rscl.msr]);
  219. dao->imappers[daio->rscl.msr] = NULL;
  220. return 0;
  221. }
  222. static const struct dao_rsc_ops dao_ops = {
  223. .set_spos = dao_spdif_set_spos,
  224. .commit_write = dao_commit_write,
  225. .get_spos = dao_spdif_get_spos,
  226. .reinit = dao_rsc_reinit,
  227. .set_left_input = dao_set_left_input,
  228. .set_right_input = dao_set_right_input,
  229. .clear_left_input = dao_clear_left_input,
  230. .clear_right_input = dao_clear_right_input,
  231. };
  232. static int dai_set_srt_srcl(struct dai *dai, struct rsc *src)
  233. {
  234. src->ops->master(src);
  235. dai->hw->dai_srt_set_srcm(dai->ctrl_blk, src->ops->index(src));
  236. return 0;
  237. }
  238. static int dai_set_srt_srcr(struct dai *dai, struct rsc *src)
  239. {
  240. src->ops->master(src);
  241. dai->hw->dai_srt_set_srco(dai->ctrl_blk, src->ops->index(src));
  242. return 0;
  243. }
  244. static int dai_set_srt_msr(struct dai *dai, unsigned int msr)
  245. {
  246. unsigned int rsr;
  247. for (rsr = 0; msr > 1; msr >>= 1)
  248. rsr++;
  249. dai->hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
  250. return 0;
  251. }
  252. static int dai_set_enb_src(struct dai *dai, unsigned int enb)
  253. {
  254. dai->hw->dai_srt_set_ec(dai->ctrl_blk, enb);
  255. return 0;
  256. }
  257. static int dai_set_enb_srt(struct dai *dai, unsigned int enb)
  258. {
  259. dai->hw->dai_srt_set_et(dai->ctrl_blk, enb);
  260. return 0;
  261. }
  262. static int dai_commit_write(struct dai *dai)
  263. {
  264. dai->hw->dai_commit_write(dai->hw,
  265. daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
  266. return 0;
  267. }
  268. static const struct dai_rsc_ops dai_ops = {
  269. .set_srt_srcl = dai_set_srt_srcl,
  270. .set_srt_srcr = dai_set_srt_srcr,
  271. .set_srt_msr = dai_set_srt_msr,
  272. .set_enb_src = dai_set_enb_src,
  273. .set_enb_srt = dai_set_enb_srt,
  274. .commit_write = dai_commit_write,
  275. };
  276. static int daio_rsc_init(struct daio *daio,
  277. const struct daio_desc *desc,
  278. struct hw *hw)
  279. {
  280. int err;
  281. unsigned int idx_l, idx_r;
  282. switch (hw->chip_type) {
  283. case ATC20K1:
  284. idx_l = idx_20k1[desc->type].left;
  285. idx_r = idx_20k1[desc->type].right;
  286. break;
  287. case ATC20K2:
  288. idx_l = idx_20k2[desc->type].left;
  289. idx_r = idx_20k2[desc->type].right;
  290. break;
  291. default:
  292. return -EINVAL;
  293. }
  294. err = rsc_init(&daio->rscl, idx_l, DAIO, desc->msr, hw);
  295. if (err)
  296. return err;
  297. err = rsc_init(&daio->rscr, idx_r, DAIO, desc->msr, hw);
  298. if (err)
  299. goto error1;
  300. /* Set daio->rscl/r->ops to daio specific ones */
  301. if (desc->type <= DAIO_OUT_MAX) {
  302. daio->rscl.ops = daio->rscr.ops = &daio_out_rsc_ops;
  303. } else {
  304. switch (hw->chip_type) {
  305. case ATC20K1:
  306. daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k1;
  307. break;
  308. case ATC20K2:
  309. daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k2;
  310. break;
  311. default:
  312. break;
  313. }
  314. }
  315. daio->type = desc->type;
  316. return 0;
  317. error1:
  318. rsc_uninit(&daio->rscl);
  319. return err;
  320. }
  321. static int daio_rsc_uninit(struct daio *daio)
  322. {
  323. rsc_uninit(&daio->rscl);
  324. rsc_uninit(&daio->rscr);
  325. return 0;
  326. }
  327. static int dao_rsc_init(struct dao *dao,
  328. const struct daio_desc *desc,
  329. struct daio_mgr *mgr)
  330. {
  331. struct hw *hw = mgr->mgr.hw;
  332. unsigned int conf;
  333. int err;
  334. err = daio_rsc_init(&dao->daio, desc, mgr->mgr.hw);
  335. if (err)
  336. return err;
  337. dao->imappers = kzalloc(array3_size(sizeof(void *), desc->msr, 2),
  338. GFP_KERNEL);
  339. if (!dao->imappers) {
  340. err = -ENOMEM;
  341. goto error1;
  342. }
  343. dao->ops = &dao_ops;
  344. dao->mgr = mgr;
  345. dao->hw = hw;
  346. err = hw->dao_get_ctrl_blk(&dao->ctrl_blk);
  347. if (err)
  348. goto error2;
  349. hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
  350. daio_device_index(dao->daio.type, hw));
  351. hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
  352. conf = (desc->msr & 0x7) | (desc->passthru << 3);
  353. hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk,
  354. daio_device_index(dao->daio.type, hw), conf);
  355. hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
  356. daio_device_index(dao->daio.type, hw));
  357. hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
  358. return 0;
  359. error2:
  360. kfree(dao->imappers);
  361. dao->imappers = NULL;
  362. error1:
  363. daio_rsc_uninit(&dao->daio);
  364. return err;
  365. }
  366. static int dao_rsc_uninit(struct dao *dao)
  367. {
  368. if (dao->imappers) {
  369. if (dao->imappers[0])
  370. dao_clear_left_input(dao);
  371. if (dao->imappers[dao->daio.rscl.msr])
  372. dao_clear_right_input(dao);
  373. kfree(dao->imappers);
  374. dao->imappers = NULL;
  375. }
  376. dao->hw->dao_put_ctrl_blk(dao->ctrl_blk);
  377. dao->hw = dao->ctrl_blk = NULL;
  378. daio_rsc_uninit(&dao->daio);
  379. return 0;
  380. }
  381. static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc)
  382. {
  383. struct daio_mgr *mgr = dao->mgr;
  384. struct daio_desc dsc = {0};
  385. dsc.type = dao->daio.type;
  386. dsc.msr = desc->msr;
  387. dsc.passthru = desc->passthru;
  388. dao_rsc_uninit(dao);
  389. return dao_rsc_init(dao, &dsc, mgr);
  390. }
  391. static int dai_rsc_init(struct dai *dai,
  392. const struct daio_desc *desc,
  393. struct daio_mgr *mgr)
  394. {
  395. int err;
  396. struct hw *hw = mgr->mgr.hw;
  397. unsigned int rsr, msr;
  398. err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw);
  399. if (err)
  400. return err;
  401. dai->ops = &dai_ops;
  402. dai->hw = mgr->mgr.hw;
  403. err = hw->dai_get_ctrl_blk(&dai->ctrl_blk);
  404. if (err)
  405. goto error1;
  406. for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1)
  407. rsr++;
  408. hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
  409. hw->dai_srt_set_drat(dai->ctrl_blk, 0);
  410. /* default to disabling control of a SRC */
  411. hw->dai_srt_set_ec(dai->ctrl_blk, 0);
  412. hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */
  413. hw->dai_commit_write(hw,
  414. daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
  415. return 0;
  416. error1:
  417. daio_rsc_uninit(&dai->daio);
  418. return err;
  419. }
  420. static int dai_rsc_uninit(struct dai *dai)
  421. {
  422. dai->hw->dai_put_ctrl_blk(dai->ctrl_blk);
  423. dai->hw = dai->ctrl_blk = NULL;
  424. daio_rsc_uninit(&dai->daio);
  425. return 0;
  426. }
  427. static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
  428. {
  429. if (((struct daio_usage *)mgr->rscs)->data & (0x1 << type))
  430. return -ENOENT;
  431. ((struct daio_usage *)mgr->rscs)->data |= (0x1 << type);
  432. return 0;
  433. }
  434. static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
  435. {
  436. ((struct daio_usage *)mgr->rscs)->data &= ~(0x1 << type);
  437. return 0;
  438. }
  439. static int get_daio_rsc(struct daio_mgr *mgr,
  440. const struct daio_desc *desc,
  441. struct daio **rdaio)
  442. {
  443. int err;
  444. unsigned long flags;
  445. *rdaio = NULL;
  446. /* Check whether there are sufficient daio resources to meet request. */
  447. spin_lock_irqsave(&mgr->mgr_lock, flags);
  448. err = daio_mgr_get_rsc(&mgr->mgr, desc->type);
  449. spin_unlock_irqrestore(&mgr->mgr_lock, flags);
  450. if (err) {
  451. dev_err(mgr->card->dev,
  452. "Can't meet DAIO resource request!\n");
  453. return err;
  454. }
  455. err = -ENOMEM;
  456. /* Allocate mem for daio resource */
  457. if (desc->type <= DAIO_OUT_MAX) {
  458. struct dao *dao = kzalloc(sizeof(*dao), GFP_KERNEL);
  459. if (!dao)
  460. goto error;
  461. err = dao_rsc_init(dao, desc, mgr);
  462. if (err) {
  463. kfree(dao);
  464. goto error;
  465. }
  466. *rdaio = &dao->daio;
  467. } else {
  468. struct dai *dai = kzalloc(sizeof(*dai), GFP_KERNEL);
  469. if (!dai)
  470. goto error;
  471. err = dai_rsc_init(dai, desc, mgr);
  472. if (err) {
  473. kfree(dai);
  474. goto error;
  475. }
  476. *rdaio = &dai->daio;
  477. }
  478. mgr->daio_enable(mgr, *rdaio);
  479. mgr->commit_write(mgr);
  480. return 0;
  481. error:
  482. spin_lock_irqsave(&mgr->mgr_lock, flags);
  483. daio_mgr_put_rsc(&mgr->mgr, desc->type);
  484. spin_unlock_irqrestore(&mgr->mgr_lock, flags);
  485. return err;
  486. }
  487. static int put_daio_rsc(struct daio_mgr *mgr, struct daio *daio)
  488. {
  489. unsigned long flags;
  490. mgr->daio_disable(mgr, daio);
  491. mgr->commit_write(mgr);
  492. spin_lock_irqsave(&mgr->mgr_lock, flags);
  493. daio_mgr_put_rsc(&mgr->mgr, daio->type);
  494. spin_unlock_irqrestore(&mgr->mgr_lock, flags);
  495. if (daio->type <= DAIO_OUT_MAX) {
  496. dao_rsc_uninit(container_of(daio, struct dao, daio));
  497. kfree(container_of(daio, struct dao, daio));
  498. } else {
  499. dai_rsc_uninit(container_of(daio, struct dai, daio));
  500. kfree(container_of(daio, struct dai, daio));
  501. }
  502. return 0;
  503. }
  504. static int daio_mgr_enb_daio(struct daio_mgr *mgr, struct daio *daio)
  505. {
  506. struct hw *hw = mgr->mgr.hw;
  507. if (DAIO_OUT_MAX >= daio->type) {
  508. hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
  509. daio_device_index(daio->type, hw));
  510. } else {
  511. hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk,
  512. daio_device_index(daio->type, hw));
  513. }
  514. return 0;
  515. }
  516. static int daio_mgr_dsb_daio(struct daio_mgr *mgr, struct daio *daio)
  517. {
  518. struct hw *hw = mgr->mgr.hw;
  519. if (DAIO_OUT_MAX >= daio->type) {
  520. hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
  521. daio_device_index(daio->type, hw));
  522. } else {
  523. hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk,
  524. daio_device_index(daio->type, hw));
  525. }
  526. return 0;
  527. }
  528. static int daio_map_op(void *data, struct imapper *entry)
  529. {
  530. struct rsc_mgr *mgr = &((struct daio_mgr *)data)->mgr;
  531. struct hw *hw = mgr->hw;
  532. hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
  533. hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
  534. hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
  535. hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
  536. return 0;
  537. }
  538. static int daio_imap_add(struct daio_mgr *mgr, struct imapper *entry)
  539. {
  540. unsigned long flags;
  541. int err;
  542. spin_lock_irqsave(&mgr->imap_lock, flags);
  543. if (!entry->addr && mgr->init_imap_added) {
  544. input_mapper_delete(&mgr->imappers, mgr->init_imap,
  545. daio_map_op, mgr);
  546. mgr->init_imap_added = 0;
  547. }
  548. err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr);
  549. spin_unlock_irqrestore(&mgr->imap_lock, flags);
  550. return err;
  551. }
  552. static int daio_imap_delete(struct daio_mgr *mgr, struct imapper *entry)
  553. {
  554. unsigned long flags;
  555. int err;
  556. spin_lock_irqsave(&mgr->imap_lock, flags);
  557. err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr);
  558. if (list_empty(&mgr->imappers)) {
  559. input_mapper_add(&mgr->imappers, mgr->init_imap,
  560. daio_map_op, mgr);
  561. mgr->init_imap_added = 1;
  562. }
  563. spin_unlock_irqrestore(&mgr->imap_lock, flags);
  564. return err;
  565. }
  566. static int daio_mgr_commit_write(struct daio_mgr *mgr)
  567. {
  568. struct hw *hw = mgr->mgr.hw;
  569. hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
  570. return 0;
  571. }
  572. int daio_mgr_create(struct hw *hw, struct daio_mgr **rdaio_mgr)
  573. {
  574. int err, i;
  575. struct daio_mgr *daio_mgr;
  576. struct imapper *entry;
  577. *rdaio_mgr = NULL;
  578. daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
  579. if (!daio_mgr)
  580. return -ENOMEM;
  581. err = rsc_mgr_init(&daio_mgr->mgr, DAIO, NUM_DAIOTYP, hw);
  582. if (err)
  583. goto error1;
  584. spin_lock_init(&daio_mgr->mgr_lock);
  585. spin_lock_init(&daio_mgr->imap_lock);
  586. INIT_LIST_HEAD(&daio_mgr->imappers);
  587. entry = kzalloc(sizeof(*entry), GFP_KERNEL);
  588. if (!entry) {
  589. err = -ENOMEM;
  590. goto error2;
  591. }
  592. entry->slot = entry->addr = entry->next = entry->user = 0;
  593. list_add(&entry->list, &daio_mgr->imappers);
  594. daio_mgr->init_imap = entry;
  595. daio_mgr->init_imap_added = 1;
  596. daio_mgr->get_daio = get_daio_rsc;
  597. daio_mgr->put_daio = put_daio_rsc;
  598. daio_mgr->daio_enable = daio_mgr_enb_daio;
  599. daio_mgr->daio_disable = daio_mgr_dsb_daio;
  600. daio_mgr->imap_add = daio_imap_add;
  601. daio_mgr->imap_delete = daio_imap_delete;
  602. daio_mgr->commit_write = daio_mgr_commit_write;
  603. daio_mgr->card = hw->card;
  604. for (i = 0; i < 8; i++) {
  605. hw->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i);
  606. hw->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i);
  607. }
  608. hw->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk);
  609. *rdaio_mgr = daio_mgr;
  610. return 0;
  611. error2:
  612. rsc_mgr_uninit(&daio_mgr->mgr);
  613. error1:
  614. kfree(daio_mgr);
  615. return err;
  616. }
  617. int daio_mgr_destroy(struct daio_mgr *daio_mgr)
  618. {
  619. unsigned long flags;
  620. /* free daio input mapper list */
  621. spin_lock_irqsave(&daio_mgr->imap_lock, flags);
  622. free_input_mapper_list(&daio_mgr->imappers);
  623. spin_unlock_irqrestore(&daio_mgr->imap_lock, flags);
  624. rsc_mgr_uninit(&daio_mgr->mgr);
  625. kfree(daio_mgr);
  626. return 0;
  627. }