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

TOMOYO Linux Cross Reference
Linux/sound/pci/hda/hda_controller.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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  *
  3  *  Implementation of primary alsa driver code base for Intel HD Audio.
  4  *
  5  *  Copyright(c) 2004 Intel Corporation. All rights reserved.
  6  *
  7  *  Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
  8  *                     PeiSen Hou <pshou@realtek.com.tw>
  9  *
 10  *  This program is free software; you can redistribute it and/or modify it
 11  *  under the terms of the GNU General Public License as published by the Free
 12  *  Software Foundation; either version 2 of the License, or (at your option)
 13  *  any later version.
 14  *
 15  *  This program is distributed in the hope that it will be useful, but WITHOUT
 16  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 17  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 18  *  more details.
 19  *
 20  *
 21  */
 22 
 23 #include <linux/clocksource.h>
 24 #include <linux/delay.h>
 25 #include <linux/interrupt.h>
 26 #include <linux/kernel.h>
 27 #include <linux/module.h>
 28 #include <linux/pm_runtime.h>
 29 #include <linux/slab.h>
 30 #include <sound/core.h>
 31 #include <sound/initval.h>
 32 #include "hda_controller.h"
 33 
 34 #define CREATE_TRACE_POINTS
 35 #include "hda_controller_trace.h"
 36 
 37 /* DSP lock helpers */
 38 #define dsp_lock(dev)           snd_hdac_dsp_lock(azx_stream(dev))
 39 #define dsp_unlock(dev)         snd_hdac_dsp_unlock(azx_stream(dev))
 40 #define dsp_is_locked(dev)      snd_hdac_stream_is_locked(azx_stream(dev))
 41 
 42 /* assign a stream for the PCM */
 43 static inline struct azx_dev *
 44 azx_assign_device(struct azx *chip, struct snd_pcm_substream *substream)
 45 {
 46         struct hdac_stream *s;
 47 
 48         s = snd_hdac_stream_assign(azx_bus(chip), substream);
 49         if (!s)
 50                 return NULL;
 51         return stream_to_azx_dev(s);
 52 }
 53 
 54 /* release the assigned stream */
 55 static inline void azx_release_device(struct azx_dev *azx_dev)
 56 {
 57         snd_hdac_stream_release(azx_stream(azx_dev));
 58 }
 59 
 60 static inline struct hda_pcm_stream *
 61 to_hda_pcm_stream(struct snd_pcm_substream *substream)
 62 {
 63         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
 64         return &apcm->info->stream[substream->stream];
 65 }
 66 
 67 static u64 azx_adjust_codec_delay(struct snd_pcm_substream *substream,
 68                                 u64 nsec)
 69 {
 70         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
 71         struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
 72         u64 codec_frames, codec_nsecs;
 73 
 74         if (!hinfo->ops.get_delay)
 75                 return nsec;
 76 
 77         codec_frames = hinfo->ops.get_delay(hinfo, apcm->codec, substream);
 78         codec_nsecs = div_u64(codec_frames * 1000000000LL,
 79                               substream->runtime->rate);
 80 
 81         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 82                 return nsec + codec_nsecs;
 83 
 84         return (nsec > codec_nsecs) ? nsec - codec_nsecs : 0;
 85 }
 86 
 87 /*
 88  * PCM ops
 89  */
 90 
 91 static int azx_pcm_close(struct snd_pcm_substream *substream)
 92 {
 93         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
 94         struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
 95         struct azx *chip = apcm->chip;
 96         struct azx_dev *azx_dev = get_azx_dev(substream);
 97 
 98         trace_azx_pcm_close(chip, azx_dev);
 99         mutex_lock(&chip->open_mutex);
100         azx_release_device(azx_dev);
101         if (hinfo->ops.close)
102                 hinfo->ops.close(hinfo, apcm->codec, substream);
103         snd_hda_power_down(apcm->codec);
104         mutex_unlock(&chip->open_mutex);
105         snd_hda_codec_pcm_put(apcm->info);
106         return 0;
107 }
108 
109 static int azx_pcm_hw_params(struct snd_pcm_substream *substream,
110                              struct snd_pcm_hw_params *hw_params)
111 {
112         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
113         struct azx *chip = apcm->chip;
114         struct azx_dev *azx_dev = get_azx_dev(substream);
115         int ret;
116 
117         trace_azx_pcm_hw_params(chip, azx_dev);
118         dsp_lock(azx_dev);
119         if (dsp_is_locked(azx_dev)) {
120                 ret = -EBUSY;
121                 goto unlock;
122         }
123 
124         azx_dev->core.bufsize = 0;
125         azx_dev->core.period_bytes = 0;
126         azx_dev->core.format_val = 0;
127         ret = chip->ops->substream_alloc_pages(chip, substream,
128                                           params_buffer_bytes(hw_params));
129 unlock:
130         dsp_unlock(azx_dev);
131         return ret;
132 }
133 
134 static int azx_pcm_hw_free(struct snd_pcm_substream *substream)
135 {
136         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
137         struct azx_dev *azx_dev = get_azx_dev(substream);
138         struct azx *chip = apcm->chip;
139         struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
140         int err;
141 
142         /* reset BDL address */
143         dsp_lock(azx_dev);
144         if (!dsp_is_locked(azx_dev))
145                 snd_hdac_stream_cleanup(azx_stream(azx_dev));
146 
147         snd_hda_codec_cleanup(apcm->codec, hinfo, substream);
148 
149         err = chip->ops->substream_free_pages(chip, substream);
150         azx_stream(azx_dev)->prepared = 0;
151         dsp_unlock(azx_dev);
152         return err;
153 }
154 
155 static int azx_pcm_prepare(struct snd_pcm_substream *substream)
156 {
157         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
158         struct azx *chip = apcm->chip;
159         struct azx_dev *azx_dev = get_azx_dev(substream);
160         struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
161         struct snd_pcm_runtime *runtime = substream->runtime;
162         unsigned int format_val, stream_tag;
163         int err;
164         struct hda_spdif_out *spdif =
165                 snd_hda_spdif_out_of_nid(apcm->codec, hinfo->nid);
166         unsigned short ctls = spdif ? spdif->ctls : 0;
167 
168         trace_azx_pcm_prepare(chip, azx_dev);
169         dsp_lock(azx_dev);
170         if (dsp_is_locked(azx_dev)) {
171                 err = -EBUSY;
172                 goto unlock;
173         }
174 
175         snd_hdac_stream_reset(azx_stream(azx_dev));
176         format_val = snd_hdac_calc_stream_format(runtime->rate,
177                                                 runtime->channels,
178                                                 runtime->format,
179                                                 hinfo->maxbps,
180                                                 ctls);
181         if (!format_val) {
182                 dev_err(chip->card->dev,
183                         "invalid format_val, rate=%d, ch=%d, format=%d\n",
184                         runtime->rate, runtime->channels, runtime->format);
185                 err = -EINVAL;
186                 goto unlock;
187         }
188 
189         err = snd_hdac_stream_set_params(azx_stream(azx_dev), format_val);
190         if (err < 0)
191                 goto unlock;
192 
193         snd_hdac_stream_setup(azx_stream(azx_dev));
194 
195         stream_tag = azx_dev->core.stream_tag;
196         /* CA-IBG chips need the playback stream starting from 1 */
197         if ((chip->driver_caps & AZX_DCAPS_CTX_WORKAROUND) &&
198             stream_tag > chip->capture_streams)
199                 stream_tag -= chip->capture_streams;
200         err = snd_hda_codec_prepare(apcm->codec, hinfo, stream_tag,
201                                      azx_dev->core.format_val, substream);
202 
203  unlock:
204         if (!err)
205                 azx_stream(azx_dev)->prepared = 1;
206         dsp_unlock(azx_dev);
207         return err;
208 }
209 
210 static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
211 {
212         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
213         struct azx *chip = apcm->chip;
214         struct hdac_bus *bus = azx_bus(chip);
215         struct azx_dev *azx_dev;
216         struct snd_pcm_substream *s;
217         struct hdac_stream *hstr;
218         bool start;
219         int sbits = 0;
220         int sync_reg;
221 
222         azx_dev = get_azx_dev(substream);
223         trace_azx_pcm_trigger(chip, azx_dev, cmd);
224 
225         hstr = azx_stream(azx_dev);
226         if (chip->driver_caps & AZX_DCAPS_OLD_SSYNC)
227                 sync_reg = AZX_REG_OLD_SSYNC;
228         else
229                 sync_reg = AZX_REG_SSYNC;
230 
231         if (dsp_is_locked(azx_dev) || !hstr->prepared)
232                 return -EPIPE;
233 
234         switch (cmd) {
235         case SNDRV_PCM_TRIGGER_START:
236         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
237         case SNDRV_PCM_TRIGGER_RESUME:
238                 start = true;
239                 break;
240         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
241         case SNDRV_PCM_TRIGGER_SUSPEND:
242         case SNDRV_PCM_TRIGGER_STOP:
243                 start = false;
244                 break;
245         default:
246                 return -EINVAL;
247         }
248 
249         snd_pcm_group_for_each_entry(s, substream) {
250                 if (s->pcm->card != substream->pcm->card)
251                         continue;
252                 azx_dev = get_azx_dev(s);
253                 sbits |= 1 << azx_dev->core.index;
254                 snd_pcm_trigger_done(s, substream);
255         }
256 
257         spin_lock(&bus->reg_lock);
258 
259         /* first, set SYNC bits of corresponding streams */
260         snd_hdac_stream_sync_trigger(hstr, true, sbits, sync_reg);
261 
262         snd_pcm_group_for_each_entry(s, substream) {
263                 if (s->pcm->card != substream->pcm->card)
264                         continue;
265                 azx_dev = get_azx_dev(s);
266                 if (start) {
267                         azx_dev->insufficient = 1;
268                         snd_hdac_stream_start(azx_stream(azx_dev), true);
269                 } else {
270                         snd_hdac_stream_stop(azx_stream(azx_dev));
271                 }
272         }
273         spin_unlock(&bus->reg_lock);
274 
275         snd_hdac_stream_sync(hstr, start, sbits);
276 
277         spin_lock(&bus->reg_lock);
278         /* reset SYNC bits */
279         snd_hdac_stream_sync_trigger(hstr, false, sbits, sync_reg);
280         if (start)
281                 snd_hdac_stream_timecounter_init(hstr, sbits);
282         spin_unlock(&bus->reg_lock);
283         return 0;
284 }
285 
286 unsigned int azx_get_pos_lpib(struct azx *chip, struct azx_dev *azx_dev)
287 {
288         return snd_hdac_stream_get_pos_lpib(azx_stream(azx_dev));
289 }
290 EXPORT_SYMBOL_GPL(azx_get_pos_lpib);
291 
292 unsigned int azx_get_pos_posbuf(struct azx *chip, struct azx_dev *azx_dev)
293 {
294         return snd_hdac_stream_get_pos_posbuf(azx_stream(azx_dev));
295 }
296 EXPORT_SYMBOL_GPL(azx_get_pos_posbuf);
297 
298 unsigned int azx_get_position(struct azx *chip,
299                               struct azx_dev *azx_dev)
300 {
301         struct snd_pcm_substream *substream = azx_dev->core.substream;
302         unsigned int pos;
303         int stream = substream->stream;
304         int delay = 0;
305 
306         if (chip->get_position[stream])
307                 pos = chip->get_position[stream](chip, azx_dev);
308         else /* use the position buffer as default */
309                 pos = azx_get_pos_posbuf(chip, azx_dev);
310 
311         if (pos >= azx_dev->core.bufsize)
312                 pos = 0;
313 
314         if (substream->runtime) {
315                 struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
316                 struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
317 
318                 if (chip->get_delay[stream])
319                         delay += chip->get_delay[stream](chip, azx_dev, pos);
320                 if (hinfo->ops.get_delay)
321                         delay += hinfo->ops.get_delay(hinfo, apcm->codec,
322                                                       substream);
323                 substream->runtime->delay = delay;
324         }
325 
326         trace_azx_get_position(chip, azx_dev, pos, delay);
327         return pos;
328 }
329 EXPORT_SYMBOL_GPL(azx_get_position);
330 
331 static snd_pcm_uframes_t azx_pcm_pointer(struct snd_pcm_substream *substream)
332 {
333         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
334         struct azx *chip = apcm->chip;
335         struct azx_dev *azx_dev = get_azx_dev(substream);
336         return bytes_to_frames(substream->runtime,
337                                azx_get_position(chip, azx_dev));
338 }
339 
340 static int azx_get_time_info(struct snd_pcm_substream *substream,
341                         struct timespec *system_ts, struct timespec *audio_ts,
342                         struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
343                         struct snd_pcm_audio_tstamp_report *audio_tstamp_report)
344 {
345         struct azx_dev *azx_dev = get_azx_dev(substream);
346         u64 nsec;
347 
348         if ((substream->runtime->hw.info & SNDRV_PCM_INFO_HAS_LINK_ATIME) &&
349                 (audio_tstamp_config->type_requested == SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK)) {
350 
351                 snd_pcm_gettime(substream->runtime, system_ts);
352 
353                 nsec = timecounter_read(&azx_dev->core.tc);
354                 nsec = div_u64(nsec, 3); /* can be optimized */
355                 if (audio_tstamp_config->report_delay)
356                         nsec = azx_adjust_codec_delay(substream, nsec);
357 
358                 *audio_ts = ns_to_timespec(nsec);
359 
360                 audio_tstamp_report->actual_type = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK;
361                 audio_tstamp_report->accuracy_report = 1; /* rest of structure is valid */
362                 audio_tstamp_report->accuracy = 42; /* 24 MHz WallClock == 42ns resolution */
363 
364         } else
365                 audio_tstamp_report->actual_type = SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT;
366 
367         return 0;
368 }
369 
370 static struct snd_pcm_hardware azx_pcm_hw = {
371         .info =                 (SNDRV_PCM_INFO_MMAP |
372                                  SNDRV_PCM_INFO_INTERLEAVED |
373                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
374                                  SNDRV_PCM_INFO_MMAP_VALID |
375                                  /* No full-resume yet implemented */
376                                  /* SNDRV_PCM_INFO_RESUME |*/
377                                  SNDRV_PCM_INFO_PAUSE |
378                                  SNDRV_PCM_INFO_SYNC_START |
379                                  SNDRV_PCM_INFO_HAS_WALL_CLOCK | /* legacy */
380                                  SNDRV_PCM_INFO_HAS_LINK_ATIME |
381                                  SNDRV_PCM_INFO_NO_PERIOD_WAKEUP),
382         .formats =              SNDRV_PCM_FMTBIT_S16_LE,
383         .rates =                SNDRV_PCM_RATE_48000,
384         .rate_min =             48000,
385         .rate_max =             48000,
386         .channels_min =         2,
387         .channels_max =         2,
388         .buffer_bytes_max =     AZX_MAX_BUF_SIZE,
389         .period_bytes_min =     128,
390         .period_bytes_max =     AZX_MAX_BUF_SIZE / 2,
391         .periods_min =          2,
392         .periods_max =          AZX_MAX_FRAG,
393         .fifo_size =            0,
394 };
395 
396 static int azx_pcm_open(struct snd_pcm_substream *substream)
397 {
398         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
399         struct hda_pcm_stream *hinfo = to_hda_pcm_stream(substream);
400         struct azx *chip = apcm->chip;
401         struct azx_dev *azx_dev;
402         struct snd_pcm_runtime *runtime = substream->runtime;
403         int err;
404         int buff_step;
405 
406         snd_hda_codec_pcm_get(apcm->info);
407         mutex_lock(&chip->open_mutex);
408         azx_dev = azx_assign_device(chip, substream);
409         trace_azx_pcm_open(chip, azx_dev);
410         if (azx_dev == NULL) {
411                 err = -EBUSY;
412                 goto unlock;
413         }
414         runtime->private_data = azx_dev;
415         runtime->hw = azx_pcm_hw;
416         runtime->hw.channels_min = hinfo->channels_min;
417         runtime->hw.channels_max = hinfo->channels_max;
418         runtime->hw.formats = hinfo->formats;
419         runtime->hw.rates = hinfo->rates;
420         snd_pcm_limit_hw_rates(runtime);
421         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
422 
423         /* avoid wrap-around with wall-clock */
424         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_TIME,
425                                      20,
426                                      178000000);
427 
428         if (chip->align_buffer_size)
429                 /* constrain buffer sizes to be multiple of 128
430                    bytes. This is more efficient in terms of memory
431                    access but isn't required by the HDA spec and
432                    prevents users from specifying exact period/buffer
433                    sizes. For example for 44.1kHz, a period size set
434                    to 20ms will be rounded to 19.59ms. */
435                 buff_step = 128;
436         else
437                 /* Don't enforce steps on buffer sizes, still need to
438                    be multiple of 4 bytes (HDA spec). Tested on Intel
439                    HDA controllers, may not work on all devices where
440                    option needs to be disabled */
441                 buff_step = 4;
442 
443         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
444                                    buff_step);
445         snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
446                                    buff_step);
447         snd_hda_power_up(apcm->codec);
448         if (hinfo->ops.open)
449                 err = hinfo->ops.open(hinfo, apcm->codec, substream);
450         else
451                 err = -ENODEV;
452         if (err < 0) {
453                 azx_release_device(azx_dev);
454                 goto powerdown;
455         }
456         snd_pcm_limit_hw_rates(runtime);
457         /* sanity check */
458         if (snd_BUG_ON(!runtime->hw.channels_min) ||
459             snd_BUG_ON(!runtime->hw.channels_max) ||
460             snd_BUG_ON(!runtime->hw.formats) ||
461             snd_BUG_ON(!runtime->hw.rates)) {
462                 azx_release_device(azx_dev);
463                 if (hinfo->ops.close)
464                         hinfo->ops.close(hinfo, apcm->codec, substream);
465                 err = -EINVAL;
466                 goto powerdown;
467         }
468 
469         /* disable LINK_ATIME timestamps for capture streams
470            until we figure out how to handle digital inputs */
471         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
472                 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_WALL_CLOCK; /* legacy */
473                 runtime->hw.info &= ~SNDRV_PCM_INFO_HAS_LINK_ATIME;
474         }
475 
476         snd_pcm_set_sync(substream);
477         mutex_unlock(&chip->open_mutex);
478         return 0;
479 
480  powerdown:
481         snd_hda_power_down(apcm->codec);
482  unlock:
483         mutex_unlock(&chip->open_mutex);
484         snd_hda_codec_pcm_put(apcm->info);
485         return err;
486 }
487 
488 static int azx_pcm_mmap(struct snd_pcm_substream *substream,
489                         struct vm_area_struct *area)
490 {
491         struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
492         struct azx *chip = apcm->chip;
493         if (chip->ops->pcm_mmap_prepare)
494                 chip->ops->pcm_mmap_prepare(substream, area);
495         return snd_pcm_lib_default_mmap(substream, area);
496 }
497 
498 static struct snd_pcm_ops azx_pcm_ops = {
499         .open = azx_pcm_open,
500         .close = azx_pcm_close,
501         .ioctl = snd_pcm_lib_ioctl,
502         .hw_params = azx_pcm_hw_params,
503         .hw_free = azx_pcm_hw_free,
504         .prepare = azx_pcm_prepare,
505         .trigger = azx_pcm_trigger,
506         .pointer = azx_pcm_pointer,
507         .get_time_info =  azx_get_time_info,
508         .mmap = azx_pcm_mmap,
509         .page = snd_pcm_sgbuf_ops_page,
510 };
511 
512 static void azx_pcm_free(struct snd_pcm *pcm)
513 {
514         struct azx_pcm *apcm = pcm->private_data;
515         if (apcm) {
516                 list_del(&apcm->list);
517                 apcm->info->pcm = NULL;
518                 kfree(apcm);
519         }
520 }
521 
522 #define MAX_PREALLOC_SIZE       (32 * 1024 * 1024)
523 
524 int snd_hda_attach_pcm_stream(struct hda_bus *_bus, struct hda_codec *codec,
525                               struct hda_pcm *cpcm)
526 {
527         struct hdac_bus *bus = &_bus->core;
528         struct azx *chip = bus_to_azx(bus);
529         struct snd_pcm *pcm;
530         struct azx_pcm *apcm;
531         int pcm_dev = cpcm->device;
532         unsigned int size;
533         int s, err;
534 
535         list_for_each_entry(apcm, &chip->pcm_list, list) {
536                 if (apcm->pcm->device == pcm_dev) {
537                         dev_err(chip->card->dev, "PCM %d already exists\n",
538                                 pcm_dev);
539                         return -EBUSY;
540                 }
541         }
542         err = snd_pcm_new(chip->card, cpcm->name, pcm_dev,
543                           cpcm->stream[SNDRV_PCM_STREAM_PLAYBACK].substreams,
544                           cpcm->stream[SNDRV_PCM_STREAM_CAPTURE].substreams,
545                           &pcm);
546         if (err < 0)
547                 return err;
548         strlcpy(pcm->name, cpcm->name, sizeof(pcm->name));
549         apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
550         if (apcm == NULL)
551                 return -ENOMEM;
552         apcm->chip = chip;
553         apcm->pcm = pcm;
554         apcm->codec = codec;
555         apcm->info = cpcm;
556         pcm->private_data = apcm;
557         pcm->private_free = azx_pcm_free;
558         if (cpcm->pcm_type == HDA_PCM_TYPE_MODEM)
559                 pcm->dev_class = SNDRV_PCM_CLASS_MODEM;
560         list_add_tail(&apcm->list, &chip->pcm_list);
561         cpcm->pcm = pcm;
562         for (s = 0; s < 2; s++) {
563                 if (cpcm->stream[s].substreams)
564                         snd_pcm_set_ops(pcm, s, &azx_pcm_ops);
565         }
566         /* buffer pre-allocation */
567         size = CONFIG_SND_HDA_PREALLOC_SIZE * 1024;
568         if (size > MAX_PREALLOC_SIZE)
569                 size = MAX_PREALLOC_SIZE;
570         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
571                                               chip->card->dev,
572                                               size, MAX_PREALLOC_SIZE);
573         return 0;
574 }
575 
576 static unsigned int azx_command_addr(u32 cmd)
577 {
578         unsigned int addr = cmd >> 28;
579 
580         if (addr >= AZX_MAX_CODECS) {
581                 snd_BUG();
582                 addr = 0;
583         }
584 
585         return addr;
586 }
587 
588 /* receive a response */
589 static int azx_rirb_get_response(struct hdac_bus *bus, unsigned int addr,
590                                  unsigned int *res)
591 {
592         struct azx *chip = bus_to_azx(bus);
593         struct hda_bus *hbus = &chip->bus;
594         unsigned long timeout;
595         unsigned long loopcounter;
596         int do_poll = 0;
597 
598  again:
599         timeout = jiffies + msecs_to_jiffies(1000);
600 
601         for (loopcounter = 0;; loopcounter++) {
602                 spin_lock_irq(&bus->reg_lock);
603                 if (chip->polling_mode || do_poll)
604                         snd_hdac_bus_update_rirb(bus);
605                 if (!bus->rirb.cmds[addr]) {
606                         if (!do_poll)
607                                 chip->poll_count = 0;
608                         if (res)
609                                 *res = bus->rirb.res[addr]; /* the last value */
610                         spin_unlock_irq(&bus->reg_lock);
611                         return 0;
612                 }
613                 spin_unlock_irq(&bus->reg_lock);
614                 if (time_after(jiffies, timeout))
615                         break;
616                 if (hbus->needs_damn_long_delay || loopcounter > 3000)
617                         msleep(2); /* temporary workaround */
618                 else {
619                         udelay(10);
620                         cond_resched();
621                 }
622         }
623 
624         if (hbus->no_response_fallback)
625                 return -EIO;
626 
627         if (!chip->polling_mode && chip->poll_count < 2) {
628                 dev_dbg(chip->card->dev,
629                         "azx_get_response timeout, polling the codec once: last cmd=0x%08x\n",
630                         bus->last_cmd[addr]);
631                 do_poll = 1;
632                 chip->poll_count++;
633                 goto again;
634         }
635 
636 
637         if (!chip->polling_mode) {
638                 dev_warn(chip->card->dev,
639                          "azx_get_response timeout, switching to polling mode: last cmd=0x%08x\n",
640                          bus->last_cmd[addr]);
641                 chip->polling_mode = 1;
642                 goto again;
643         }
644 
645         if (chip->msi) {
646                 dev_warn(chip->card->dev,
647                          "No response from codec, disabling MSI: last cmd=0x%08x\n",
648                          bus->last_cmd[addr]);
649                 if (chip->ops->disable_msi_reset_irq &&
650                     chip->ops->disable_msi_reset_irq(chip) < 0)
651                         return -EIO;
652                 goto again;
653         }
654 
655         if (chip->probing) {
656                 /* If this critical timeout happens during the codec probing
657                  * phase, this is likely an access to a non-existing codec
658                  * slot.  Better to return an error and reset the system.
659                  */
660                 return -EIO;
661         }
662 
663         /* a fatal communication error; need either to reset or to fallback
664          * to the single_cmd mode
665          */
666         if (hbus->allow_bus_reset && !hbus->response_reset && !hbus->in_reset) {
667                 hbus->response_reset = 1;
668                 return -EAGAIN; /* give a chance to retry */
669         }
670 
671         dev_err(chip->card->dev,
672                 "azx_get_response timeout, switching to single_cmd mode: last cmd=0x%08x\n",
673                 bus->last_cmd[addr]);
674         chip->single_cmd = 1;
675         hbus->response_reset = 0;
676         snd_hdac_bus_stop_cmd_io(bus);
677         return -EIO;
678 }
679 
680 /*
681  * Use the single immediate command instead of CORB/RIRB for simplicity
682  *
683  * Note: according to Intel, this is not preferred use.  The command was
684  *       intended for the BIOS only, and may get confused with unsolicited
685  *       responses.  So, we shouldn't use it for normal operation from the
686  *       driver.
687  *       I left the codes, however, for debugging/testing purposes.
688  */
689 
690 /* receive a response */
691 static int azx_single_wait_for_response(struct azx *chip, unsigned int addr)
692 {
693         int timeout = 50;
694 
695         while (timeout--) {
696                 /* check IRV busy bit */
697                 if (azx_readw(chip, IRS) & AZX_IRS_VALID) {
698                         /* reuse rirb.res as the response return value */
699                         azx_bus(chip)->rirb.res[addr] = azx_readl(chip, IR);
700                         return 0;
701                 }
702                 udelay(1);
703         }
704         if (printk_ratelimit())
705                 dev_dbg(chip->card->dev, "get_response timeout: IRS=0x%x\n",
706                         azx_readw(chip, IRS));
707         azx_bus(chip)->rirb.res[addr] = -1;
708         return -EIO;
709 }
710 
711 /* send a command */
712 static int azx_single_send_cmd(struct hdac_bus *bus, u32 val)
713 {
714         struct azx *chip = bus_to_azx(bus);
715         unsigned int addr = azx_command_addr(val);
716         int timeout = 50;
717 
718         bus->last_cmd[azx_command_addr(val)] = val;
719         while (timeout--) {
720                 /* check ICB busy bit */
721                 if (!((azx_readw(chip, IRS) & AZX_IRS_BUSY))) {
722                         /* Clear IRV valid bit */
723                         azx_writew(chip, IRS, azx_readw(chip, IRS) |
724                                    AZX_IRS_VALID);
725                         azx_writel(chip, IC, val);
726                         azx_writew(chip, IRS, azx_readw(chip, IRS) |
727                                    AZX_IRS_BUSY);
728                         return azx_single_wait_for_response(chip, addr);
729                 }
730                 udelay(1);
731         }
732         if (printk_ratelimit())
733                 dev_dbg(chip->card->dev,
734                         "send_cmd timeout: IRS=0x%x, val=0x%x\n",
735                         azx_readw(chip, IRS), val);
736         return -EIO;
737 }
738 
739 /* receive a response */
740 static int azx_single_get_response(struct hdac_bus *bus, unsigned int addr,
741                                    unsigned int *res)
742 {
743         if (res)
744                 *res = bus->rirb.res[addr];
745         return 0;
746 }
747 
748 /*
749  * The below are the main callbacks from hda_codec.
750  *
751  * They are just the skeleton to call sub-callbacks according to the
752  * current setting of chip->single_cmd.
753  */
754 
755 /* send a command */
756 static int azx_send_cmd(struct hdac_bus *bus, unsigned int val)
757 {
758         struct azx *chip = bus_to_azx(bus);
759 
760         if (chip->disabled)
761                 return 0;
762         if (chip->single_cmd)
763                 return azx_single_send_cmd(bus, val);
764         else
765                 return snd_hdac_bus_send_cmd(bus, val);
766 }
767 
768 /* get a response */
769 static int azx_get_response(struct hdac_bus *bus, unsigned int addr,
770                             unsigned int *res)
771 {
772         struct azx *chip = bus_to_azx(bus);
773 
774         if (chip->disabled)
775                 return 0;
776         if (chip->single_cmd)
777                 return azx_single_get_response(bus, addr, res);
778         else
779                 return azx_rirb_get_response(bus, addr, res);
780 }
781 
782 static int azx_link_power(struct hdac_bus *bus, bool enable)
783 {
784         struct azx *chip = bus_to_azx(bus);
785 
786         if (chip->ops->link_power)
787                 return chip->ops->link_power(chip, enable);
788         else
789                 return -EINVAL;
790 }
791 
792 static const struct hdac_bus_ops bus_core_ops = {
793         .command = azx_send_cmd,
794         .get_response = azx_get_response,
795         .link_power = azx_link_power,
796 };
797 
798 #ifdef CONFIG_SND_HDA_DSP_LOADER
799 /*
800  * DSP loading code (e.g. for CA0132)
801  */
802 
803 /* use the first stream for loading DSP */
804 static struct azx_dev *
805 azx_get_dsp_loader_dev(struct azx *chip)
806 {
807         struct hdac_bus *bus = azx_bus(chip);
808         struct hdac_stream *s;
809 
810         list_for_each_entry(s, &bus->stream_list, list)
811                 if (s->index == chip->playback_index_offset)
812                         return stream_to_azx_dev(s);
813 
814         return NULL;
815 }
816 
817 int snd_hda_codec_load_dsp_prepare(struct hda_codec *codec, unsigned int format,
818                                    unsigned int byte_size,
819                                    struct snd_dma_buffer *bufp)
820 {
821         struct hdac_bus *bus = &codec->bus->core;
822         struct azx *chip = bus_to_azx(bus);
823         struct azx_dev *azx_dev;
824         struct hdac_stream *hstr;
825         bool saved = false;
826         int err;
827 
828         azx_dev = azx_get_dsp_loader_dev(chip);
829         hstr = azx_stream(azx_dev);
830         spin_lock_irq(&bus->reg_lock);
831         if (hstr->opened) {
832                 chip->saved_azx_dev = *azx_dev;
833                 saved = true;
834         }
835         spin_unlock_irq(&bus->reg_lock);
836 
837         err = snd_hdac_dsp_prepare(hstr, format, byte_size, bufp);
838         if (err < 0) {
839                 spin_lock_irq(&bus->reg_lock);
840                 if (saved)
841                         *azx_dev = chip->saved_azx_dev;
842                 spin_unlock_irq(&bus->reg_lock);
843                 return err;
844         }
845 
846         hstr->prepared = 0;
847         return err;
848 }
849 EXPORT_SYMBOL_GPL(snd_hda_codec_load_dsp_prepare);
850 
851 void snd_hda_codec_load_dsp_trigger(struct hda_codec *codec, bool start)
852 {
853         struct hdac_bus *bus = &codec->bus->core;
854         struct azx *chip = bus_to_azx(bus);
855         struct azx_dev *azx_dev = azx_get_dsp_loader_dev(chip);
856 
857         snd_hdac_dsp_trigger(azx_stream(azx_dev), start);
858 }
859 EXPORT_SYMBOL_GPL(snd_hda_codec_load_dsp_trigger);
860 
861 void snd_hda_codec_load_dsp_cleanup(struct hda_codec *codec,
862                                     struct snd_dma_buffer *dmab)
863 {
864         struct hdac_bus *bus = &codec->bus->core;
865         struct azx *chip = bus_to_azx(bus);
866         struct azx_dev *azx_dev = azx_get_dsp_loader_dev(chip);
867         struct hdac_stream *hstr = azx_stream(azx_dev);
868 
869         if (!dmab->area || !hstr->locked)
870                 return;
871 
872         snd_hdac_dsp_cleanup(hstr, dmab);
873         spin_lock_irq(&bus->reg_lock);
874         if (hstr->opened)
875                 *azx_dev = chip->saved_azx_dev;
876         hstr->locked = false;
877         spin_unlock_irq(&bus->reg_lock);
878 }
879 EXPORT_SYMBOL_GPL(snd_hda_codec_load_dsp_cleanup);
880 #endif /* CONFIG_SND_HDA_DSP_LOADER */
881 
882 /*
883  * reset and start the controller registers
884  */
885 void azx_init_chip(struct azx *chip, bool full_reset)
886 {
887         if (snd_hdac_bus_init_chip(azx_bus(chip), full_reset)) {
888                 /* correct RINTCNT for CXT */
889                 if (chip->driver_caps & AZX_DCAPS_CTX_WORKAROUND)
890                         azx_writew(chip, RINTCNT, 0xc0);
891         }
892 }
893 EXPORT_SYMBOL_GPL(azx_init_chip);
894 
895 void azx_stop_all_streams(struct azx *chip)
896 {
897         struct hdac_bus *bus = azx_bus(chip);
898         struct hdac_stream *s;
899 
900         list_for_each_entry(s, &bus->stream_list, list)
901                 snd_hdac_stream_stop(s);
902 }
903 EXPORT_SYMBOL_GPL(azx_stop_all_streams);
904 
905 void azx_stop_chip(struct azx *chip)
906 {
907         snd_hdac_bus_stop_chip(azx_bus(chip));
908 }
909 EXPORT_SYMBOL_GPL(azx_stop_chip);
910 
911 /*
912  * interrupt handler
913  */
914 static void stream_update(struct hdac_bus *bus, struct hdac_stream *s)
915 {
916         struct azx *chip = bus_to_azx(bus);
917         struct azx_dev *azx_dev = stream_to_azx_dev(s);
918 
919         /* check whether this IRQ is really acceptable */
920         if (!chip->ops->position_check ||
921             chip->ops->position_check(chip, azx_dev)) {
922                 spin_unlock(&bus->reg_lock);
923                 snd_pcm_period_elapsed(azx_stream(azx_dev)->substream);
924                 spin_lock(&bus->reg_lock);
925         }
926 }
927 
928 irqreturn_t azx_interrupt(int irq, void *dev_id)
929 {
930         struct azx *chip = dev_id;
931         struct hdac_bus *bus = azx_bus(chip);
932         u32 status;
933 
934 #ifdef CONFIG_PM
935         if (azx_has_pm_runtime(chip))
936                 if (!pm_runtime_active(chip->card->dev))
937                         return IRQ_NONE;
938 #endif
939 
940         spin_lock(&bus->reg_lock);
941 
942         if (chip->disabled) {
943                 spin_unlock(&bus->reg_lock);
944                 return IRQ_NONE;
945         }
946 
947         status = azx_readl(chip, INTSTS);
948         if (status == 0 || status == 0xffffffff) {
949                 spin_unlock(&bus->reg_lock);
950                 return IRQ_NONE;
951         }
952 
953         snd_hdac_bus_handle_stream_irq(bus, status, stream_update);
954 
955         /* clear rirb int */
956         status = azx_readb(chip, RIRBSTS);
957         if (status & RIRB_INT_MASK) {
958                 if (status & RIRB_INT_RESPONSE) {
959                         if (chip->driver_caps & AZX_DCAPS_RIRB_PRE_DELAY)
960                                 udelay(80);
961                         snd_hdac_bus_update_rirb(bus);
962                 }
963                 azx_writeb(chip, RIRBSTS, RIRB_INT_MASK);
964         }
965 
966         spin_unlock(&bus->reg_lock);
967 
968         return IRQ_HANDLED;
969 }
970 EXPORT_SYMBOL_GPL(azx_interrupt);
971 
972 /*
973  * Codec initerface
974  */
975 
976 /*
977  * Probe the given codec address
978  */
979 static int probe_codec(struct azx *chip, int addr)
980 {
981         unsigned int cmd = (addr << 28) | (AC_NODE_ROOT << 20) |
982                 (AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
983         struct hdac_bus *bus = azx_bus(chip);
984         int err;
985         unsigned int res = -1;
986 
987         mutex_lock(&bus->cmd_mutex);
988         chip->probing = 1;
989         azx_send_cmd(bus, cmd);
990         err = azx_get_response(bus, addr, &res);
991         chip->probing = 0;
992         mutex_unlock(&bus->cmd_mutex);
993         if (err < 0 || res == -1)
994                 return -EIO;
995         dev_dbg(chip->card->dev, "codec #%d probed OK\n", addr);
996         return 0;
997 }
998 
999 void snd_hda_bus_reset(struct hda_bus *bus)
1000 {
1001         struct azx *chip = bus_to_azx(&bus->core);
1002 
1003         bus->in_reset = 1;
1004         azx_stop_chip(chip);
1005         azx_init_chip(chip, true);
1006         if (bus->core.chip_init)
1007                 snd_hda_bus_reset_codecs(bus);
1008         bus->in_reset = 0;
1009 }
1010 
1011 static int get_jackpoll_interval(struct azx *chip)
1012 {
1013         int i;
1014         unsigned int j;
1015 
1016         if (!chip->jackpoll_ms)
1017                 return 0;
1018 
1019         i = chip->jackpoll_ms[chip->dev_index];
1020         if (i == 0)
1021                 return 0;
1022         if (i < 50 || i > 60000)
1023                 j = 0;
1024         else
1025                 j = msecs_to_jiffies(i);
1026         if (j == 0)
1027                 dev_warn(chip->card->dev,
1028                          "jackpoll_ms value out of range: %d\n", i);
1029         return j;
1030 }
1031 
1032 /* HD-audio bus initialization */
1033 int azx_bus_init(struct azx *chip, const char *model,
1034                  const struct hdac_io_ops *io_ops)
1035 {
1036         struct hda_bus *bus = &chip->bus;
1037         int err;
1038 
1039         err = snd_hdac_bus_init(&bus->core, chip->card->dev, &bus_core_ops,
1040                                 io_ops);
1041         if (err < 0)
1042                 return err;
1043 
1044         bus->card = chip->card;
1045         mutex_init(&bus->prepare_mutex);
1046         bus->pci = chip->pci;
1047         bus->modelname = model;
1048         bus->core.snoop = azx_snoop(chip);
1049         if (chip->get_position[0] != azx_get_pos_lpib ||
1050             chip->get_position[1] != azx_get_pos_lpib)
1051                 bus->core.use_posbuf = true;
1052         if (chip->bdl_pos_adj)
1053                 bus->core.bdl_pos_adj = chip->bdl_pos_adj[chip->dev_index];
1054         if (chip->driver_caps & AZX_DCAPS_CORBRP_SELF_CLEAR)
1055                 bus->core.corbrp_self_clear = true;
1056 
1057         if (chip->driver_caps & AZX_DCAPS_RIRB_DELAY) {
1058                 dev_dbg(chip->card->dev, "Enable delay in RIRB handling\n");
1059                 bus->needs_damn_long_delay = 1;
1060         }
1061 
1062         /* AMD chipsets often cause the communication stalls upon certain
1063          * sequence like the pin-detection.  It seems that forcing the synced
1064          * access works around the stall.  Grrr...
1065          */
1066         if (chip->driver_caps & AZX_DCAPS_SYNC_WRITE) {
1067                 dev_dbg(chip->card->dev, "Enable sync_write for stable communication\n");
1068                 bus->core.sync_write = 1;
1069                 bus->allow_bus_reset = 1;
1070         }
1071 
1072         return 0;
1073 }
1074 EXPORT_SYMBOL_GPL(azx_bus_init);
1075 
1076 /* Probe codecs */
1077 int azx_probe_codecs(struct azx *chip, unsigned int max_slots)
1078 {
1079         struct hdac_bus *bus = azx_bus(chip);
1080         int c, codecs, err;
1081 
1082         codecs = 0;
1083         if (!max_slots)
1084                 max_slots = AZX_DEFAULT_CODECS;
1085 
1086         /* First try to probe all given codec slots */
1087         for (c = 0; c < max_slots; c++) {
1088                 if ((bus->codec_mask & (1 << c)) & chip->codec_probe_mask) {
1089                         if (probe_codec(chip, c) < 0) {
1090                                 /* Some BIOSen give you wrong codec addresses
1091                                  * that don't exist
1092                                  */
1093                                 dev_warn(chip->card->dev,
1094                                          "Codec #%d probe error; disabling it...\n", c);
1095                                 bus->codec_mask &= ~(1 << c);
1096                                 /* More badly, accessing to a non-existing
1097                                  * codec often screws up the controller chip,
1098                                  * and disturbs the further communications.
1099                                  * Thus if an error occurs during probing,
1100                                  * better to reset the controller chip to
1101                                  * get back to the sanity state.
1102                                  */
1103                                 azx_stop_chip(chip);
1104                                 azx_init_chip(chip, true);
1105                         }
1106                 }
1107         }
1108 
1109         /* Then create codec instances */
1110         for (c = 0; c < max_slots; c++) {
1111                 if ((bus->codec_mask & (1 << c)) & chip->codec_probe_mask) {
1112                         struct hda_codec *codec;
1113                         err = snd_hda_codec_new(&chip->bus, chip->card, c, &codec);
1114                         if (err < 0)
1115                                 continue;
1116                         codec->jackpoll_interval = get_jackpoll_interval(chip);
1117                         codec->beep_mode = chip->beep_mode;
1118                         codecs++;
1119                 }
1120         }
1121         if (!codecs) {
1122                 dev_err(chip->card->dev, "no codecs initialized\n");
1123                 return -ENXIO;
1124         }
1125         return 0;
1126 }
1127 EXPORT_SYMBOL_GPL(azx_probe_codecs);
1128 
1129 /* configure each codec instance */
1130 int azx_codec_configure(struct azx *chip)
1131 {
1132         struct hda_codec *codec;
1133         list_for_each_codec(codec, &chip->bus) {
1134                 snd_hda_codec_configure(codec);
1135         }
1136         return 0;
1137 }
1138 EXPORT_SYMBOL_GPL(azx_codec_configure);
1139 
1140 static int stream_direction(struct azx *chip, unsigned char index)
1141 {
1142         if (index >= chip->capture_index_offset &&
1143             index < chip->capture_index_offset + chip->capture_streams)
1144                 return SNDRV_PCM_STREAM_CAPTURE;
1145         return SNDRV_PCM_STREAM_PLAYBACK;
1146 }
1147 
1148 /* initialize SD streams */
1149 int azx_init_streams(struct azx *chip)
1150 {
1151         int i;
1152         int stream_tags[2] = { 0, 0 };
1153 
1154         /* initialize each stream (aka device)
1155          * assign the starting bdl address to each stream (device)
1156          * and initialize
1157          */
1158         for (i = 0; i < chip->num_streams; i++) {
1159                 struct azx_dev *azx_dev = kzalloc(sizeof(*azx_dev), GFP_KERNEL);
1160                 int dir, tag;
1161 
1162                 if (!azx_dev)
1163                         return -ENOMEM;
1164 
1165                 dir = stream_direction(chip, i);
1166                 /* stream tag must be unique throughout
1167                  * the stream direction group,
1168                  * valid values 1...15
1169                  * use separate stream tag if the flag
1170                  * AZX_DCAPS_SEPARATE_STREAM_TAG is used
1171                  */
1172                 if (chip->driver_caps & AZX_DCAPS_SEPARATE_STREAM_TAG)
1173                         tag = ++stream_tags[dir];
1174                 else
1175                         tag = i + 1;
1176                 snd_hdac_stream_init(azx_bus(chip), azx_stream(azx_dev),
1177                                      i, dir, tag);
1178         }
1179 
1180         return 0;
1181 }
1182 EXPORT_SYMBOL_GPL(azx_init_streams);
1183 
1184 void azx_free_streams(struct azx *chip)
1185 {
1186         struct hdac_bus *bus = azx_bus(chip);
1187         struct hdac_stream *s;
1188 
1189         while (!list_empty(&bus->stream_list)) {
1190                 s = list_first_entry(&bus->stream_list, struct hdac_stream, list);
1191                 list_del(&s->list);
1192                 kfree(stream_to_azx_dev(s));
1193         }
1194 }
1195 EXPORT_SYMBOL_GPL(azx_free_streams);
1196 

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