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

TOMOYO Linux Cross Reference
Linux/sound/soc/intel/boards/cht_bsw_max98090_ti.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  *  cht-bsw-max98090.c - ASoc Machine driver for Intel Cherryview-based
  4  *  platforms Cherrytrail and Braswell, with max98090 & TI codec.
  5  *
  6  *  Copyright (C) 2015 Intel Corp
  7  *  Author: Fang, Yang A <yang.a.fang@intel.com>
  8  *  This file is modified from cht_bsw_rt5645.c
  9  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 10  *
 11  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 12  */
 13 
 14 #include <linux/dmi.h>
 15 #include <linux/module.h>
 16 #include <linux/platform_device.h>
 17 #include <linux/slab.h>
 18 #include <linux/acpi.h>
 19 #include <linux/clk.h>
 20 #include <sound/pcm.h>
 21 #include <sound/pcm_params.h>
 22 #include <sound/soc.h>
 23 #include <sound/soc-acpi.h>
 24 #include <sound/jack.h>
 25 #include "../../codecs/max98090.h"
 26 #include "../atom/sst-atom-controls.h"
 27 #include "../../codecs/ts3a227e.h"
 28 
 29 #define CHT_PLAT_CLK_3_HZ       19200000
 30 #define CHT_CODEC_DAI   "HiFi"
 31 
 32 #define QUIRK_PMC_PLT_CLK_0                             0x01
 33 
 34 struct cht_mc_private {
 35         struct clk *mclk;
 36         struct snd_soc_jack jack;
 37         bool ts3a227e_present;
 38         int quirks;
 39 };
 40 
 41 static int platform_clock_control(struct snd_soc_dapm_widget *w,
 42                                           struct snd_kcontrol *k, int  event)
 43 {
 44         struct snd_soc_dapm_context *dapm = w->dapm;
 45         struct snd_soc_card *card = dapm->card;
 46         struct snd_soc_dai *codec_dai;
 47         struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
 48         int ret;
 49 
 50         /* See the comment in snd_cht_mc_probe() */
 51         if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
 52                 return 0;
 53 
 54         codec_dai = snd_soc_card_get_codec_dai(card, CHT_CODEC_DAI);
 55         if (!codec_dai) {
 56                 dev_err(card->dev, "Codec dai not found; Unable to set platform clock\n");
 57                 return -EIO;
 58         }
 59 
 60         if (SND_SOC_DAPM_EVENT_ON(event)) {
 61                 ret = clk_prepare_enable(ctx->mclk);
 62                 if (ret < 0) {
 63                         dev_err(card->dev,
 64                                 "could not configure MCLK state");
 65                         return ret;
 66                 }
 67         } else {
 68                 clk_disable_unprepare(ctx->mclk);
 69         }
 70 
 71         return 0;
 72 }
 73 
 74 static const struct snd_soc_dapm_widget cht_dapm_widgets[] = {
 75         SND_SOC_DAPM_HP("Headphone", NULL),
 76         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 77         SND_SOC_DAPM_MIC("Int Mic", NULL),
 78         SND_SOC_DAPM_SPK("Ext Spk", NULL),
 79         SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
 80                             platform_clock_control, SND_SOC_DAPM_PRE_PMU |
 81                             SND_SOC_DAPM_POST_PMD),
 82 };
 83 
 84 static const struct snd_soc_dapm_route cht_audio_map[] = {
 85         {"IN34", NULL, "Headset Mic"},
 86         {"Headset Mic", NULL, "MICBIAS"},
 87         {"DMICL", NULL, "Int Mic"},
 88         {"Headphone", NULL, "HPL"},
 89         {"Headphone", NULL, "HPR"},
 90         {"Ext Spk", NULL, "SPKL"},
 91         {"Ext Spk", NULL, "SPKR"},
 92         {"HiFi Playback", NULL, "ssp2 Tx"},
 93         {"ssp2 Tx", NULL, "codec_out0"},
 94         {"ssp2 Tx", NULL, "codec_out1"},
 95         {"codec_in0", NULL, "ssp2 Rx" },
 96         {"codec_in1", NULL, "ssp2 Rx" },
 97         {"ssp2 Rx", NULL, "HiFi Capture"},
 98         {"Headphone", NULL, "Platform Clock"},
 99         {"Headset Mic", NULL, "Platform Clock"},
100         {"Int Mic", NULL, "Platform Clock"},
101         {"Ext Spk", NULL, "Platform Clock"},
102 };
103 
104 static const struct snd_kcontrol_new cht_mc_controls[] = {
105         SOC_DAPM_PIN_SWITCH("Headphone"),
106         SOC_DAPM_PIN_SWITCH("Headset Mic"),
107         SOC_DAPM_PIN_SWITCH("Int Mic"),
108         SOC_DAPM_PIN_SWITCH("Ext Spk"),
109 };
110 
111 static int cht_aif1_hw_params(struct snd_pcm_substream *substream,
112                              struct snd_pcm_hw_params *params)
113 {
114         struct snd_soc_pcm_runtime *rtd = substream->private_data;
115         struct snd_soc_dai *codec_dai = rtd->codec_dai;
116         int ret;
117 
118         ret = snd_soc_dai_set_sysclk(codec_dai, M98090_REG_SYSTEM_CLOCK,
119                                      CHT_PLAT_CLK_3_HZ, SND_SOC_CLOCK_IN);
120         if (ret < 0) {
121                 dev_err(rtd->dev, "can't set codec sysclk: %d\n", ret);
122                 return ret;
123         }
124 
125         return 0;
126 }
127 
128 static int cht_ti_jack_event(struct notifier_block *nb,
129                 unsigned long event, void *data)
130 {
131         struct snd_soc_jack *jack = (struct snd_soc_jack *)data;
132         struct snd_soc_dapm_context *dapm = &jack->card->dapm;
133 
134         if (event & SND_JACK_MICROPHONE) {
135                 snd_soc_dapm_force_enable_pin(dapm, "SHDN");
136                 snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
137                 snd_soc_dapm_sync(dapm);
138         } else {
139                 snd_soc_dapm_disable_pin(dapm, "MICBIAS");
140                 snd_soc_dapm_disable_pin(dapm, "SHDN");
141                 snd_soc_dapm_sync(dapm);
142         }
143 
144         return 0;
145 }
146 
147 static struct notifier_block cht_jack_nb = {
148         .notifier_call = cht_ti_jack_event,
149 };
150 
151 static struct snd_soc_jack_pin hs_jack_pins[] = {
152         {
153                 .pin    = "Headphone",
154                 .mask   = SND_JACK_HEADPHONE,
155         },
156         {
157                 .pin    = "Headset Mic",
158                 .mask   = SND_JACK_MICROPHONE,
159         },
160 };
161 
162 static struct snd_soc_jack_gpio hs_jack_gpios[] = {
163         {
164                 .name           = "hp",
165                 .report         = SND_JACK_HEADPHONE | SND_JACK_LINEOUT,
166                 .debounce_time  = 200,
167         },
168         {
169                 .name           = "mic",
170                 .invert         = 1,
171                 .report         = SND_JACK_MICROPHONE,
172                 .debounce_time  = 200,
173         },
174 };
175 
176 static const struct acpi_gpio_params hp_gpios = { 0, 0, false };
177 static const struct acpi_gpio_params mic_gpios = { 1, 0, false };
178 
179 static const struct acpi_gpio_mapping acpi_max98090_gpios[] = {
180         { "hp-gpios", &hp_gpios, 1 },
181         { "mic-gpios", &mic_gpios, 1 },
182         {},
183 };
184 
185 static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
186 {
187         int ret;
188         int jack_type;
189         struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
190         struct snd_soc_jack *jack = &ctx->jack;
191 
192         if (ctx->ts3a227e_present) {
193                 /*
194                  * The jack has already been created in the
195                  * cht_max98090_headset_init() function.
196                  */
197                 snd_soc_jack_notifier_register(jack, &cht_jack_nb);
198                 return 0;
199         }
200 
201         jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE;
202 
203         ret = snd_soc_card_jack_new(runtime->card, "Headset Jack",
204                                     jack_type, jack,
205                                     hs_jack_pins, ARRAY_SIZE(hs_jack_pins));
206         if (ret) {
207                 dev_err(runtime->dev, "Headset Jack creation failed %d\n", ret);
208                 return ret;
209         }
210 
211         ret = snd_soc_jack_add_gpiods(runtime->card->dev->parent, jack,
212                                       ARRAY_SIZE(hs_jack_gpios),
213                                       hs_jack_gpios);
214         if (ret) {
215                 /*
216                  * flag error but don't bail if jack detect is broken
217                  * due to platform issues or bad BIOS/configuration
218                  */
219                 dev_err(runtime->dev,
220                         "jack detection gpios not added, error %d\n", ret);
221         }
222 
223         /* See the comment in snd_cht_mc_probe() */
224         if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
225                 return 0;
226 
227         /*
228          * The firmware might enable the clock at
229          * boot (this information may or may not
230          * be reflected in the enable clock register).
231          * To change the rate we must disable the clock
232          * first to cover these cases. Due to common
233          * clock framework restrictions that do not allow
234          * to disable a clock that has not been enabled,
235          * we need to enable the clock first.
236          */
237         ret = clk_prepare_enable(ctx->mclk);
238         if (!ret)
239                 clk_disable_unprepare(ctx->mclk);
240 
241         ret = clk_set_rate(ctx->mclk, CHT_PLAT_CLK_3_HZ);
242 
243         if (ret)
244                 dev_err(runtime->dev, "unable to set MCLK rate\n");
245 
246         return ret;
247 }
248 
249 static int cht_codec_fixup(struct snd_soc_pcm_runtime *rtd,
250                             struct snd_pcm_hw_params *params)
251 {
252         struct snd_interval *rate = hw_param_interval(params,
253                         SNDRV_PCM_HW_PARAM_RATE);
254         struct snd_interval *channels = hw_param_interval(params,
255                                                 SNDRV_PCM_HW_PARAM_CHANNELS);
256         int ret = 0;
257         unsigned int fmt = 0;
258 
259         ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 16);
260         if (ret < 0) {
261                 dev_err(rtd->dev, "can't set cpu_dai slot fmt: %d\n", ret);
262                 return ret;
263         }
264 
265         fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
266                                 | SND_SOC_DAIFMT_CBS_CFS;
267 
268         ret = snd_soc_dai_set_fmt(rtd->cpu_dai, fmt);
269         if (ret < 0) {
270                 dev_err(rtd->dev, "can't set cpu_dai set fmt: %d\n", ret);
271                 return ret;
272         }
273 
274         /* The DSP will covert the FE rate to 48k, stereo, 24bits */
275         rate->min = rate->max = 48000;
276         channels->min = channels->max = 2;
277 
278         /* set SSP2 to 16-bit */
279         params_set_format(params, SNDRV_PCM_FORMAT_S16_LE);
280         return 0;
281 }
282 
283 static int cht_aif1_startup(struct snd_pcm_substream *substream)
284 {
285         return snd_pcm_hw_constraint_single(substream->runtime,
286                         SNDRV_PCM_HW_PARAM_RATE, 48000);
287 }
288 
289 static int cht_max98090_headset_init(struct snd_soc_component *component)
290 {
291         struct snd_soc_card *card = component->card;
292         struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
293         struct snd_soc_jack *jack = &ctx->jack;
294         int jack_type;
295         int ret;
296 
297         /*
298          * TI supports 4 butons headset detection
299          * KEY_MEDIA
300          * KEY_VOICECOMMAND
301          * KEY_VOLUMEUP
302          * KEY_VOLUMEDOWN
303          */
304         jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE |
305                     SND_JACK_BTN_0 | SND_JACK_BTN_1 |
306                     SND_JACK_BTN_2 | SND_JACK_BTN_3;
307 
308         ret = snd_soc_card_jack_new(card, "Headset Jack", jack_type,
309                                     jack, NULL, 0);
310         if (ret) {
311                 dev_err(card->dev, "Headset Jack creation failed %d\n", ret);
312                 return ret;
313         }
314 
315         return ts3a227e_enable_jack_detect(component, jack);
316 }
317 
318 static const struct snd_soc_ops cht_aif1_ops = {
319         .startup = cht_aif1_startup,
320 };
321 
322 static const struct snd_soc_ops cht_be_ssp2_ops = {
323         .hw_params = cht_aif1_hw_params,
324 };
325 
326 static struct snd_soc_aux_dev cht_max98090_headset_dev = {
327         .name = "Headset Chip",
328         .init = cht_max98090_headset_init,
329         .codec_name = "i2c-104C227E:00",
330 };
331 
332 SND_SOC_DAILINK_DEF(dummy,
333         DAILINK_COMP_ARRAY(COMP_DUMMY()));
334 
335 SND_SOC_DAILINK_DEF(media,
336         DAILINK_COMP_ARRAY(COMP_CPU("media-cpu-dai")));
337 
338 SND_SOC_DAILINK_DEF(deepbuffer,
339         DAILINK_COMP_ARRAY(COMP_CPU("deepbuffer-cpu-dai")));
340 
341 SND_SOC_DAILINK_DEF(ssp2_port,
342         DAILINK_COMP_ARRAY(COMP_CPU("ssp2-port")));
343 SND_SOC_DAILINK_DEF(ssp2_codec,
344         DAILINK_COMP_ARRAY(COMP_CODEC("i2c-193C9890:00", "HiFi")));
345 
346 SND_SOC_DAILINK_DEF(platform,
347         DAILINK_COMP_ARRAY(COMP_PLATFORM("sst-mfld-platform")));
348 
349 static struct snd_soc_dai_link cht_dailink[] = {
350         [MERR_DPCM_AUDIO] = {
351                 .name = "Audio Port",
352                 .stream_name = "Audio",
353                 .nonatomic = true,
354                 .dynamic = 1,
355                 .dpcm_playback = 1,
356                 .dpcm_capture = 1,
357                 .ops = &cht_aif1_ops,
358                 SND_SOC_DAILINK_REG(media, dummy, platform),
359         },
360         [MERR_DPCM_DEEP_BUFFER] = {
361                 .name = "Deep-Buffer Audio Port",
362                 .stream_name = "Deep-Buffer Audio",
363                 .nonatomic = true,
364                 .dynamic = 1,
365                 .dpcm_playback = 1,
366                 .ops = &cht_aif1_ops,
367                 SND_SOC_DAILINK_REG(deepbuffer, dummy, platform),
368         },
369         /* back ends */
370         {
371                 .name = "SSP2-Codec",
372                 .id = 0,
373                 .no_pcm = 1,
374                 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
375                                         | SND_SOC_DAIFMT_CBS_CFS,
376                 .init = cht_codec_init,
377                 .be_hw_params_fixup = cht_codec_fixup,
378                 .dpcm_playback = 1,
379                 .dpcm_capture = 1,
380                 .ops = &cht_be_ssp2_ops,
381                 SND_SOC_DAILINK_REG(ssp2_port, ssp2_codec, platform),
382         },
383 };
384 
385 /* SoC card */
386 static struct snd_soc_card snd_soc_card_cht = {
387         .name = "chtmax98090",
388         .owner = THIS_MODULE,
389         .dai_link = cht_dailink,
390         .num_links = ARRAY_SIZE(cht_dailink),
391         .aux_dev = &cht_max98090_headset_dev,
392         .num_aux_devs = 1,
393         .dapm_widgets = cht_dapm_widgets,
394         .num_dapm_widgets = ARRAY_SIZE(cht_dapm_widgets),
395         .dapm_routes = cht_audio_map,
396         .num_dapm_routes = ARRAY_SIZE(cht_audio_map),
397         .controls = cht_mc_controls,
398         .num_controls = ARRAY_SIZE(cht_mc_controls),
399 };
400 
401 static const struct dmi_system_id cht_max98090_quirk_table[] = {
402         {
403                 /* Clapper model Chromebook */
404                 .matches = {
405                         DMI_MATCH(DMI_PRODUCT_NAME, "Clapper"),
406                 },
407                 .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
408         },
409         {
410                 /* Gnawty model Chromebook (Acer Chromebook CB3-111) */
411                 .matches = {
412                         DMI_MATCH(DMI_PRODUCT_NAME, "Gnawty"),
413                 },
414                 .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
415         },
416         {
417                 /* Swanky model Chromebook (Toshiba Chromebook 2) */
418                 .matches = {
419                         DMI_MATCH(DMI_PRODUCT_NAME, "Swanky"),
420                 },
421                 .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
422         },
423         {}
424 };
425 
426 static int snd_cht_mc_probe(struct platform_device *pdev)
427 {
428         const struct dmi_system_id *dmi_id;
429         struct device *dev = &pdev->dev;
430         int ret_val = 0;
431         struct cht_mc_private *drv;
432         const char *mclk_name;
433         struct snd_soc_acpi_mach *mach;
434         const char *platform_name;
435 
436         drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);
437         if (!drv)
438                 return -ENOMEM;
439 
440         dmi_id = dmi_first_match(cht_max98090_quirk_table);
441         if (dmi_id)
442                 drv->quirks = (unsigned long)dmi_id->driver_data;
443 
444         drv->ts3a227e_present = acpi_dev_found("104C227E");
445         if (!drv->ts3a227e_present) {
446                 /* no need probe TI jack detection chip */
447                 snd_soc_card_cht.aux_dev = NULL;
448                 snd_soc_card_cht.num_aux_devs = 0;
449 
450                 ret_val = devm_acpi_dev_add_driver_gpios(dev->parent,
451                                                          acpi_max98090_gpios);
452                 if (ret_val)
453                         dev_dbg(dev, "Unable to add GPIO mapping table\n");
454         }
455 
456         /* override plaform name, if required */
457         snd_soc_card_cht.dev = &pdev->dev;
458         mach = (&pdev->dev)->platform_data;
459         platform_name = mach->mach_params.platform;
460 
461         ret_val = snd_soc_fixup_dai_links_platform_name(&snd_soc_card_cht,
462                                                         platform_name);
463         if (ret_val)
464                 return ret_val;
465 
466         /* register the soc card */
467         snd_soc_card_set_drvdata(&snd_soc_card_cht, drv);
468 
469         if (drv->quirks & QUIRK_PMC_PLT_CLK_0)
470                 mclk_name = "pmc_plt_clk_0";
471         else
472                 mclk_name = "pmc_plt_clk_3";
473 
474         drv->mclk = devm_clk_get(&pdev->dev, mclk_name);
475         if (IS_ERR(drv->mclk)) {
476                 dev_err(&pdev->dev,
477                         "Failed to get MCLK from %s: %ld\n",
478                         mclk_name, PTR_ERR(drv->mclk));
479                 return PTR_ERR(drv->mclk);
480         }
481 
482         /*
483          * Boards which have the MAX98090's clk connected to clk_0 do not seem
484          * to like it if we muck with the clock. If we disable the clock when
485          * it is unused we get "max98090 i2c-193C9890:00: PLL unlocked" errors
486          * and the PLL never seems to lock again.
487          * So for these boards we enable it here once and leave it at that.
488          */
489         if (drv->quirks & QUIRK_PMC_PLT_CLK_0) {
490                 ret_val = clk_prepare_enable(drv->mclk);
491                 if (ret_val < 0) {
492                         dev_err(&pdev->dev, "MCLK enable error: %d\n", ret_val);
493                         return ret_val;
494                 }
495         }
496 
497         ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_cht);
498         if (ret_val) {
499                 dev_err(&pdev->dev,
500                         "snd_soc_register_card failed %d\n", ret_val);
501                 return ret_val;
502         }
503         platform_set_drvdata(pdev, &snd_soc_card_cht);
504         return ret_val;
505 }
506 
507 static int snd_cht_mc_remove(struct platform_device *pdev)
508 {
509         struct snd_soc_card *card = platform_get_drvdata(pdev);
510         struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
511 
512         if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
513                 clk_disable_unprepare(ctx->mclk);
514 
515         return 0;
516 }
517 
518 static struct platform_driver snd_cht_mc_driver = {
519         .driver = {
520                 .name = "cht-bsw-max98090",
521         },
522         .probe = snd_cht_mc_probe,
523         .remove = snd_cht_mc_remove,
524 };
525 
526 module_platform_driver(snd_cht_mc_driver)
527 
528 MODULE_DESCRIPTION("ASoC Intel(R) Braswell Machine driver");
529 MODULE_AUTHOR("Fang, Yang A <yang.a.fang@intel.com>");
530 MODULE_LICENSE("GPL v2");
531 MODULE_ALIAS("platform:cht-bsw-max98090");
532 

~ [ 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