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