2 * hdac_hdmi.c - ASoc HDA-HDMI codec driver for Intel platforms
4 * Copyright (C) 2014-2015 Intel Corp
5 * Author: Samreen Nilofer <samreen.nilofer@intel.com>
6 * Subhransu S. Prusty <subhransu.s.prusty@intel.com>
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; version 2 of the License.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
20 #include <linux/init.h>
21 #include <linux/delay.h>
22 #include <linux/module.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/hdmi.h>
25 #include <sound/pcm_params.h>
26 #include <sound/soc.h>
27 #include <sound/hdaudio_ext.h>
28 #include <sound/hda_i915.h>
29 #include "../../hda/local.h"
31 #define AMP_OUT_MUTE 0xb080
32 #define AMP_OUT_UNMUTE 0xb000
33 #define PIN_OUT (AC_PINCTL_OUT_EN)
35 #define HDA_MAX_CONNECTIONS 32
37 struct hdac_hdmi_cvt_params
{
38 unsigned int channels_min
;
39 unsigned int channels_max
;
45 struct hdac_hdmi_cvt
{
46 struct list_head head
;
48 struct hdac_hdmi_cvt_params params
;
51 struct hdac_hdmi_pin
{
52 struct list_head head
;
55 hda_nid_t mux_nids
[HDA_MAX_CONNECTIONS
];
58 struct hdac_hdmi_dai_pin_map
{
60 struct hdac_hdmi_pin
*pin
;
61 struct hdac_hdmi_cvt
*cvt
;
64 struct hdac_hdmi_priv
{
65 struct hdac_hdmi_dai_pin_map dai_map
[3];
66 struct list_head pin_list
;
67 struct list_head cvt_list
;
72 static inline struct hdac_ext_device
*to_hda_ext_device(struct device
*dev
)
74 struct hdac_device
*hdac
= dev_to_hdac_dev(dev
);
76 return to_ehdac_device(hdac
);
79 static int hdac_hdmi_setup_stream(struct hdac_ext_device
*hdac
,
80 hda_nid_t cvt_nid
, hda_nid_t pin_nid
,
81 u32 stream_tag
, int format
)
85 dev_dbg(&hdac
->hdac
.dev
, "cvt nid %d pnid %d stream %d format 0x%x\n",
86 cvt_nid
, pin_nid
, stream_tag
, format
);
88 val
= (stream_tag
<< 4);
90 snd_hdac_codec_write(&hdac
->hdac
, cvt_nid
, 0,
91 AC_VERB_SET_CHANNEL_STREAMID
, val
);
92 snd_hdac_codec_write(&hdac
->hdac
, cvt_nid
, 0,
93 AC_VERB_SET_STREAM_FORMAT
, format
);
99 hdac_hdmi_set_dip_index(struct hdac_ext_device
*hdac
, hda_nid_t pin_nid
,
100 int packet_index
, int byte_index
)
104 val
= (packet_index
<< 5) | (byte_index
& 0x1f);
106 snd_hdac_codec_write(&hdac
->hdac
, pin_nid
, 0,
107 AC_VERB_SET_HDMI_DIP_INDEX
, val
);
110 static int hdac_hdmi_setup_audio_infoframe(struct hdac_ext_device
*hdac
,
111 hda_nid_t cvt_nid
, hda_nid_t pin_nid
)
113 uint8_t buffer
[HDMI_INFOFRAME_HEADER_SIZE
+ HDMI_AUDIO_INFOFRAME_SIZE
];
114 struct hdmi_audio_infoframe frame
;
115 u8
*dip
= (u8
*)&frame
;
119 hdmi_audio_infoframe_init(&frame
);
121 /* Default stereo for now */
124 /* setup channel count */
125 snd_hdac_codec_write(&hdac
->hdac
, cvt_nid
, 0,
126 AC_VERB_SET_CVT_CHAN_COUNT
, frame
.channels
- 1);
128 ret
= hdmi_audio_infoframe_pack(&frame
, buffer
, sizeof(buffer
));
132 /* stop infoframe transmission */
133 hdac_hdmi_set_dip_index(hdac
, pin_nid
, 0x0, 0x0);
134 snd_hdac_codec_write(&hdac
->hdac
, pin_nid
, 0,
135 AC_VERB_SET_HDMI_DIP_XMIT
, AC_DIPXMIT_DISABLE
);
138 /* Fill infoframe. Index auto-incremented */
139 hdac_hdmi_set_dip_index(hdac
, pin_nid
, 0x0, 0x0);
140 for (i
= 0; i
< sizeof(frame
); i
++)
141 snd_hdac_codec_write(&hdac
->hdac
, pin_nid
, 0,
142 AC_VERB_SET_HDMI_DIP_DATA
, dip
[i
]);
144 /* Start infoframe */
145 hdac_hdmi_set_dip_index(hdac
, pin_nid
, 0x0, 0x0);
146 snd_hdac_codec_write(&hdac
->hdac
, pin_nid
, 0,
147 AC_VERB_SET_HDMI_DIP_XMIT
, AC_DIPXMIT_BEST
);
152 static void hdac_hdmi_set_power_state(struct hdac_ext_device
*edev
,
153 struct hdac_hdmi_dai_pin_map
*dai_map
, unsigned int pwr_state
)
155 /* Power up pin widget */
156 if (!snd_hdac_check_power_state(&edev
->hdac
, dai_map
->pin
->nid
,
158 snd_hdac_codec_write(&edev
->hdac
, dai_map
->pin
->nid
, 0,
159 AC_VERB_SET_POWER_STATE
, pwr_state
);
161 /* Power up converter */
162 if (!snd_hdac_check_power_state(&edev
->hdac
, dai_map
->cvt
->nid
,
164 snd_hdac_codec_write(&edev
->hdac
, dai_map
->cvt
->nid
, 0,
165 AC_VERB_SET_POWER_STATE
, pwr_state
);
168 static int hdac_hdmi_playback_prepare(struct snd_pcm_substream
*substream
,
169 struct snd_soc_dai
*dai
)
171 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
172 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
173 struct hdac_hdmi_dai_pin_map
*dai_map
;
174 struct hdac_ext_dma_params
*dd
;
178 dev_err(&hdac
->hdac
.dev
, "Only one dai supported as of now\n");
182 dai_map
= &hdmi
->dai_map
[dai
->id
];
184 dd
= (struct hdac_ext_dma_params
*)snd_soc_dai_get_dma_data(dai
, substream
);
185 dev_dbg(&hdac
->hdac
.dev
, "stream tag from cpu dai %d format in cvt 0x%x\n",
186 dd
->stream_tag
, dd
->format
);
188 ret
= hdac_hdmi_setup_audio_infoframe(hdac
, dai_map
->cvt
->nid
,
193 return hdac_hdmi_setup_stream(hdac
, dai_map
->cvt
->nid
,
194 dai_map
->pin
->nid
, dd
->stream_tag
, dd
->format
);
197 static int hdac_hdmi_set_hw_params(struct snd_pcm_substream
*substream
,
198 struct snd_pcm_hw_params
*hparams
, struct snd_soc_dai
*dai
)
200 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
201 struct hdac_ext_dma_params
*dd
;
204 dev_err(&hdac
->hdac
.dev
, "Only one dai supported as of now\n");
208 dd
= kzalloc(sizeof(*dd
), GFP_KERNEL
);
211 dd
->format
= snd_hdac_calc_stream_format(params_rate(hparams
),
212 params_channels(hparams
), params_format(hparams
),
215 snd_soc_dai_set_dma_data(dai
, substream
, (void *)dd
);
220 static int hdac_hdmi_playback_cleanup(struct snd_pcm_substream
*substream
,
221 struct snd_soc_dai
*dai
)
223 struct hdac_ext_device
*edev
= snd_soc_dai_get_drvdata(dai
);
224 struct hdac_ext_dma_params
*dd
;
225 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
226 struct hdac_hdmi_dai_pin_map
*dai_map
;
228 dai_map
= &hdmi
->dai_map
[dai
->id
];
230 snd_hdac_codec_write(&edev
->hdac
, dai_map
->cvt
->nid
, 0,
231 AC_VERB_SET_CHANNEL_STREAMID
, 0);
232 snd_hdac_codec_write(&edev
->hdac
, dai_map
->cvt
->nid
, 0,
233 AC_VERB_SET_STREAM_FORMAT
, 0);
235 dd
= (struct hdac_ext_dma_params
*)snd_soc_dai_get_dma_data(dai
, substream
);
236 snd_soc_dai_set_dma_data(dai
, substream
, NULL
);
243 static int hdac_hdmi_pcm_open(struct snd_pcm_substream
*substream
,
244 struct snd_soc_dai
*dai
)
246 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
247 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
248 struct hdac_hdmi_dai_pin_map
*dai_map
;
252 dev_err(&hdac
->hdac
.dev
, "Only one dai supported as of now\n");
256 dai_map
= &hdmi
->dai_map
[dai
->id
];
258 val
= snd_hdac_codec_read(&hdac
->hdac
, dai_map
->pin
->nid
, 0,
259 AC_VERB_GET_PIN_SENSE
, 0);
260 dev_info(&hdac
->hdac
.dev
, "Val for AC_VERB_GET_PIN_SENSE: %x\n", val
);
262 if ((!(val
& AC_PINSENSE_PRESENCE
)) || (!(val
& AC_PINSENSE_ELDV
))) {
263 dev_err(&hdac
->hdac
.dev
, "Monitor presence invalid with val: %x\n", val
);
267 hdac_hdmi_set_power_state(hdac
, dai_map
, AC_PWRST_D0
);
269 snd_hdac_codec_write(&hdac
->hdac
, dai_map
->pin
->nid
, 0,
270 AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
);
272 snd_pcm_hw_constraint_step(substream
->runtime
, 0,
273 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
278 static void hdac_hdmi_pcm_close(struct snd_pcm_substream
*substream
,
279 struct snd_soc_dai
*dai
)
281 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
282 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
283 struct hdac_hdmi_dai_pin_map
*dai_map
;
285 dai_map
= &hdmi
->dai_map
[dai
->id
];
287 hdac_hdmi_set_power_state(hdac
, dai_map
, AC_PWRST_D3
);
289 snd_hdac_codec_write(&hdac
->hdac
, dai_map
->pin
->nid
, 0,
290 AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
);
294 hdac_hdmi_query_cvt_params(struct hdac_device
*hdac
, struct hdac_hdmi_cvt
*cvt
)
298 /* Only stereo supported as of now */
299 cvt
->params
.channels_min
= cvt
->params
.channels_max
= 2;
301 err
= snd_hdac_query_supported_pcm(hdac
, cvt
->nid
,
303 &cvt
->params
.formats
,
304 &cvt
->params
.maxbps
);
307 "Failed to query pcm params for nid %d: %d\n",
313 static void hdac_hdmi_fill_widget_info(struct snd_soc_dapm_widget
*w
,
314 enum snd_soc_dapm_type id
,
315 const char *wname
, const char *stream
)
320 w
->reg
= SND_SOC_NOPM
;
322 w
->kcontrol_news
= NULL
;
323 w
->num_kcontrols
= 0;
327 static void hdac_hdmi_fill_route(struct snd_soc_dapm_route
*route
,
328 const char *sink
, const char *control
, const char *src
)
332 route
->control
= control
;
333 route
->connected
= NULL
;
336 static void create_fill_widget_route_map(struct snd_soc_dapm_context
*dapm
,
337 struct hdac_hdmi_dai_pin_map
*dai_map
)
339 struct snd_soc_dapm_route route
[1];
340 struct snd_soc_dapm_widget widgets
[2] = { {0} };
342 memset(&route
, 0, sizeof(route
));
344 hdac_hdmi_fill_widget_info(&widgets
[0], snd_soc_dapm_output
,
345 "hif1 Output", NULL
);
346 hdac_hdmi_fill_widget_info(&widgets
[1], snd_soc_dapm_aif_in
,
347 "Coverter 1", "hif1");
349 hdac_hdmi_fill_route(&route
[0], "hif1 Output", NULL
, "Coverter 1");
351 snd_soc_dapm_new_controls(dapm
, widgets
, ARRAY_SIZE(widgets
));
352 snd_soc_dapm_add_routes(dapm
, route
, ARRAY_SIZE(route
));
355 static int hdac_hdmi_init_dai_map(struct hdac_ext_device
*edev
)
357 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
358 struct hdac_hdmi_dai_pin_map
*dai_map
= &hdmi
->dai_map
[0];
359 struct hdac_hdmi_cvt
*cvt
;
360 struct hdac_hdmi_pin
*pin
;
362 if (list_empty(&hdmi
->cvt_list
) || list_empty(&hdmi
->pin_list
))
366 * Currently on board only 1 pin and 1 converter is enabled for
367 * simplification, more will be added eventually
368 * So using fixed map for dai_id:pin:cvt
370 cvt
= list_first_entry(&hdmi
->cvt_list
, struct hdac_hdmi_cvt
, head
);
371 pin
= list_first_entry(&hdmi
->pin_list
, struct hdac_hdmi_pin
, head
);
378 /* Enable out path for this pin widget */
379 snd_hdac_codec_write(&edev
->hdac
, pin
->nid
, 0,
380 AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
);
382 /* Enable transmission */
383 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
384 AC_VERB_SET_DIGI_CONVERT_1
, 1);
386 /* Category Code (CC) to zero */
387 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
388 AC_VERB_SET_DIGI_CONVERT_2
, 0);
390 snd_hdac_codec_write(&edev
->hdac
, pin
->nid
, 0,
391 AC_VERB_SET_CONNECT_SEL
, 0);
396 static int hdac_hdmi_add_cvt(struct hdac_ext_device
*edev
, hda_nid_t nid
)
398 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
399 struct hdac_hdmi_cvt
*cvt
;
401 cvt
= kzalloc(sizeof(*cvt
), GFP_KERNEL
);
407 list_add_tail(&cvt
->head
, &hdmi
->cvt_list
);
410 return hdac_hdmi_query_cvt_params(&edev
->hdac
, cvt
);
413 static int hdac_hdmi_add_pin(struct hdac_ext_device
*edev
, hda_nid_t nid
)
415 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
416 struct hdac_hdmi_pin
*pin
;
418 pin
= kzalloc(sizeof(*pin
), GFP_KERNEL
);
424 list_add_tail(&pin
->head
, &hdmi
->pin_list
);
431 * Parse all nodes and store the cvt/pin nids in array
432 * Add one time initialization for pin and cvt widgets
434 static int hdac_hdmi_parse_and_map_nid(struct hdac_ext_device
*edev
)
438 struct hdac_device
*hdac
= &edev
->hdac
;
439 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
442 num_nodes
= snd_hdac_get_sub_nodes(hdac
, hdac
->afg
, &nid
);
443 if (!nid
|| num_nodes
<= 0) {
444 dev_warn(&hdac
->dev
, "HDMI: failed to get afg sub nodes\n");
448 hdac
->num_nodes
= num_nodes
;
449 hdac
->start_nid
= nid
;
451 for (i
= 0; i
< hdac
->num_nodes
; i
++, nid
++) {
455 caps
= get_wcaps(hdac
, nid
);
456 type
= get_wcaps_type(caps
);
458 if (!(caps
& AC_WCAP_DIGITAL
))
464 ret
= hdac_hdmi_add_cvt(edev
, nid
);
470 ret
= hdac_hdmi_add_pin(edev
, nid
);
479 if (!hdmi
->num_pin
|| !hdmi
->num_cvt
)
482 return hdac_hdmi_init_dai_map(edev
);
485 static int hdmi_codec_probe(struct snd_soc_codec
*codec
)
487 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
488 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
489 struct snd_soc_dapm_context
*dapm
=
490 snd_soc_component_get_dapm(&codec
->component
);
492 edev
->scodec
= codec
;
494 create_fill_widget_route_map(dapm
, &hdmi
->dai_map
[0]);
496 /* Imp: Store the card pointer in hda_codec */
497 edev
->card
= dapm
->card
->snd_card
;
500 * hdac_device core already sets the state to active and calls
501 * get_noresume. So enable runtime and set the device to suspend.
503 pm_runtime_enable(&edev
->hdac
.dev
);
504 pm_runtime_put(&edev
->hdac
.dev
);
505 pm_runtime_suspend(&edev
->hdac
.dev
);
510 static int hdmi_codec_remove(struct snd_soc_codec
*codec
)
512 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
514 pm_runtime_disable(&edev
->hdac
.dev
);
518 static struct snd_soc_codec_driver hdmi_hda_codec
= {
519 .probe
= hdmi_codec_probe
,
520 .remove
= hdmi_codec_remove
,
521 .idle_bias_off
= true,
524 static struct snd_soc_dai_ops hdmi_dai_ops
= {
525 .startup
= hdac_hdmi_pcm_open
,
526 .shutdown
= hdac_hdmi_pcm_close
,
527 .hw_params
= hdac_hdmi_set_hw_params
,
528 .prepare
= hdac_hdmi_playback_prepare
,
529 .hw_free
= hdac_hdmi_playback_cleanup
,
532 static struct snd_soc_dai_driver hdmi_dais
[] = {
533 { .name
= "intel-hdmi-hif1",
535 .stream_name
= "hif1",
538 .rates
= SNDRV_PCM_RATE_32000
|
539 SNDRV_PCM_RATE_44100
| SNDRV_PCM_RATE_48000
|
540 SNDRV_PCM_RATE_88200
| SNDRV_PCM_RATE_96000
|
541 SNDRV_PCM_RATE_176400
| SNDRV_PCM_RATE_192000
,
542 .formats
= SNDRV_PCM_FMTBIT_S16_LE
|
543 SNDRV_PCM_FMTBIT_S20_3LE
|
544 SNDRV_PCM_FMTBIT_S24_LE
|
545 SNDRV_PCM_FMTBIT_S32_LE
,
548 .ops
= &hdmi_dai_ops
,
552 static int hdac_hdmi_dev_probe(struct hdac_ext_device
*edev
)
554 struct hdac_device
*codec
= &edev
->hdac
;
555 struct hdac_hdmi_priv
*hdmi_priv
;
558 hdmi_priv
= devm_kzalloc(&codec
->dev
, sizeof(*hdmi_priv
), GFP_KERNEL
);
559 if (hdmi_priv
== NULL
)
562 edev
->private_data
= hdmi_priv
;
564 dev_set_drvdata(&codec
->dev
, edev
);
566 INIT_LIST_HEAD(&hdmi_priv
->pin_list
);
567 INIT_LIST_HEAD(&hdmi_priv
->cvt_list
);
569 ret
= hdac_hdmi_parse_and_map_nid(edev
);
573 /* ASoC specific initialization */
574 return snd_soc_register_codec(&codec
->dev
, &hdmi_hda_codec
,
575 hdmi_dais
, ARRAY_SIZE(hdmi_dais
));
578 static int hdac_hdmi_dev_remove(struct hdac_ext_device
*edev
)
580 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
581 struct hdac_hdmi_pin
*pin
, *pin_next
;
582 struct hdac_hdmi_cvt
*cvt
, *cvt_next
;
584 snd_soc_unregister_codec(&edev
->hdac
.dev
);
586 list_for_each_entry_safe(cvt
, cvt_next
, &hdmi
->cvt_list
, head
) {
587 list_del(&cvt
->head
);
591 list_for_each_entry_safe(pin
, pin_next
, &hdmi
->pin_list
, head
) {
592 list_del(&pin
->head
);
600 static int hdac_hdmi_runtime_suspend(struct device
*dev
)
602 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
603 struct hdac_device
*hdac
= &edev
->hdac
;
604 struct hdac_bus
*bus
= hdac
->bus
;
607 dev_dbg(dev
, "Enter: %s\n", __func__
);
609 /* controller may not have been initialized for the first time */
614 if (!snd_hdac_check_power_state(hdac
, hdac
->afg
, AC_PWRST_D3
))
615 snd_hdac_codec_write(hdac
, hdac
->afg
, 0,
616 AC_VERB_SET_POWER_STATE
, AC_PWRST_D3
);
618 err
= snd_hdac_display_power(bus
, false);
620 dev_err(bus
->dev
, "Cannot turn on display power on i915\n");
627 static int hdac_hdmi_runtime_resume(struct device
*dev
)
629 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
630 struct hdac_device
*hdac
= &edev
->hdac
;
631 struct hdac_bus
*bus
= hdac
->bus
;
634 dev_dbg(dev
, "Enter: %s\n", __func__
);
636 /* controller may not have been initialized for the first time */
640 err
= snd_hdac_display_power(bus
, true);
642 dev_err(bus
->dev
, "Cannot turn on display power on i915\n");
647 if (!snd_hdac_check_power_state(hdac
, hdac
->afg
, AC_PWRST_D0
))
648 snd_hdac_codec_write(hdac
, hdac
->afg
, 0,
649 AC_VERB_SET_POWER_STATE
, AC_PWRST_D0
);
654 #define hdac_hdmi_runtime_suspend NULL
655 #define hdac_hdmi_runtime_resume NULL
658 static const struct dev_pm_ops hdac_hdmi_pm
= {
659 SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend
, hdac_hdmi_runtime_resume
, NULL
)
662 static const struct hda_device_id hdmi_list
[] = {
663 HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0),
667 MODULE_DEVICE_TABLE(hdaudio
, hdmi_list
);
669 static struct hdac_ext_driver hdmi_driver
= {
672 .name
= "HDMI HDA Codec",
675 .id_table
= hdmi_list
,
677 .probe
= hdac_hdmi_dev_probe
,
678 .remove
= hdac_hdmi_dev_remove
,
681 static int __init
hdmi_init(void)
683 return snd_hda_ext_driver_register(&hdmi_driver
);
686 static void __exit
hdmi_exit(void)
688 snd_hda_ext_driver_unregister(&hdmi_driver
);
691 module_init(hdmi_init
);
692 module_exit(hdmi_exit
);
694 MODULE_LICENSE("GPL v2");
695 MODULE_DESCRIPTION("HDMI HD codec");
696 MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>");
697 MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>");