Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 //
0003 // Renesas R-Car SSIU/SSI support
0004 //
0005 // Copyright (C) 2013 Renesas Solutions Corp.
0006 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
0007 //
0008 // Based on fsi.c
0009 // Kuninori Morimoto <morimoto.kuninori@renesas.com>
0010 
0011 /*
0012  * you can enable below define if you don't need
0013  * SSI interrupt status debug message when debugging
0014  * see rsnd_print_irq_status()
0015  *
0016  * #define RSND_DEBUG_NO_IRQ_STATUS 1
0017  */
0018 
0019 #include <sound/simple_card_utils.h>
0020 #include <linux/delay.h>
0021 #include "rsnd.h"
0022 #define RSND_SSI_NAME_SIZE 16
0023 
0024 /*
0025  * SSICR
0026  */
0027 #define FORCE       (1u << 31)  /* Fixed */
0028 #define DMEN        (1u << 28)  /* DMA Enable */
0029 #define UIEN        (1u << 27)  /* Underflow Interrupt Enable */
0030 #define OIEN        (1u << 26)  /* Overflow Interrupt Enable */
0031 #define IIEN        (1u << 25)  /* Idle Mode Interrupt Enable */
0032 #define DIEN        (1u << 24)  /* Data Interrupt Enable */
0033 #define CHNL_4      (1u << 22)  /* Channels */
0034 #define CHNL_6      (2u << 22)  /* Channels */
0035 #define CHNL_8      (3u << 22)  /* Channels */
0036 #define DWL_MASK    (7u << 19)  /* Data Word Length mask */
0037 #define DWL_8       (0u << 19)  /* Data Word Length */
0038 #define DWL_16      (1u << 19)  /* Data Word Length */
0039 #define DWL_18      (2u << 19)  /* Data Word Length */
0040 #define DWL_20      (3u << 19)  /* Data Word Length */
0041 #define DWL_22      (4u << 19)  /* Data Word Length */
0042 #define DWL_24      (5u << 19)  /* Data Word Length */
0043 #define DWL_32      (6u << 19)  /* Data Word Length */
0044 
0045 /*
0046  * System word length
0047  */
0048 #define SWL_16      (1 << 16)   /* R/W System Word Length */
0049 #define SWL_24      (2 << 16)   /* R/W System Word Length */
0050 #define SWL_32      (3 << 16)   /* R/W System Word Length */
0051 
0052 #define SCKD        (1 << 15)   /* Serial Bit Clock Direction */
0053 #define SWSD        (1 << 14)   /* Serial WS Direction */
0054 #define SCKP        (1 << 13)   /* Serial Bit Clock Polarity */
0055 #define SWSP        (1 << 12)   /* Serial WS Polarity */
0056 #define SDTA        (1 << 10)   /* Serial Data Alignment */
0057 #define PDTA        (1 <<  9)   /* Parallel Data Alignment */
0058 #define DEL     (1 <<  8)   /* Serial Data Delay */
0059 #define CKDV(v)     (v <<  4)   /* Serial Clock Division Ratio */
0060 #define TRMD        (1 <<  1)   /* Transmit/Receive Mode Select */
0061 #define EN      (1 <<  0)   /* SSI Module Enable */
0062 
0063 /*
0064  * SSISR
0065  */
0066 #define UIRQ        (1 << 27)   /* Underflow Error Interrupt Status */
0067 #define OIRQ        (1 << 26)   /* Overflow Error Interrupt Status */
0068 #define IIRQ        (1 << 25)   /* Idle Mode Interrupt Status */
0069 #define DIRQ        (1 << 24)   /* Data Interrupt Status Flag */
0070 
0071 /*
0072  * SSIWSR
0073  */
0074 #define CONT        (1 << 8)    /* WS Continue Function */
0075 #define WS_MODE     (1 << 0)    /* WS Mode */
0076 
0077 #define SSI_NAME "ssi"
0078 
0079 struct rsnd_ssi {
0080     struct rsnd_mod mod;
0081 
0082     u32 flags;
0083     u32 cr_own;
0084     u32 cr_clk;
0085     u32 cr_mode;
0086     u32 cr_en;
0087     u32 wsr;
0088     int chan;
0089     int rate;
0090     int irq;
0091     unsigned int usrcnt;
0092 
0093     /* for PIO */
0094     int byte_pos;
0095     int byte_per_period;
0096     int next_period_byte;
0097 };
0098 
0099 /* flags */
0100 #define RSND_SSI_CLK_PIN_SHARE      (1 << 0)
0101 #define RSND_SSI_NO_BUSIF       (1 << 1) /* SSI+DMA without BUSIF */
0102 #define RSND_SSI_PROBED         (1 << 2)
0103 
0104 #define for_each_rsnd_ssi(pos, priv, i)                 \
0105     for (i = 0;                         \
0106          (i < rsnd_ssi_nr(priv)) &&                 \
0107         ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i));     \
0108          i++)
0109 
0110 #define rsnd_ssi_get(priv, id) ((struct rsnd_ssi *)(priv->ssi) + id)
0111 #define rsnd_ssi_nr(priv) ((priv)->ssi_nr)
0112 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod)
0113 #define rsnd_ssi_is_parent(ssi, io) ((ssi) == rsnd_io_to_mod_ssip(io))
0114 #define rsnd_ssi_is_multi_secondary(mod, io)                \
0115     (rsnd_ssi_multi_secondaries(io) & (1 << rsnd_mod_id(mod)))
0116 #define rsnd_ssi_is_run_mods(mod, io) \
0117     (rsnd_ssi_run_mods(io) & (1 << rsnd_mod_id(mod)))
0118 #define rsnd_ssi_can_output_clk(mod) (!__rsnd_ssi_is_pin_sharing(mod))
0119 
0120 int rsnd_ssi_use_busif(struct rsnd_dai_stream *io)
0121 {
0122     struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io);
0123     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0124     int use_busif = 0;
0125 
0126     if (!rsnd_ssi_is_dma_mode(mod))
0127         return 0;
0128 
0129     if (!(rsnd_flags_has(ssi, RSND_SSI_NO_BUSIF)))
0130         use_busif = 1;
0131     if (rsnd_io_to_mod_src(io))
0132         use_busif = 1;
0133 
0134     return use_busif;
0135 }
0136 
0137 static void rsnd_ssi_status_clear(struct rsnd_mod *mod)
0138 {
0139     rsnd_mod_write(mod, SSISR, 0);
0140 }
0141 
0142 static u32 rsnd_ssi_status_get(struct rsnd_mod *mod)
0143 {
0144     return rsnd_mod_read(mod, SSISR);
0145 }
0146 
0147 static void rsnd_ssi_status_check(struct rsnd_mod *mod,
0148                   u32 bit)
0149 {
0150     struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
0151     struct device *dev = rsnd_priv_to_dev(priv);
0152     u32 status;
0153     int i;
0154 
0155     for (i = 0; i < 1024; i++) {
0156         status = rsnd_ssi_status_get(mod);
0157         if (status & bit)
0158             return;
0159 
0160         udelay(5);
0161     }
0162 
0163     dev_warn(dev, "%s status check failed\n", rsnd_mod_name(mod));
0164 }
0165 
0166 static u32 rsnd_ssi_multi_secondaries(struct rsnd_dai_stream *io)
0167 {
0168     static const enum rsnd_mod_type types[] = {
0169         RSND_MOD_SSIM1,
0170         RSND_MOD_SSIM2,
0171         RSND_MOD_SSIM3,
0172     };
0173     int i, mask;
0174 
0175     mask = 0;
0176     for (i = 0; i < ARRAY_SIZE(types); i++) {
0177         struct rsnd_mod *mod = rsnd_io_to_mod(io, types[i]);
0178 
0179         if (!mod)
0180             continue;
0181 
0182         mask |= 1 << rsnd_mod_id(mod);
0183     }
0184 
0185     return mask;
0186 }
0187 
0188 static u32 rsnd_ssi_run_mods(struct rsnd_dai_stream *io)
0189 {
0190     struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);
0191     struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
0192     u32 mods;
0193 
0194     mods = rsnd_ssi_multi_secondaries_runtime(io) |
0195         1 << rsnd_mod_id(ssi_mod);
0196 
0197     if (ssi_parent_mod)
0198         mods |= 1 << rsnd_mod_id(ssi_parent_mod);
0199 
0200     return mods;
0201 }
0202 
0203 u32 rsnd_ssi_multi_secondaries_runtime(struct rsnd_dai_stream *io)
0204 {
0205     if (rsnd_runtime_is_multi_ssi(io))
0206         return rsnd_ssi_multi_secondaries(io);
0207 
0208     return 0;
0209 }
0210 
0211 static u32 rsnd_rdai_width_to_swl(struct rsnd_dai *rdai)
0212 {
0213     struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);
0214     struct device *dev = rsnd_priv_to_dev(priv);
0215     int width = rsnd_rdai_width_get(rdai);
0216 
0217     switch (width) {
0218     case 32: return SWL_32;
0219     case 24: return SWL_24;
0220     case 16: return SWL_16;
0221     }
0222 
0223     dev_err(dev, "unsupported slot width value: %d\n", width);
0224     return 0;
0225 }
0226 
0227 unsigned int rsnd_ssi_clk_query(struct rsnd_dai *rdai,
0228                int param1, int param2, int *idx)
0229 {
0230     struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);
0231     static const int ssi_clk_mul_table[] = {
0232         1, 2, 4, 8, 16, 6, 12,
0233     };
0234     int j, ret;
0235     unsigned int main_rate;
0236     int width = rsnd_rdai_width_get(rdai);
0237 
0238     for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) {
0239 
0240         /*
0241          * It will set SSIWSR.CONT here, but SSICR.CKDV = 000
0242          * with it is not allowed. (SSIWSR.WS_MODE with
0243          * SSICR.CKDV = 000 is not allowed either).
0244          * Skip it. See SSICR.CKDV
0245          */
0246         if (j == 0)
0247             continue;
0248 
0249         main_rate = width * param1 * param2 * ssi_clk_mul_table[j];
0250 
0251         ret = rsnd_adg_clk_query(priv, main_rate);
0252         if (ret < 0)
0253             continue;
0254 
0255         if (idx)
0256             *idx = j;
0257 
0258         return main_rate;
0259     }
0260 
0261     return 0;
0262 }
0263 
0264 static int rsnd_ssi_master_clk_start(struct rsnd_mod *mod,
0265                      struct rsnd_dai_stream *io)
0266 {
0267     struct rsnd_priv *priv = rsnd_io_to_priv(io);
0268     struct device *dev = rsnd_priv_to_dev(priv);
0269     struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
0270     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0271     int chan = rsnd_runtime_channel_for_ssi(io);
0272     int idx, ret;
0273     unsigned int main_rate;
0274     unsigned int rate = rsnd_io_is_play(io) ?
0275         rsnd_src_get_out_rate(priv, io) :
0276         rsnd_src_get_in_rate(priv, io);
0277 
0278     if (!rsnd_rdai_is_clk_master(rdai))
0279         return 0;
0280 
0281     if (!rsnd_ssi_can_output_clk(mod))
0282         return 0;
0283 
0284     if (rsnd_ssi_is_multi_secondary(mod, io))
0285         return 0;
0286 
0287     if (rsnd_runtime_is_tdm_split(io))
0288         chan = rsnd_io_converted_chan(io);
0289 
0290     chan = rsnd_channel_normalization(chan);
0291 
0292     if (ssi->usrcnt > 0) {
0293         if (ssi->rate != rate) {
0294             dev_err(dev, "SSI parent/child should use same rate\n");
0295             return -EINVAL;
0296         }
0297 
0298         if (ssi->chan != chan) {
0299             dev_err(dev, "SSI parent/child should use same chan\n");
0300             return -EINVAL;
0301         }
0302 
0303         return 0;
0304     }
0305 
0306     main_rate = rsnd_ssi_clk_query(rdai, rate, chan, &idx);
0307     if (!main_rate) {
0308         dev_err(dev, "unsupported clock rate\n");
0309         return -EIO;
0310     }
0311 
0312     ret = rsnd_adg_ssi_clk_try_start(mod, main_rate);
0313     if (ret < 0)
0314         return ret;
0315 
0316     /*
0317      * SSI clock will be output contiguously
0318      * by below settings.
0319      * This means, rsnd_ssi_master_clk_start()
0320      * and rsnd_ssi_register_setup() are necessary
0321      * for SSI parent
0322      *
0323      * SSICR  : FORCE, SCKD, SWSD
0324      * SSIWSR : CONT
0325      */
0326     ssi->cr_clk = FORCE | rsnd_rdai_width_to_swl(rdai) |
0327             SCKD | SWSD | CKDV(idx);
0328     ssi->wsr = CONT;
0329     ssi->rate = rate;
0330     ssi->chan = chan;
0331 
0332     dev_dbg(dev, "%s outputs %d chan %u Hz\n",
0333         rsnd_mod_name(mod), chan, rate);
0334 
0335     return 0;
0336 }
0337 
0338 static void rsnd_ssi_master_clk_stop(struct rsnd_mod *mod,
0339                      struct rsnd_dai_stream *io)
0340 {
0341     struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
0342     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0343 
0344     if (!rsnd_rdai_is_clk_master(rdai))
0345         return;
0346 
0347     if (!rsnd_ssi_can_output_clk(mod))
0348         return;
0349 
0350     if (ssi->usrcnt > 1)
0351         return;
0352 
0353     ssi->cr_clk = 0;
0354     ssi->rate   = 0;
0355     ssi->chan   = 0;
0356 
0357     rsnd_adg_ssi_clk_stop(mod);
0358 }
0359 
0360 static void rsnd_ssi_config_init(struct rsnd_mod *mod,
0361                 struct rsnd_dai_stream *io)
0362 {
0363     struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
0364     struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);
0365     struct device *dev = rsnd_priv_to_dev(priv);
0366     struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
0367     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0368     u32 cr_own  = ssi->cr_own;
0369     u32 cr_mode = ssi->cr_mode;
0370     u32 wsr     = ssi->wsr;
0371     int width;
0372     int is_tdm, is_tdm_split;
0373 
0374     is_tdm      = rsnd_runtime_is_tdm(io);
0375     is_tdm_split    = rsnd_runtime_is_tdm_split(io);
0376 
0377     if (is_tdm)
0378         dev_dbg(dev, "TDM mode\n");
0379     if (is_tdm_split)
0380         dev_dbg(dev, "TDM Split mode\n");
0381 
0382     cr_own |= FORCE | rsnd_rdai_width_to_swl(rdai);
0383 
0384     if (rdai->bit_clk_inv)
0385         cr_own |= SCKP;
0386     if (rdai->frm_clk_inv && !is_tdm)
0387         cr_own |= SWSP;
0388     if (rdai->data_alignment)
0389         cr_own |= SDTA;
0390     if (rdai->sys_delay)
0391         cr_own |= DEL;
0392 
0393     /*
0394      * TDM Mode
0395      * see
0396      *  rsnd_ssiu_init_gen2()
0397      */
0398     if (is_tdm || is_tdm_split) {
0399         wsr |= WS_MODE;
0400         cr_own  |= CHNL_8;
0401     }
0402 
0403     /*
0404      * We shouldn't exchange SWSP after running.
0405      * This means, parent needs to care it.
0406      */
0407     if (rsnd_ssi_is_parent(mod, io))
0408         goto init_end;
0409 
0410     if (rsnd_io_is_play(io))
0411         cr_own |= TRMD;
0412 
0413     cr_own &= ~DWL_MASK;
0414     width = snd_pcm_format_width(runtime->format);
0415     if (is_tdm_split) {
0416         /*
0417          * The SWL and DWL bits in SSICR should be fixed at 32-bit
0418          * setting when TDM split mode.
0419          * see datasheet
0420          *  Operation :: TDM Format Split Function (TDM Split Mode)
0421          */
0422         width = 32;
0423     }
0424 
0425     switch (width) {
0426     case 8:
0427         cr_own |= DWL_8;
0428         break;
0429     case 16:
0430         cr_own |= DWL_16;
0431         break;
0432     case 24:
0433         cr_own |= DWL_24;
0434         break;
0435     case 32:
0436         cr_own |= DWL_32;
0437         break;
0438     }
0439 
0440     if (rsnd_ssi_is_dma_mode(mod)) {
0441         cr_mode = UIEN | OIEN | /* over/under run */
0442               DMEN;     /* DMA : enable DMA */
0443     } else {
0444         cr_mode = DIEN;     /* PIO : enable Data interrupt */
0445     }
0446 
0447 init_end:
0448     ssi->cr_own = cr_own;
0449     ssi->cr_mode    = cr_mode;
0450     ssi->wsr    = wsr;
0451 }
0452 
0453 static void rsnd_ssi_register_setup(struct rsnd_mod *mod)
0454 {
0455     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0456 
0457     rsnd_mod_write(mod, SSIWSR, ssi->wsr);
0458     rsnd_mod_write(mod, SSICR,  ssi->cr_own |
0459                     ssi->cr_clk |
0460                     ssi->cr_mode    |
0461                     ssi->cr_en);
0462 }
0463 
0464 /*
0465  *  SSI mod common functions
0466  */
0467 static int rsnd_ssi_init(struct rsnd_mod *mod,
0468              struct rsnd_dai_stream *io,
0469              struct rsnd_priv *priv)
0470 {
0471     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0472     int ret;
0473 
0474     if (!rsnd_ssi_is_run_mods(mod, io))
0475         return 0;
0476 
0477     ret = rsnd_ssi_master_clk_start(mod, io);
0478     if (ret < 0)
0479         return ret;
0480 
0481     ssi->usrcnt++;
0482 
0483     rsnd_mod_power_on(mod);
0484 
0485     rsnd_ssi_config_init(mod, io);
0486 
0487     rsnd_ssi_register_setup(mod);
0488 
0489     /* clear error status */
0490     rsnd_ssi_status_clear(mod);
0491 
0492     return 0;
0493 }
0494 
0495 static int rsnd_ssi_quit(struct rsnd_mod *mod,
0496              struct rsnd_dai_stream *io,
0497              struct rsnd_priv *priv)
0498 {
0499     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0500     struct device *dev = rsnd_priv_to_dev(priv);
0501 
0502     if (!rsnd_ssi_is_run_mods(mod, io))
0503         return 0;
0504 
0505     if (!ssi->usrcnt) {
0506         dev_err(dev, "%s usrcnt error\n", rsnd_mod_name(mod));
0507         return -EIO;
0508     }
0509 
0510     rsnd_ssi_master_clk_stop(mod, io);
0511 
0512     rsnd_mod_power_off(mod);
0513 
0514     ssi->usrcnt--;
0515 
0516     if (!ssi->usrcnt) {
0517         ssi->cr_own = 0;
0518         ssi->cr_mode    = 0;
0519         ssi->wsr    = 0;
0520     }
0521 
0522     return 0;
0523 }
0524 
0525 static int rsnd_ssi_hw_params(struct rsnd_mod *mod,
0526                   struct rsnd_dai_stream *io,
0527                   struct snd_pcm_substream *substream,
0528                   struct snd_pcm_hw_params *params)
0529 {
0530     struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
0531     unsigned int fmt_width = snd_pcm_format_width(params_format(params));
0532 
0533     if (fmt_width > rdai->chan_width) {
0534         struct rsnd_priv *priv = rsnd_io_to_priv(io);
0535         struct device *dev = rsnd_priv_to_dev(priv);
0536 
0537         dev_err(dev, "invalid combination of slot-width and format-data-width\n");
0538         return -EINVAL;
0539     }
0540 
0541     return 0;
0542 }
0543 
0544 static int rsnd_ssi_start(struct rsnd_mod *mod,
0545               struct rsnd_dai_stream *io,
0546               struct rsnd_priv *priv)
0547 {
0548     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0549 
0550     if (!rsnd_ssi_is_run_mods(mod, io))
0551         return 0;
0552 
0553     /*
0554      * EN will be set via SSIU :: SSI_CONTROL
0555      * if Multi channel mode
0556      */
0557     if (rsnd_ssi_multi_secondaries_runtime(io))
0558         return 0;
0559 
0560     /*
0561      * EN is for data output.
0562      * SSI parent EN is not needed.
0563      */
0564     if (rsnd_ssi_is_parent(mod, io))
0565         return 0;
0566 
0567     ssi->cr_en = EN;
0568 
0569     rsnd_mod_write(mod, SSICR,  ssi->cr_own |
0570                     ssi->cr_clk |
0571                     ssi->cr_mode    |
0572                     ssi->cr_en);
0573 
0574     return 0;
0575 }
0576 
0577 static int rsnd_ssi_stop(struct rsnd_mod *mod,
0578              struct rsnd_dai_stream *io,
0579              struct rsnd_priv *priv)
0580 {
0581     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0582     u32 cr;
0583 
0584     if (!rsnd_ssi_is_run_mods(mod, io))
0585         return 0;
0586 
0587     if (rsnd_ssi_is_parent(mod, io))
0588         return 0;
0589 
0590     cr  =   ssi->cr_own |
0591         ssi->cr_clk;
0592 
0593     /*
0594      * disable all IRQ,
0595      * Playback: Wait all data was sent
0596      * Capture:  It might not receave data. Do nothing
0597      */
0598     if (rsnd_io_is_play(io)) {
0599         rsnd_mod_write(mod, SSICR, cr | ssi->cr_en);
0600         rsnd_ssi_status_check(mod, DIRQ);
0601     }
0602 
0603     /* In multi-SSI mode, stop is performed by setting ssi0129 in
0604      * SSI_CONTROL to 0 (in rsnd_ssio_stop_gen2). Do nothing here.
0605      */
0606     if (rsnd_ssi_multi_secondaries_runtime(io))
0607         return 0;
0608 
0609     /*
0610      * disable SSI,
0611      * and, wait idle state
0612      */
0613     rsnd_mod_write(mod, SSICR, cr); /* disabled all */
0614     rsnd_ssi_status_check(mod, IIRQ);
0615 
0616     ssi->cr_en = 0;
0617 
0618     return 0;
0619 }
0620 
0621 static int rsnd_ssi_irq(struct rsnd_mod *mod,
0622             struct rsnd_dai_stream *io,
0623             struct rsnd_priv *priv,
0624             int enable)
0625 {
0626     u32 val = 0;
0627     int is_tdm, is_tdm_split;
0628     int id = rsnd_mod_id(mod);
0629 
0630     is_tdm      = rsnd_runtime_is_tdm(io);
0631     is_tdm_split    = rsnd_runtime_is_tdm_split(io);
0632 
0633     if (rsnd_is_gen1(priv))
0634         return 0;
0635 
0636     if (rsnd_ssi_is_parent(mod, io))
0637         return 0;
0638 
0639     if (!rsnd_ssi_is_run_mods(mod, io))
0640         return 0;
0641 
0642     if (enable)
0643         val = rsnd_ssi_is_dma_mode(mod) ? 0x0e000000 : 0x0f000000;
0644 
0645     if (is_tdm || is_tdm_split) {
0646         switch (id) {
0647         case 0:
0648         case 1:
0649         case 2:
0650         case 3:
0651         case 4:
0652         case 9:
0653             val |= 0x0000ff00;
0654             break;
0655         }
0656     }
0657 
0658     rsnd_mod_write(mod, SSI_INT_ENABLE, val);
0659 
0660     return 0;
0661 }
0662 
0663 static bool rsnd_ssi_pio_interrupt(struct rsnd_mod *mod,
0664                    struct rsnd_dai_stream *io);
0665 static void __rsnd_ssi_interrupt(struct rsnd_mod *mod,
0666                  struct rsnd_dai_stream *io)
0667 {
0668     struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
0669     struct device *dev = rsnd_priv_to_dev(priv);
0670     int is_dma = rsnd_ssi_is_dma_mode(mod);
0671     u32 status;
0672     bool elapsed = false;
0673     bool stop = false;
0674 
0675     spin_lock(&priv->lock);
0676 
0677     /* ignore all cases if not working */
0678     if (!rsnd_io_is_working(io))
0679         goto rsnd_ssi_interrupt_out;
0680 
0681     status = rsnd_ssi_status_get(mod);
0682 
0683     /* PIO only */
0684     if (!is_dma && (status & DIRQ))
0685         elapsed = rsnd_ssi_pio_interrupt(mod, io);
0686 
0687     /* DMA only */
0688     if (is_dma && (status & (UIRQ | OIRQ))) {
0689         rsnd_print_irq_status(dev, "%s err status : 0x%08x\n",
0690                       rsnd_mod_name(mod), status);
0691 
0692         stop = true;
0693     }
0694 
0695     stop |= rsnd_ssiu_busif_err_status_clear(mod);
0696 
0697     rsnd_ssi_status_clear(mod);
0698 rsnd_ssi_interrupt_out:
0699     spin_unlock(&priv->lock);
0700 
0701     if (elapsed)
0702         rsnd_dai_period_elapsed(io);
0703 
0704     if (stop)
0705         snd_pcm_stop_xrun(io->substream);
0706 
0707 }
0708 
0709 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
0710 {
0711     struct rsnd_mod *mod = data;
0712 
0713     rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt);
0714 
0715     return IRQ_HANDLED;
0716 }
0717 
0718 static u32 *rsnd_ssi_get_status(struct rsnd_mod *mod,
0719                 struct rsnd_dai_stream *io,
0720                 enum rsnd_mod_type type)
0721 {
0722     /*
0723      * SSIP (= SSI parent) needs to be special, otherwise,
0724      * 2nd SSI might doesn't start. see also rsnd_mod_call()
0725      *
0726      * We can't include parent SSI status on SSI, because we don't know
0727      * how many SSI requests parent SSI. Thus, it is localed on "io" now.
0728      * ex) trouble case
0729      *  Playback: SSI0
0730      *  Capture : SSI1 (needs SSI0)
0731      *
0732      * 1) start Capture  -> SSI0/SSI1 are started.
0733      * 2) start Playback -> SSI0 doesn't work, because it is already
0734      *          marked as "started" on 1)
0735      *
0736      * OTOH, using each mod's status is good for MUX case.
0737      * It doesn't need to start in 2nd start
0738      * ex)
0739      *  IO-0: SRC0 -> CTU1 -+-> MUX -> DVC -> SSIU -> SSI0
0740      *              |
0741      *  IO-1: SRC1 -> CTU2 -+
0742      *
0743      * 1) start IO-0 -> start SSI0
0744      * 2) start IO-1 -> SSI0 doesn't need to start, because it is
0745      *          already started on 1)
0746      */
0747     if (type == RSND_MOD_SSIP)
0748         return &io->parent_ssi_status;
0749 
0750     return rsnd_mod_get_status(mod, io, type);
0751 }
0752 
0753 /*
0754  *      SSI PIO
0755  */
0756 static void rsnd_ssi_parent_attach(struct rsnd_mod *mod,
0757                    struct rsnd_dai_stream *io)
0758 {
0759     struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
0760     struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
0761 
0762     if (!__rsnd_ssi_is_pin_sharing(mod))
0763         return;
0764 
0765     if (!rsnd_rdai_is_clk_master(rdai))
0766         return;
0767 
0768     if (rsnd_ssi_is_multi_secondary(mod, io))
0769         return;
0770 
0771     switch (rsnd_mod_id(mod)) {
0772     case 1:
0773     case 2:
0774     case 9:
0775         rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP);
0776         break;
0777     case 4:
0778         rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP);
0779         break;
0780     case 8:
0781         rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP);
0782         break;
0783     }
0784 }
0785 
0786 static int rsnd_ssi_pcm_new(struct rsnd_mod *mod,
0787                 struct rsnd_dai_stream *io,
0788                 struct snd_soc_pcm_runtime *rtd)
0789 {
0790     /*
0791      * rsnd_rdai_is_clk_master() will be enabled after set_fmt,
0792      * and, pcm_new will be called after it.
0793      * This function reuse pcm_new at this point.
0794      */
0795     rsnd_ssi_parent_attach(mod, io);
0796 
0797     return 0;
0798 }
0799 
0800 static int rsnd_ssi_common_probe(struct rsnd_mod *mod,
0801                  struct rsnd_dai_stream *io,
0802                  struct rsnd_priv *priv)
0803 {
0804     struct device *dev = rsnd_priv_to_dev(priv);
0805     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0806     int ret = 0;
0807 
0808     /*
0809      * SSIP/SSIU/IRQ are not needed on
0810      * SSI Multi secondaries
0811      */
0812     if (rsnd_ssi_is_multi_secondary(mod, io))
0813         return 0;
0814 
0815     /*
0816      * It can't judge ssi parent at this point
0817      * see rsnd_ssi_pcm_new()
0818      */
0819 
0820     /*
0821      * SSI might be called again as PIO fallback
0822      * It is easy to manual handling for IRQ request/free
0823      *
0824      * OTOH, this function might be called many times if platform is
0825      * using MIX. It needs xxx_attach() many times on xxx_probe().
0826      * Because of it, we can't control .probe/.remove calling count by
0827      * mod->status.
0828      * But it don't need to call request_irq() many times.
0829      * Let's control it by RSND_SSI_PROBED flag.
0830      */
0831     if (!rsnd_flags_has(ssi, RSND_SSI_PROBED)) {
0832         ret = request_irq(ssi->irq,
0833                   rsnd_ssi_interrupt,
0834                   IRQF_SHARED,
0835                   dev_name(dev), mod);
0836 
0837         rsnd_flags_set(ssi, RSND_SSI_PROBED);
0838     }
0839 
0840     return ret;
0841 }
0842 
0843 static int rsnd_ssi_common_remove(struct rsnd_mod *mod,
0844                   struct rsnd_dai_stream *io,
0845                   struct rsnd_priv *priv)
0846 {
0847     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0848     struct rsnd_mod *pure_ssi_mod = rsnd_io_to_mod_ssi(io);
0849 
0850     /* Do nothing if non SSI (= SSI parent, multi SSI) mod */
0851     if (pure_ssi_mod != mod)
0852         return 0;
0853 
0854     /* PIO will request IRQ again */
0855     if (rsnd_flags_has(ssi, RSND_SSI_PROBED)) {
0856         free_irq(ssi->irq, mod);
0857 
0858         rsnd_flags_del(ssi, RSND_SSI_PROBED);
0859     }
0860 
0861     return 0;
0862 }
0863 
0864 /*
0865  *  SSI PIO functions
0866  */
0867 static bool rsnd_ssi_pio_interrupt(struct rsnd_mod *mod,
0868                    struct rsnd_dai_stream *io)
0869 {
0870     struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
0871     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0872     u32 *buf = (u32 *)(runtime->dma_area + ssi->byte_pos);
0873     int shift = 0;
0874     int byte_pos;
0875     bool elapsed = false;
0876 
0877     if (snd_pcm_format_width(runtime->format) == 24)
0878         shift = 8;
0879 
0880     /*
0881      * 8/16/32 data can be assesse to TDR/RDR register
0882      * directly as 32bit data
0883      * see rsnd_ssi_init()
0884      */
0885     if (rsnd_io_is_play(io))
0886         rsnd_mod_write(mod, SSITDR, (*buf) << shift);
0887     else
0888         *buf = (rsnd_mod_read(mod, SSIRDR) >> shift);
0889 
0890     byte_pos = ssi->byte_pos + sizeof(*buf);
0891 
0892     if (byte_pos >= ssi->next_period_byte) {
0893         int period_pos = byte_pos / ssi->byte_per_period;
0894 
0895         if (period_pos >= runtime->periods) {
0896             byte_pos = 0;
0897             period_pos = 0;
0898         }
0899 
0900         ssi->next_period_byte = (period_pos + 1) * ssi->byte_per_period;
0901 
0902         elapsed = true;
0903     }
0904 
0905     WRITE_ONCE(ssi->byte_pos, byte_pos);
0906 
0907     return elapsed;
0908 }
0909 
0910 static int rsnd_ssi_pio_init(struct rsnd_mod *mod,
0911                  struct rsnd_dai_stream *io,
0912                  struct rsnd_priv *priv)
0913 {
0914     struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
0915     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0916 
0917     if (!rsnd_ssi_is_parent(mod, io)) {
0918         ssi->byte_pos       = 0;
0919         ssi->byte_per_period    = runtime->period_size *
0920                       runtime->channels *
0921                       samples_to_bytes(runtime, 1);
0922         ssi->next_period_byte   = ssi->byte_per_period;
0923     }
0924 
0925     return rsnd_ssi_init(mod, io, priv);
0926 }
0927 
0928 static int rsnd_ssi_pio_pointer(struct rsnd_mod *mod,
0929                 struct rsnd_dai_stream *io,
0930                 snd_pcm_uframes_t *pointer)
0931 {
0932     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
0933     struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
0934 
0935     *pointer = bytes_to_frames(runtime, READ_ONCE(ssi->byte_pos));
0936 
0937     return 0;
0938 }
0939 
0940 static struct rsnd_mod_ops rsnd_ssi_pio_ops = {
0941     .name       = SSI_NAME,
0942     .probe      = rsnd_ssi_common_probe,
0943     .remove     = rsnd_ssi_common_remove,
0944     .init       = rsnd_ssi_pio_init,
0945     .quit       = rsnd_ssi_quit,
0946     .start      = rsnd_ssi_start,
0947     .stop       = rsnd_ssi_stop,
0948     .irq        = rsnd_ssi_irq,
0949     .pointer    = rsnd_ssi_pio_pointer,
0950     .pcm_new    = rsnd_ssi_pcm_new,
0951     .hw_params  = rsnd_ssi_hw_params,
0952     .get_status = rsnd_ssi_get_status,
0953 };
0954 
0955 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
0956                   struct rsnd_dai_stream *io,
0957                   struct rsnd_priv *priv)
0958 {
0959     int ret;
0960 
0961     /*
0962      * SSIP/SSIU/IRQ/DMA are not needed on
0963      * SSI Multi secondaries
0964      */
0965     if (rsnd_ssi_is_multi_secondary(mod, io))
0966         return 0;
0967 
0968     ret = rsnd_ssi_common_probe(mod, io, priv);
0969     if (ret)
0970         return ret;
0971 
0972     /* SSI probe might be called many times in MUX multi path */
0973     ret = rsnd_dma_attach(io, mod, &io->dma);
0974 
0975     return ret;
0976 }
0977 
0978 static int rsnd_ssi_fallback(struct rsnd_mod *mod,
0979                  struct rsnd_dai_stream *io,
0980                  struct rsnd_priv *priv)
0981 {
0982     struct device *dev = rsnd_priv_to_dev(priv);
0983 
0984     /*
0985      * fallback to PIO
0986      *
0987      * SSI .probe might be called again.
0988      * see
0989      *  rsnd_rdai_continuance_probe()
0990      */
0991     mod->ops = &rsnd_ssi_pio_ops;
0992 
0993     dev_info(dev, "%s fallback to PIO mode\n", rsnd_mod_name(mod));
0994 
0995     return 0;
0996 }
0997 
0998 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io,
0999                      struct rsnd_mod *mod)
1000 {
1001     struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
1002     int is_play = rsnd_io_is_play(io);
1003     char *name;
1004 
1005     /*
1006      * It should use "rcar_sound,ssiu" on DT.
1007      * But, we need to keep compatibility for old version.
1008      *
1009      * If it has "rcar_sound.ssiu", it will be used.
1010      * If not, "rcar_sound.ssi" will be used.
1011      * see
1012      *  rsnd_ssiu_dma_req()
1013      *  rsnd_dma_of_path()
1014      */
1015 
1016     if (rsnd_ssi_use_busif(io))
1017         name = is_play ? "rxu" : "txu";
1018     else
1019         name = is_play ? "rx" : "tx";
1020 
1021     return rsnd_dma_request_channel(rsnd_ssi_of_node(priv),
1022                     SSI_NAME, mod, name);
1023 }
1024 
1025 #ifdef CONFIG_DEBUG_FS
1026 static void rsnd_ssi_debug_info(struct seq_file *m,
1027                 struct rsnd_dai_stream *io,
1028                 struct rsnd_mod *mod)
1029 {
1030     struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
1031     struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
1032 
1033     seq_printf(m, "clock:           %s\n",      rsnd_rdai_is_clk_master(rdai) ?
1034                                 "provider" : "consumer");
1035     seq_printf(m, "bit_clk_inv:     %d\n",      rdai->bit_clk_inv);
1036     seq_printf(m, "frm_clk_inv:     %d\n",      rdai->frm_clk_inv);
1037     seq_printf(m, "pin share:       %d\n",      __rsnd_ssi_is_pin_sharing(mod));
1038     seq_printf(m, "can out clk:     %d\n",      rsnd_ssi_can_output_clk(mod));
1039     seq_printf(m, "multi secondary: %d\n",      rsnd_ssi_is_multi_secondary(mod, io));
1040     seq_printf(m, "tdm:             %d, %d\n",  rsnd_runtime_is_tdm(io),
1041                             rsnd_runtime_is_tdm_split(io));
1042     seq_printf(m, "chan:            %d\n",      ssi->chan);
1043     seq_printf(m, "user:            %d\n",      ssi->usrcnt);
1044 
1045     rsnd_debugfs_mod_reg_show(m, mod, RSND_GEN2_SSI,
1046                   rsnd_mod_id(mod) * 0x40, 0x40);
1047 }
1048 #define DEBUG_INFO .debug_info = rsnd_ssi_debug_info
1049 #else
1050 #define DEBUG_INFO
1051 #endif
1052 
1053 static struct rsnd_mod_ops rsnd_ssi_dma_ops = {
1054     .name       = SSI_NAME,
1055     .dma_req    = rsnd_ssi_dma_req,
1056     .probe      = rsnd_ssi_dma_probe,
1057     .remove     = rsnd_ssi_common_remove,
1058     .init       = rsnd_ssi_init,
1059     .quit       = rsnd_ssi_quit,
1060     .start      = rsnd_ssi_start,
1061     .stop       = rsnd_ssi_stop,
1062     .irq        = rsnd_ssi_irq,
1063     .pcm_new    = rsnd_ssi_pcm_new,
1064     .fallback   = rsnd_ssi_fallback,
1065     .hw_params  = rsnd_ssi_hw_params,
1066     .get_status = rsnd_ssi_get_status,
1067     DEBUG_INFO
1068 };
1069 
1070 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod)
1071 {
1072     return mod->ops == &rsnd_ssi_dma_ops;
1073 }
1074 
1075 /*
1076  *      ssi mod function
1077  */
1078 static void rsnd_ssi_connect(struct rsnd_mod *mod,
1079                  struct rsnd_dai_stream *io)
1080 {
1081     struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
1082     static const enum rsnd_mod_type types[] = {
1083         RSND_MOD_SSI,
1084         RSND_MOD_SSIM1,
1085         RSND_MOD_SSIM2,
1086         RSND_MOD_SSIM3,
1087     };
1088     enum rsnd_mod_type type;
1089     int i;
1090 
1091     /* try SSI -> SSIM1 -> SSIM2 -> SSIM3 */
1092     for (i = 0; i < ARRAY_SIZE(types); i++) {
1093         type = types[i];
1094         if (!rsnd_io_to_mod(io, type)) {
1095             rsnd_dai_connect(mod, io, type);
1096             rsnd_rdai_channels_set(rdai, (i + 1) * 2);
1097             rsnd_rdai_ssi_lane_set(rdai, (i + 1));
1098             return;
1099         }
1100     }
1101 }
1102 
1103 void rsnd_parse_connect_ssi(struct rsnd_dai *rdai,
1104                 struct device_node *playback,
1105                 struct device_node *capture)
1106 {
1107     struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);
1108     struct device *dev = rsnd_priv_to_dev(priv);
1109     struct device_node *node;
1110     struct device_node *np;
1111     int i;
1112 
1113     node = rsnd_ssi_of_node(priv);
1114     if (!node)
1115         return;
1116 
1117     i = 0;
1118     for_each_child_of_node(node, np) {
1119         struct rsnd_mod *mod;
1120 
1121         i = rsnd_node_fixed_index(dev, np, SSI_NAME, i);
1122         if (i < 0) {
1123             of_node_put(np);
1124             break;
1125         }
1126 
1127         mod = rsnd_ssi_mod_get(priv, i);
1128 
1129         if (np == playback)
1130             rsnd_ssi_connect(mod, &rdai->playback);
1131         if (np == capture)
1132             rsnd_ssi_connect(mod, &rdai->capture);
1133         i++;
1134     }
1135 
1136     of_node_put(node);
1137 }
1138 
1139 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id)
1140 {
1141     if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv)))
1142         id = 0;
1143 
1144     return rsnd_mod_get(rsnd_ssi_get(priv, id));
1145 }
1146 
1147 int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod)
1148 {
1149     if (!mod)
1150         return 0;
1151 
1152     return !!(rsnd_flags_has(rsnd_mod_to_ssi(mod), RSND_SSI_CLK_PIN_SHARE));
1153 }
1154 
1155 int rsnd_ssi_probe(struct rsnd_priv *priv)
1156 {
1157     struct device_node *node;
1158     struct device_node *np;
1159     struct device *dev = rsnd_priv_to_dev(priv);
1160     struct rsnd_mod_ops *ops;
1161     struct clk *clk;
1162     struct rsnd_ssi *ssi;
1163     char name[RSND_SSI_NAME_SIZE];
1164     int i, nr, ret;
1165 
1166     node = rsnd_ssi_of_node(priv);
1167     if (!node)
1168         return -EINVAL;
1169 
1170     nr = rsnd_node_count(priv, node, SSI_NAME);
1171     if (!nr) {
1172         ret = -EINVAL;
1173         goto rsnd_ssi_probe_done;
1174     }
1175 
1176     ssi = devm_kcalloc(dev, nr, sizeof(*ssi), GFP_KERNEL);
1177     if (!ssi) {
1178         ret = -ENOMEM;
1179         goto rsnd_ssi_probe_done;
1180     }
1181 
1182     priv->ssi   = ssi;
1183     priv->ssi_nr    = nr;
1184 
1185     i = 0;
1186     for_each_child_of_node(node, np) {
1187         if (!of_device_is_available(np))
1188             goto skip;
1189 
1190         i = rsnd_node_fixed_index(dev, np, SSI_NAME, i);
1191         if (i < 0) {
1192             ret = -EINVAL;
1193             of_node_put(np);
1194             goto rsnd_ssi_probe_done;
1195         }
1196 
1197         ssi = rsnd_ssi_get(priv, i);
1198 
1199         snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d",
1200              SSI_NAME, i);
1201 
1202         clk = devm_clk_get(dev, name);
1203         if (IS_ERR(clk)) {
1204             ret = PTR_ERR(clk);
1205             of_node_put(np);
1206             goto rsnd_ssi_probe_done;
1207         }
1208 
1209         if (of_get_property(np, "shared-pin", NULL))
1210             rsnd_flags_set(ssi, RSND_SSI_CLK_PIN_SHARE);
1211 
1212         if (of_get_property(np, "no-busif", NULL))
1213             rsnd_flags_set(ssi, RSND_SSI_NO_BUSIF);
1214 
1215         ssi->irq = irq_of_parse_and_map(np, 0);
1216         if (!ssi->irq) {
1217             ret = -EINVAL;
1218             of_node_put(np);
1219             goto rsnd_ssi_probe_done;
1220         }
1221 
1222         if (of_property_read_bool(np, "pio-transfer"))
1223             ops = &rsnd_ssi_pio_ops;
1224         else
1225             ops = &rsnd_ssi_dma_ops;
1226 
1227         ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk,
1228                     RSND_MOD_SSI, i);
1229         if (ret) {
1230             of_node_put(np);
1231             goto rsnd_ssi_probe_done;
1232         }
1233 skip:
1234         i++;
1235     }
1236 
1237     ret = 0;
1238 
1239 rsnd_ssi_probe_done:
1240     of_node_put(node);
1241 
1242     return ret;
1243 }
1244 
1245 void rsnd_ssi_remove(struct rsnd_priv *priv)
1246 {
1247     struct rsnd_ssi *ssi;
1248     int i;
1249 
1250     for_each_rsnd_ssi(ssi, priv, i) {
1251         rsnd_mod_quit(rsnd_mod_get(ssi));
1252     }
1253 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!