~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/ctxfi/ctdaio.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 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 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 
 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 
 66 static int daio_index(const struct rsc *rsc)
 67 {
 68         return rsc->conj;
 69 }
 70 
 71 static int daio_out_next_conj(struct rsc *rsc)
 72 {
 73         return rsc->conj += 2;
 74 }
 75 
 76 static int daio_in_next_conj_20k1(struct rsc *rsc)
 77 {
 78         return rsc->conj += 0x200;
 79 }
 80 
 81 static int daio_in_next_conj_20k2(struct rsc *rsc)
 82 {
 83         return rsc->conj += 0x100;
 84 }
 85 
 86 static 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 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 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 
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 
141 static int dao_spdif_get_spos(struct dao *dao, unsigned int *spos)
142 {
143         ((struct hw *)dao->hw)->dao_get_spos(dao->ctrl_blk, spos);
144         return 0;
145 }
146 
147 static int dao_spdif_set_spos(struct dao *dao, unsigned int spos)
148 {
149         ((struct hw *)dao->hw)->dao_set_spos(dao->ctrl_blk, spos);
150         return 0;
151 }
152 
153 static int dao_commit_write(struct dao *dao)
154 {
155         ((struct hw *)dao->hw)->dao_commit_write(dao->hw,
156                 daio_device_index(dao->daio.type, dao->hw), dao->ctrl_blk);
157         return 0;
158 }
159 
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 
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 
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 
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 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 
277 static int dai_set_srt_srcl(struct dai *dai, struct rsc *src)
278 {
279         src->ops->master(src);
280         ((struct hw *)dai->hw)->dai_srt_set_srcm(dai->ctrl_blk,
281                                                 src->ops->index(src));
282         return 0;
283 }
284 
285 static int dai_set_srt_srcr(struct dai *dai, struct rsc *src)
286 {
287         src->ops->master(src);
288         ((struct hw *)dai->hw)->dai_srt_set_srco(dai->ctrl_blk,
289                                                 src->ops->index(src));
290         return 0;
291 }
292 
293 static int dai_set_srt_msr(struct dai *dai, unsigned int msr)
294 {
295         unsigned int rsr;
296 
297         for (rsr = 0; msr > 1; msr >>= 1)
298                 rsr++;
299 
300         ((struct hw *)dai->hw)->dai_srt_set_rsr(dai->ctrl_blk, rsr);
301         return 0;
302 }
303 
304 static int dai_set_enb_src(struct dai *dai, unsigned int enb)
305 {
306         ((struct hw *)dai->hw)->dai_srt_set_ec(dai->ctrl_blk, enb);
307         return 0;
308 }
309 
310 static int dai_set_enb_srt(struct dai *dai, unsigned int enb)
311 {
312         ((struct hw *)dai->hw)->dai_srt_set_et(dai->ctrl_blk, enb);
313         return 0;
314 }
315 
316 static int dai_commit_write(struct dai *dai)
317 {
318         ((struct hw *)dai->hw)->dai_commit_write(dai->hw,
319                 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
320         return 0;
321 }
322 
323 static struct dai_rsc_ops dai_ops = {
324         .set_srt_srcl           = dai_set_srt_srcl,
325         .set_srt_srcr           = dai_set_srt_srcr,
326         .set_srt_msr            = dai_set_srt_msr,
327         .set_enb_src            = dai_set_enb_src,
328         .set_enb_srt            = dai_set_enb_srt,
329         .commit_write           = dai_commit_write,
330 };
331 
332 static int daio_rsc_init(struct daio *daio,
333                          const struct daio_desc *desc,
334                          void *hw)
335 {
336         int err;
337         unsigned int idx_l, idx_r;
338 
339         switch (((struct hw *)hw)->chip_type) {
340         case ATC20K1:
341                 idx_l = idx_20k1[desc->type].left;
342                 idx_r = idx_20k1[desc->type].right;
343                 break;
344         case ATC20K2:
345                 idx_l = idx_20k2[desc->type].left;
346                 idx_r = idx_20k2[desc->type].right;
347                 break;
348         default:
349                 return -EINVAL;
350         }
351         err = rsc_init(&daio->rscl, idx_l, DAIO, desc->msr, hw);
352         if (err)
353                 return err;
354 
355         err = rsc_init(&daio->rscr, idx_r, DAIO, desc->msr, hw);
356         if (err)
357                 goto error1;
358 
359         /* Set daio->rscl/r->ops to daio specific ones */
360         if (desc->type <= DAIO_OUT_MAX) {
361                 daio->rscl.ops = daio->rscr.ops = &daio_out_rsc_ops;
362         } else {
363                 switch (((struct hw *)hw)->chip_type) {
364                 case ATC20K1:
365                         daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k1;
366                         break;
367                 case ATC20K2:
368                         daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k2;
369                         break;
370                 default:
371                         break;
372                 }
373         }
374         daio->type = desc->type;
375 
376         return 0;
377 
378 error1:
379         rsc_uninit(&daio->rscl);
380         return err;
381 }
382 
383 static int daio_rsc_uninit(struct daio *daio)
384 {
385         rsc_uninit(&daio->rscl);
386         rsc_uninit(&daio->rscr);
387 
388         return 0;
389 }
390 
391 static int dao_rsc_init(struct dao *dao,
392                         const struct daio_desc *desc,
393                         struct daio_mgr *mgr)
394 {
395         struct hw *hw = mgr->mgr.hw;
396         unsigned int conf;
397         int err;
398 
399         err = daio_rsc_init(&dao->daio, desc, mgr->mgr.hw);
400         if (err)
401                 return err;
402 
403         dao->imappers = kzalloc(sizeof(void *)*desc->msr*2, GFP_KERNEL);
404         if (!dao->imappers) {
405                 err = -ENOMEM;
406                 goto error1;
407         }
408         dao->ops = &dao_ops;
409         dao->mgr = mgr;
410         dao->hw = hw;
411         err = hw->dao_get_ctrl_blk(&dao->ctrl_blk);
412         if (err)
413                 goto error2;
414 
415         hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
416                         daio_device_index(dao->daio.type, hw));
417         hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
418 
419         conf = (desc->msr & 0x7) | (desc->passthru << 3);
420         hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk,
421                         daio_device_index(dao->daio.type, hw), conf);
422         hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
423                         daio_device_index(dao->daio.type, hw));
424         hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
425 
426         return 0;
427 
428 error2:
429         kfree(dao->imappers);
430         dao->imappers = NULL;
431 error1:
432         daio_rsc_uninit(&dao->daio);
433         return err;
434 }
435 
436 static int dao_rsc_uninit(struct dao *dao)
437 {
438         if (dao->imappers) {
439                 if (dao->imappers[0])
440                         dao_clear_left_input(dao);
441 
442                 if (dao->imappers[dao->daio.rscl.msr])
443                         dao_clear_right_input(dao);
444 
445                 kfree(dao->imappers);
446                 dao->imappers = NULL;
447         }
448         ((struct hw *)dao->hw)->dao_put_ctrl_blk(dao->ctrl_blk);
449         dao->hw = dao->ctrl_blk = NULL;
450         daio_rsc_uninit(&dao->daio);
451 
452         return 0;
453 }
454 
455 static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc)
456 {
457         struct daio_mgr *mgr = dao->mgr;
458         struct daio_desc dsc = {0};
459 
460         dsc.type = dao->daio.type;
461         dsc.msr = desc->msr;
462         dsc.passthru = desc->passthru;
463         dao_rsc_uninit(dao);
464         return dao_rsc_init(dao, &dsc, mgr);
465 }
466 
467 static int dai_rsc_init(struct dai *dai,
468                         const struct daio_desc *desc,
469                         struct daio_mgr *mgr)
470 {
471         int err;
472         struct hw *hw = mgr->mgr.hw;
473         unsigned int rsr, msr;
474 
475         err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw);
476         if (err)
477                 return err;
478 
479         dai->ops = &dai_ops;
480         dai->hw = mgr->mgr.hw;
481         err = hw->dai_get_ctrl_blk(&dai->ctrl_blk);
482         if (err)
483                 goto error1;
484 
485         for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1)
486                 rsr++;
487 
488         hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
489         hw->dai_srt_set_drat(dai->ctrl_blk, 0);
490         /* default to disabling control of a SRC */
491         hw->dai_srt_set_ec(dai->ctrl_blk, 0);
492         hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */
493         hw->dai_commit_write(hw,
494                 daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
495 
496         return 0;
497 
498 error1:
499         daio_rsc_uninit(&dai->daio);
500         return err;
501 }
502 
503 static int dai_rsc_uninit(struct dai *dai)
504 {
505         ((struct hw *)dai->hw)->dai_put_ctrl_blk(dai->ctrl_blk);
506         dai->hw = dai->ctrl_blk = NULL;
507         daio_rsc_uninit(&dai->daio);
508         return 0;
509 }
510 
511 static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
512 {
513         if (((struct daio_usage *)mgr->rscs)->data & (0x1 << type))
514                 return -ENOENT;
515 
516         ((struct daio_usage *)mgr->rscs)->data |= (0x1 << type);
517 
518         return 0;
519 }
520 
521 static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
522 {
523         ((struct daio_usage *)mgr->rscs)->data &= ~(0x1 << type);
524 
525         return 0;
526 }
527 
528 static int get_daio_rsc(struct daio_mgr *mgr,
529                         const struct daio_desc *desc,
530                         struct daio **rdaio)
531 {
532         int err;
533         struct dai *dai = NULL;
534         struct dao *dao = NULL;
535         unsigned long flags;
536 
537         *rdaio = NULL;
538 
539         /* Check whether there are sufficient daio resources to meet request. */
540         spin_lock_irqsave(&mgr->mgr_lock, flags);
541         err = daio_mgr_get_rsc(&mgr->mgr, desc->type);
542         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
543         if (err) {
544                 printk(KERN_ERR "Can't meet DAIO resource request!\n");
545                 return err;
546         }
547 
548         /* Allocate mem for daio resource */
549         if (desc->type <= DAIO_OUT_MAX) {
550                 dao = kzalloc(sizeof(*dao), GFP_KERNEL);
551                 if (!dao) {
552                         err = -ENOMEM;
553                         goto error;
554                 }
555                 err = dao_rsc_init(dao, desc, mgr);
556                 if (err)
557                         goto error;
558 
559                 *rdaio = &dao->daio;
560         } else {
561                 dai = kzalloc(sizeof(*dai), GFP_KERNEL);
562                 if (!dai) {
563                         err = -ENOMEM;
564                         goto error;
565                 }
566                 err = dai_rsc_init(dai, desc, mgr);
567                 if (err)
568                         goto error;
569 
570                 *rdaio = &dai->daio;
571         }
572 
573         mgr->daio_enable(mgr, *rdaio);
574         mgr->commit_write(mgr);
575 
576         return 0;
577 
578 error:
579         if (dao)
580                 kfree(dao);
581         else if (dai)
582                 kfree(dai);
583 
584         spin_lock_irqsave(&mgr->mgr_lock, flags);
585         daio_mgr_put_rsc(&mgr->mgr, desc->type);
586         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
587         return err;
588 }
589 
590 static int put_daio_rsc(struct daio_mgr *mgr, struct daio *daio)
591 {
592         unsigned long flags;
593 
594         mgr->daio_disable(mgr, daio);
595         mgr->commit_write(mgr);
596 
597         spin_lock_irqsave(&mgr->mgr_lock, flags);
598         daio_mgr_put_rsc(&mgr->mgr, daio->type);
599         spin_unlock_irqrestore(&mgr->mgr_lock, flags);
600 
601         if (daio->type <= DAIO_OUT_MAX) {
602                 dao_rsc_uninit(container_of(daio, struct dao, daio));
603                 kfree(container_of(daio, struct dao, daio));
604         } else {
605                 dai_rsc_uninit(container_of(daio, struct dai, daio));
606                 kfree(container_of(daio, struct dai, daio));
607         }
608 
609         return 0;
610 }
611 
612 static int daio_mgr_enb_daio(struct daio_mgr *mgr, struct daio *daio)
613 {
614         struct hw *hw = mgr->mgr.hw;
615 
616         if (DAIO_OUT_MAX >= daio->type) {
617                 hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
618                                 daio_device_index(daio->type, hw));
619         } else {
620                 hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk,
621                                 daio_device_index(daio->type, hw));
622         }
623         return 0;
624 }
625 
626 static int daio_mgr_dsb_daio(struct daio_mgr *mgr, struct daio *daio)
627 {
628         struct hw *hw = mgr->mgr.hw;
629 
630         if (DAIO_OUT_MAX >= daio->type) {
631                 hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
632                                 daio_device_index(daio->type, hw));
633         } else {
634                 hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk,
635                                 daio_device_index(daio->type, hw));
636         }
637         return 0;
638 }
639 
640 static int daio_map_op(void *data, struct imapper *entry)
641 {
642         struct rsc_mgr *mgr = &((struct daio_mgr *)data)->mgr;
643         struct hw *hw = mgr->hw;
644 
645         hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
646         hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
647         hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
648         hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
649 
650         return 0;
651 }
652 
653 static int daio_imap_add(struct daio_mgr *mgr, struct imapper *entry)
654 {
655         unsigned long flags;
656         int err;
657 
658         spin_lock_irqsave(&mgr->imap_lock, flags);
659         if (!entry->addr && mgr->init_imap_added) {
660                 input_mapper_delete(&mgr->imappers, mgr->init_imap,
661                                                         daio_map_op, mgr);
662                 mgr->init_imap_added = 0;
663         }
664         err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr);
665         spin_unlock_irqrestore(&mgr->imap_lock, flags);
666 
667         return err;
668 }
669 
670 static int daio_imap_delete(struct daio_mgr *mgr, struct imapper *entry)
671 {
672         unsigned long flags;
673         int err;
674 
675         spin_lock_irqsave(&mgr->imap_lock, flags);
676         err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr);
677         if (list_empty(&mgr->imappers)) {
678                 input_mapper_add(&mgr->imappers, mgr->init_imap,
679                                                         daio_map_op, mgr);
680                 mgr->init_imap_added = 1;
681         }
682         spin_unlock_irqrestore(&mgr->imap_lock, flags);
683 
684         return err;
685 }
686 
687 static int daio_mgr_commit_write(struct daio_mgr *mgr)
688 {
689         struct hw *hw = mgr->mgr.hw;
690 
691         hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
692         return 0;
693 }
694 
695 int daio_mgr_create(void *hw, struct daio_mgr **rdaio_mgr)
696 {
697         int err, i;
698         struct daio_mgr *daio_mgr;
699         struct imapper *entry;
700 
701         *rdaio_mgr = NULL;
702         daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
703         if (!daio_mgr)
704                 return -ENOMEM;
705 
706         err = rsc_mgr_init(&daio_mgr->mgr, DAIO, NUM_DAIOTYP, hw);
707         if (err)
708                 goto error1;
709 
710         spin_lock_init(&daio_mgr->mgr_lock);
711         spin_lock_init(&daio_mgr->imap_lock);
712         INIT_LIST_HEAD(&daio_mgr->imappers);
713         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
714         if (!entry) {
715                 err = -ENOMEM;
716                 goto error2;
717         }
718         entry->slot = entry->addr = entry->next = entry->user = 0;
719         list_add(&entry->list, &daio_mgr->imappers);
720         daio_mgr->init_imap = entry;
721         daio_mgr->init_imap_added = 1;
722 
723         daio_mgr->get_daio = get_daio_rsc;
724         daio_mgr->put_daio = put_daio_rsc;
725         daio_mgr->daio_enable = daio_mgr_enb_daio;
726         daio_mgr->daio_disable = daio_mgr_dsb_daio;
727         daio_mgr->imap_add = daio_imap_add;
728         daio_mgr->imap_delete = daio_imap_delete;
729         daio_mgr->commit_write = daio_mgr_commit_write;
730 
731         for (i = 0; i < 8; i++) {
732                 ((struct hw *)hw)->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i);
733                 ((struct hw *)hw)->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i);
734         }
735         ((struct hw *)hw)->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk);
736 
737         *rdaio_mgr = daio_mgr;
738 
739         return 0;
740 
741 error2:
742         rsc_mgr_uninit(&daio_mgr->mgr);
743 error1:
744         kfree(daio_mgr);
745         return err;
746 }
747 
748 int daio_mgr_destroy(struct daio_mgr *daio_mgr)
749 {
750         unsigned long flags;
751 
752         /* free daio input mapper list */
753         spin_lock_irqsave(&daio_mgr->imap_lock, flags);
754         free_input_mapper_list(&daio_mgr->imappers);
755         spin_unlock_irqrestore(&daio_mgr->imap_lock, flags);
756 
757         rsc_mgr_uninit(&daio_mgr->mgr);
758         kfree(daio_mgr);
759 
760         return 0;
761 }
762 
763 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp