Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Copyright 2014 Advanced Micro Devices, Inc.
0003  *
0004  * Permission is hereby granted, free of charge, to any person obtaining a
0005  * copy of this software and associated documentation files (the "Software"),
0006  * to deal in the Software without restriction, including without limitation
0007  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
0008  * and/or sell copies of the Software, and to permit persons to whom the
0009  * Software is furnished to do so, subject to the following conditions:
0010  *
0011  * The above copyright notice and this permission notice shall be included in
0012  * all copies or substantial portions of the Software.
0013  *
0014  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0015  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0016  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
0017  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
0018  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
0019  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
0020  * OTHER DEALINGS IN THE SOFTWARE.
0021  *
0022  * Authors: Slava Grigorev <slava.grigorev@amd.com>
0023  */
0024 
0025 #include <linux/gcd.h>
0026 
0027 #include <drm/drm_crtc.h>
0028 #include "dce6_afmt.h"
0029 #include "evergreen_hdmi.h"
0030 #include "radeon.h"
0031 #include "atom.h"
0032 #include "r600.h"
0033 #include "radeon_audio.h"
0034 
0035 void dce6_audio_enable(struct radeon_device *rdev, struct r600_audio_pin *pin,
0036         u8 enable_mask);
0037 struct r600_audio_pin* r600_audio_get_pin(struct radeon_device *rdev);
0038 struct r600_audio_pin* dce6_audio_get_pin(struct radeon_device *rdev);
0039 static void radeon_audio_hdmi_mode_set(struct drm_encoder *encoder,
0040     struct drm_display_mode *mode);
0041 static void radeon_audio_dp_mode_set(struct drm_encoder *encoder,
0042     struct drm_display_mode *mode);
0043 
0044 static const u32 pin_offsets[7] =
0045 {
0046     (0x5e00 - 0x5e00),
0047     (0x5e18 - 0x5e00),
0048     (0x5e30 - 0x5e00),
0049     (0x5e48 - 0x5e00),
0050     (0x5e60 - 0x5e00),
0051     (0x5e78 - 0x5e00),
0052     (0x5e90 - 0x5e00),
0053 };
0054 
0055 static u32 radeon_audio_rreg(struct radeon_device *rdev, u32 offset, u32 reg)
0056 {
0057     return RREG32(reg);
0058 }
0059 
0060 static void radeon_audio_wreg(struct radeon_device *rdev, u32 offset,
0061         u32 reg, u32 v)
0062 {
0063     WREG32(reg, v);
0064 }
0065 
0066 static struct radeon_audio_basic_funcs r600_funcs = {
0067     .endpoint_rreg = radeon_audio_rreg,
0068     .endpoint_wreg = radeon_audio_wreg,
0069     .enable = r600_audio_enable,
0070 };
0071 
0072 static struct radeon_audio_basic_funcs dce32_funcs = {
0073     .endpoint_rreg = radeon_audio_rreg,
0074     .endpoint_wreg = radeon_audio_wreg,
0075     .enable = r600_audio_enable,
0076 };
0077 
0078 static struct radeon_audio_basic_funcs dce4_funcs = {
0079     .endpoint_rreg = radeon_audio_rreg,
0080     .endpoint_wreg = radeon_audio_wreg,
0081     .enable = dce4_audio_enable,
0082 };
0083 
0084 static struct radeon_audio_basic_funcs dce6_funcs = {
0085     .endpoint_rreg = dce6_endpoint_rreg,
0086     .endpoint_wreg = dce6_endpoint_wreg,
0087     .enable = dce6_audio_enable,
0088 };
0089 
0090 static struct radeon_audio_funcs r600_hdmi_funcs = {
0091     .get_pin = r600_audio_get_pin,
0092     .set_dto = r600_hdmi_audio_set_dto,
0093     .update_acr = r600_hdmi_update_acr,
0094     .set_vbi_packet = r600_set_vbi_packet,
0095     .set_avi_packet = r600_set_avi_packet,
0096     .set_audio_packet = r600_set_audio_packet,
0097     .set_mute = r600_set_mute,
0098     .mode_set = radeon_audio_hdmi_mode_set,
0099     .dpms = r600_hdmi_enable,
0100 };
0101 
0102 static struct radeon_audio_funcs dce32_hdmi_funcs = {
0103     .get_pin = r600_audio_get_pin,
0104     .write_sad_regs = dce3_2_afmt_write_sad_regs,
0105     .write_speaker_allocation = dce3_2_afmt_hdmi_write_speaker_allocation,
0106     .set_dto = dce3_2_audio_set_dto,
0107     .update_acr = dce3_2_hdmi_update_acr,
0108     .set_vbi_packet = r600_set_vbi_packet,
0109     .set_avi_packet = r600_set_avi_packet,
0110     .set_audio_packet = dce3_2_set_audio_packet,
0111     .set_mute = dce3_2_set_mute,
0112     .mode_set = radeon_audio_hdmi_mode_set,
0113     .dpms = r600_hdmi_enable,
0114 };
0115 
0116 static struct radeon_audio_funcs dce32_dp_funcs = {
0117     .get_pin = r600_audio_get_pin,
0118     .write_sad_regs = dce3_2_afmt_write_sad_regs,
0119     .write_speaker_allocation = dce3_2_afmt_dp_write_speaker_allocation,
0120     .set_dto = dce3_2_audio_set_dto,
0121     .set_avi_packet = r600_set_avi_packet,
0122     .set_audio_packet = dce3_2_set_audio_packet,
0123 };
0124 
0125 static struct radeon_audio_funcs dce4_hdmi_funcs = {
0126     .get_pin = r600_audio_get_pin,
0127     .write_sad_regs = evergreen_hdmi_write_sad_regs,
0128     .write_speaker_allocation = dce4_afmt_hdmi_write_speaker_allocation,
0129     .write_latency_fields = dce4_afmt_write_latency_fields,
0130     .set_dto = dce4_hdmi_audio_set_dto,
0131     .update_acr = evergreen_hdmi_update_acr,
0132     .set_vbi_packet = dce4_set_vbi_packet,
0133     .set_color_depth = dce4_hdmi_set_color_depth,
0134     .set_avi_packet = evergreen_set_avi_packet,
0135     .set_audio_packet = dce4_set_audio_packet,
0136     .set_mute = dce4_set_mute,
0137     .mode_set = radeon_audio_hdmi_mode_set,
0138     .dpms = evergreen_hdmi_enable,
0139 };
0140 
0141 static struct radeon_audio_funcs dce4_dp_funcs = {
0142     .get_pin = r600_audio_get_pin,
0143     .write_sad_regs = evergreen_hdmi_write_sad_regs,
0144     .write_speaker_allocation = dce4_afmt_dp_write_speaker_allocation,
0145     .write_latency_fields = dce4_afmt_write_latency_fields,
0146     .set_dto = dce4_dp_audio_set_dto,
0147     .set_avi_packet = evergreen_set_avi_packet,
0148     .set_audio_packet = dce4_set_audio_packet,
0149     .mode_set = radeon_audio_dp_mode_set,
0150     .dpms = evergreen_dp_enable,
0151 };
0152 
0153 static struct radeon_audio_funcs dce6_hdmi_funcs = {
0154     .select_pin = dce6_afmt_select_pin,
0155     .get_pin = dce6_audio_get_pin,
0156     .write_sad_regs = dce6_afmt_write_sad_regs,
0157     .write_speaker_allocation = dce6_afmt_hdmi_write_speaker_allocation,
0158     .write_latency_fields = dce6_afmt_write_latency_fields,
0159     .set_dto = dce6_hdmi_audio_set_dto,
0160     .update_acr = evergreen_hdmi_update_acr,
0161     .set_vbi_packet = dce4_set_vbi_packet,
0162     .set_color_depth = dce4_hdmi_set_color_depth,
0163     .set_avi_packet = evergreen_set_avi_packet,
0164     .set_audio_packet = dce4_set_audio_packet,
0165     .set_mute = dce4_set_mute,
0166     .mode_set = radeon_audio_hdmi_mode_set,
0167     .dpms = evergreen_hdmi_enable,
0168 };
0169 
0170 static struct radeon_audio_funcs dce6_dp_funcs = {
0171     .select_pin = dce6_afmt_select_pin,
0172     .get_pin = dce6_audio_get_pin,
0173     .write_sad_regs = dce6_afmt_write_sad_regs,
0174     .write_speaker_allocation = dce6_afmt_dp_write_speaker_allocation,
0175     .write_latency_fields = dce6_afmt_write_latency_fields,
0176     .set_dto = dce6_dp_audio_set_dto,
0177     .set_avi_packet = evergreen_set_avi_packet,
0178     .set_audio_packet = dce4_set_audio_packet,
0179     .mode_set = radeon_audio_dp_mode_set,
0180     .dpms = evergreen_dp_enable,
0181 };
0182 
0183 static void radeon_audio_enable(struct radeon_device *rdev,
0184                 struct r600_audio_pin *pin, u8 enable_mask)
0185 {
0186     struct drm_encoder *encoder;
0187     struct radeon_encoder *radeon_encoder;
0188     struct radeon_encoder_atom_dig *dig;
0189     int pin_count = 0;
0190 
0191     if (!pin)
0192         return;
0193 
0194     if (rdev->mode_info.mode_config_initialized) {
0195         list_for_each_entry(encoder, &rdev->ddev->mode_config.encoder_list, head) {
0196             if (radeon_encoder_is_digital(encoder)) {
0197                 radeon_encoder = to_radeon_encoder(encoder);
0198                 dig = radeon_encoder->enc_priv;
0199                 if (dig->pin == pin)
0200                     pin_count++;
0201             }
0202         }
0203 
0204         if ((pin_count > 1) && (enable_mask == 0))
0205             return;
0206     }
0207 
0208     if (rdev->audio.funcs->enable)
0209         rdev->audio.funcs->enable(rdev, pin, enable_mask);
0210 }
0211 
0212 static void radeon_audio_interface_init(struct radeon_device *rdev)
0213 {
0214     if (ASIC_IS_DCE6(rdev)) {
0215         rdev->audio.funcs = &dce6_funcs;
0216         rdev->audio.hdmi_funcs = &dce6_hdmi_funcs;
0217         rdev->audio.dp_funcs = &dce6_dp_funcs;
0218     } else if (ASIC_IS_DCE4(rdev)) {
0219         rdev->audio.funcs = &dce4_funcs;
0220         rdev->audio.hdmi_funcs = &dce4_hdmi_funcs;
0221         rdev->audio.dp_funcs = &dce4_dp_funcs;
0222     } else if (ASIC_IS_DCE32(rdev)) {
0223         rdev->audio.funcs = &dce32_funcs;
0224         rdev->audio.hdmi_funcs = &dce32_hdmi_funcs;
0225         rdev->audio.dp_funcs = &dce32_dp_funcs;
0226     } else {
0227         rdev->audio.funcs = &r600_funcs;
0228         rdev->audio.hdmi_funcs = &r600_hdmi_funcs;
0229         rdev->audio.dp_funcs = NULL;
0230     }
0231 }
0232 
0233 static int radeon_audio_chipset_supported(struct radeon_device *rdev)
0234 {
0235     return ASIC_IS_DCE2(rdev) && !ASIC_IS_NODCE(rdev);
0236 }
0237 
0238 int radeon_audio_init(struct radeon_device *rdev)
0239 {
0240     int i;
0241 
0242     if (!radeon_audio || !radeon_audio_chipset_supported(rdev))
0243         return 0;
0244 
0245     rdev->audio.enabled = true;
0246 
0247     if (ASIC_IS_DCE83(rdev))        /* KB: 2 streams, 3 endpoints */
0248         rdev->audio.num_pins = 3;
0249     else if (ASIC_IS_DCE81(rdev))   /* KV: 4 streams, 7 endpoints */
0250         rdev->audio.num_pins = 7;
0251     else if (ASIC_IS_DCE8(rdev))    /* BN/HW: 6 streams, 7 endpoints */
0252         rdev->audio.num_pins = 7;
0253     else if (ASIC_IS_DCE64(rdev))   /* OL: 2 streams, 2 endpoints */
0254         rdev->audio.num_pins = 2;
0255     else if (ASIC_IS_DCE61(rdev))   /* TN: 4 streams, 6 endpoints */
0256         rdev->audio.num_pins = 6;
0257     else if (ASIC_IS_DCE6(rdev))    /* SI: 6 streams, 6 endpoints */
0258         rdev->audio.num_pins = 6;
0259     else
0260         rdev->audio.num_pins = 1;
0261 
0262     for (i = 0; i < rdev->audio.num_pins; i++) {
0263         rdev->audio.pin[i].channels = -1;
0264         rdev->audio.pin[i].rate = -1;
0265         rdev->audio.pin[i].bits_per_sample = -1;
0266         rdev->audio.pin[i].status_bits = 0;
0267         rdev->audio.pin[i].category_code = 0;
0268         rdev->audio.pin[i].connected = false;
0269         rdev->audio.pin[i].offset = pin_offsets[i];
0270         rdev->audio.pin[i].id = i;
0271     }
0272 
0273     radeon_audio_interface_init(rdev);
0274 
0275     /* disable audio.  it will be set up later */
0276     for (i = 0; i < rdev->audio.num_pins; i++)
0277         radeon_audio_enable(rdev, &rdev->audio.pin[i], 0);
0278 
0279     return 0;
0280 }
0281 
0282 u32 radeon_audio_endpoint_rreg(struct radeon_device *rdev, u32 offset, u32 reg)
0283 {
0284     if (rdev->audio.funcs->endpoint_rreg)
0285         return rdev->audio.funcs->endpoint_rreg(rdev, offset, reg);
0286 
0287     return 0;
0288 }
0289 
0290 void radeon_audio_endpoint_wreg(struct radeon_device *rdev, u32 offset,
0291     u32 reg, u32 v)
0292 {
0293     if (rdev->audio.funcs->endpoint_wreg)
0294         rdev->audio.funcs->endpoint_wreg(rdev, offset, reg, v);
0295 }
0296 
0297 static void radeon_audio_write_sad_regs(struct drm_encoder *encoder)
0298 {
0299     struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
0300     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0301     struct cea_sad *sads;
0302     int sad_count;
0303 
0304     if (!connector)
0305         return;
0306 
0307     sad_count = drm_edid_to_sad(radeon_connector_edid(connector), &sads);
0308     if (sad_count < 0)
0309         DRM_ERROR("Couldn't read SADs: %d\n", sad_count);
0310     if (sad_count <= 0)
0311         return;
0312     BUG_ON(!sads);
0313 
0314     if (radeon_encoder->audio && radeon_encoder->audio->write_sad_regs)
0315         radeon_encoder->audio->write_sad_regs(encoder, sads, sad_count);
0316 
0317     kfree(sads);
0318 }
0319 
0320 static void radeon_audio_write_speaker_allocation(struct drm_encoder *encoder)
0321 {
0322     struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
0323     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0324     u8 *sadb = NULL;
0325     int sad_count;
0326 
0327     if (!connector)
0328         return;
0329 
0330     sad_count = drm_edid_to_speaker_allocation(radeon_connector_edid(connector),
0331                            &sadb);
0332     if (sad_count < 0) {
0333         DRM_DEBUG("Couldn't read Speaker Allocation Data Block: %d\n",
0334               sad_count);
0335         sad_count = 0;
0336     }
0337 
0338     if (radeon_encoder->audio && radeon_encoder->audio->write_speaker_allocation)
0339         radeon_encoder->audio->write_speaker_allocation(encoder, sadb, sad_count);
0340 
0341     kfree(sadb);
0342 }
0343 
0344 static void radeon_audio_write_latency_fields(struct drm_encoder *encoder,
0345                           struct drm_display_mode *mode)
0346 {
0347     struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
0348     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0349 
0350     if (!connector)
0351         return;
0352 
0353     if (radeon_encoder->audio && radeon_encoder->audio->write_latency_fields)
0354         radeon_encoder->audio->write_latency_fields(encoder, connector, mode);
0355 }
0356 
0357 struct r600_audio_pin* radeon_audio_get_pin(struct drm_encoder *encoder)
0358 {
0359     struct radeon_device *rdev = encoder->dev->dev_private;
0360     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0361 
0362     if (radeon_encoder->audio && radeon_encoder->audio->get_pin)
0363         return radeon_encoder->audio->get_pin(rdev);
0364 
0365     return NULL;
0366 }
0367 
0368 static void radeon_audio_select_pin(struct drm_encoder *encoder)
0369 {
0370     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0371 
0372     if (radeon_encoder->audio && radeon_encoder->audio->select_pin)
0373         radeon_encoder->audio->select_pin(encoder);
0374 }
0375 
0376 void radeon_audio_detect(struct drm_connector *connector,
0377              struct drm_encoder *encoder,
0378              enum drm_connector_status status)
0379 {
0380     struct drm_device *dev = connector->dev;
0381     struct radeon_device *rdev = dev->dev_private;
0382     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0383     struct radeon_encoder_atom_dig *dig;
0384 
0385     if (!radeon_audio_chipset_supported(rdev))
0386         return;
0387 
0388     if (!radeon_encoder_is_digital(encoder))
0389         return;
0390 
0391     dig = radeon_encoder->enc_priv;
0392 
0393     if (status == connector_status_connected) {
0394         if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
0395             struct radeon_connector *radeon_connector = to_radeon_connector(connector);
0396 
0397             if (radeon_dp_getsinktype(radeon_connector) ==
0398                 CONNECTOR_OBJECT_ID_DISPLAYPORT)
0399                 radeon_encoder->audio = rdev->audio.dp_funcs;
0400             else
0401                 radeon_encoder->audio = rdev->audio.hdmi_funcs;
0402         } else {
0403             radeon_encoder->audio = rdev->audio.hdmi_funcs;
0404         }
0405 
0406         if (drm_detect_monitor_audio(radeon_connector_edid(connector))) {
0407             if (!dig->pin)
0408                 dig->pin = radeon_audio_get_pin(encoder);
0409             radeon_audio_enable(rdev, dig->pin, 0xf);
0410         } else {
0411             radeon_audio_enable(rdev, dig->pin, 0);
0412             dig->pin = NULL;
0413         }
0414     } else {
0415         radeon_audio_enable(rdev, dig->pin, 0);
0416         dig->pin = NULL;
0417     }
0418 }
0419 
0420 void radeon_audio_fini(struct radeon_device *rdev)
0421 {
0422     int i;
0423 
0424     if (!rdev->audio.enabled)
0425         return;
0426 
0427     for (i = 0; i < rdev->audio.num_pins; i++)
0428         radeon_audio_enable(rdev, &rdev->audio.pin[i], 0);
0429 
0430     rdev->audio.enabled = false;
0431 }
0432 
0433 static void radeon_audio_set_dto(struct drm_encoder *encoder, unsigned int clock)
0434 {
0435     struct radeon_device *rdev = encoder->dev->dev_private;
0436     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0437     struct radeon_crtc *crtc = to_radeon_crtc(encoder->crtc);
0438 
0439     if (radeon_encoder->audio && radeon_encoder->audio->set_dto)
0440         radeon_encoder->audio->set_dto(rdev, crtc, clock);
0441 }
0442 
0443 static int radeon_audio_set_avi_packet(struct drm_encoder *encoder,
0444                        struct drm_display_mode *mode)
0445 {
0446     struct radeon_device *rdev = encoder->dev->dev_private;
0447     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0448     struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
0449     struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
0450     u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE];
0451     struct hdmi_avi_infoframe frame;
0452     int err;
0453 
0454     if (!connector)
0455         return -EINVAL;
0456 
0457     err = drm_hdmi_avi_infoframe_from_display_mode(&frame, connector, mode);
0458     if (err < 0) {
0459         DRM_ERROR("failed to setup AVI infoframe: %d\n", err);
0460         return err;
0461     }
0462 
0463     if (radeon_encoder->output_csc != RADEON_OUTPUT_CSC_BYPASS) {
0464         drm_hdmi_avi_infoframe_quant_range(&frame, connector, mode,
0465                            radeon_encoder->output_csc == RADEON_OUTPUT_CSC_TVRGB ?
0466                            HDMI_QUANTIZATION_RANGE_LIMITED :
0467                            HDMI_QUANTIZATION_RANGE_FULL);
0468     }
0469 
0470     err = hdmi_avi_infoframe_pack(&frame, buffer, sizeof(buffer));
0471     if (err < 0) {
0472         DRM_ERROR("failed to pack AVI infoframe: %d\n", err);
0473         return err;
0474     }
0475 
0476     if (dig && dig->afmt && radeon_encoder->audio &&
0477         radeon_encoder->audio->set_avi_packet)
0478         radeon_encoder->audio->set_avi_packet(rdev, dig->afmt->offset,
0479             buffer, sizeof(buffer));
0480 
0481     return 0;
0482 }
0483 
0484 /*
0485  * calculate CTS and N values if they are not found in the table
0486  */
0487 static void radeon_audio_calc_cts(unsigned int clock, int *CTS, int *N, int freq)
0488 {
0489     int n, cts;
0490     unsigned long div, mul;
0491 
0492     /* Safe, but overly large values */
0493     n = 128 * freq;
0494     cts = clock * 1000;
0495 
0496     /* Smallest valid fraction */
0497     div = gcd(n, cts);
0498 
0499     n /= div;
0500     cts /= div;
0501 
0502     /*
0503      * The optimal N is 128*freq/1000. Calculate the closest larger
0504      * value that doesn't truncate any bits.
0505      */
0506     mul = ((128*freq/1000) + (n-1))/n;
0507 
0508     n *= mul;
0509     cts *= mul;
0510 
0511     /* Check that we are in spec (not always possible) */
0512     if (n < (128*freq/1500))
0513         pr_warn("Calculated ACR N value is too small. You may experience audio problems.\n");
0514     if (n > (128*freq/300))
0515         pr_warn("Calculated ACR N value is too large. You may experience audio problems.\n");
0516 
0517     *N = n;
0518     *CTS = cts;
0519 
0520     DRM_DEBUG("Calculated ACR timing N=%d CTS=%d for frequency %d\n",
0521         *N, *CTS, freq);
0522 }
0523 
0524 static const struct radeon_hdmi_acr* radeon_audio_acr(unsigned int clock)
0525 {
0526     static struct radeon_hdmi_acr res;
0527     u8 i;
0528 
0529     static const struct radeon_hdmi_acr hdmi_predefined_acr[] = {
0530         /*       32kHz    44.1kHz   48kHz    */
0531         /* Clock      N     CTS      N     CTS      N     CTS */
0532         {  25175,  4096,  25175, 28224, 125875,  6144,  25175 }, /*  25,20/1.001 MHz */
0533         {  25200,  4096,  25200,  6272,  28000,  6144,  25200 }, /*  25.20       MHz */
0534         {  27000,  4096,  27000,  6272,  30000,  6144,  27000 }, /*  27.00       MHz */
0535         {  27027,  4096,  27027,  6272,  30030,  6144,  27027 }, /*  27.00*1.001 MHz */
0536         {  54000,  4096,  54000,  6272,  60000,  6144,  54000 }, /*  54.00       MHz */
0537         {  54054,  4096,  54054,  6272,  60060,  6144,  54054 }, /*  54.00*1.001 MHz */
0538         {  74176,  4096,  74176,  5733,  75335,  6144,  74176 }, /*  74.25/1.001 MHz */
0539         {  74250,  4096,  74250,  6272,  82500,  6144,  74250 }, /*  74.25       MHz */
0540         { 148352,  4096, 148352,  5733, 150670,  6144, 148352 }, /* 148.50/1.001 MHz */
0541         { 148500,  4096, 148500,  6272, 165000,  6144, 148500 }, /* 148.50       MHz */
0542     };
0543 
0544     /* Precalculated values for common clocks */
0545     for (i = 0; i < ARRAY_SIZE(hdmi_predefined_acr); i++)
0546         if (hdmi_predefined_acr[i].clock == clock)
0547             return &hdmi_predefined_acr[i];
0548 
0549     /* And odd clocks get manually calculated */
0550     radeon_audio_calc_cts(clock, &res.cts_32khz, &res.n_32khz, 32000);
0551     radeon_audio_calc_cts(clock, &res.cts_44_1khz, &res.n_44_1khz, 44100);
0552     radeon_audio_calc_cts(clock, &res.cts_48khz, &res.n_48khz, 48000);
0553 
0554     return &res;
0555 }
0556 
0557 /*
0558  * update the N and CTS parameters for a given pixel clock rate
0559  */
0560 static void radeon_audio_update_acr(struct drm_encoder *encoder, unsigned int clock)
0561 {
0562     const struct radeon_hdmi_acr *acr = radeon_audio_acr(clock);
0563     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0564     struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
0565 
0566     if (!dig || !dig->afmt)
0567         return;
0568 
0569     if (radeon_encoder->audio && radeon_encoder->audio->update_acr)
0570         radeon_encoder->audio->update_acr(encoder, dig->afmt->offset, acr);
0571 }
0572 
0573 static void radeon_audio_set_vbi_packet(struct drm_encoder *encoder)
0574 {
0575     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0576     struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
0577 
0578     if (!dig || !dig->afmt)
0579         return;
0580 
0581     if (radeon_encoder->audio && radeon_encoder->audio->set_vbi_packet)
0582         radeon_encoder->audio->set_vbi_packet(encoder, dig->afmt->offset);
0583 }
0584 
0585 static void radeon_hdmi_set_color_depth(struct drm_encoder *encoder)
0586 {
0587     int bpc = 8;
0588     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0589     struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
0590 
0591     if (!dig || !dig->afmt)
0592         return;
0593 
0594     if (encoder->crtc) {
0595         struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc);
0596         bpc = radeon_crtc->bpc;
0597     }
0598 
0599     if (radeon_encoder->audio && radeon_encoder->audio->set_color_depth)
0600         radeon_encoder->audio->set_color_depth(encoder, dig->afmt->offset, bpc);
0601 }
0602 
0603 static void radeon_audio_set_audio_packet(struct drm_encoder *encoder)
0604 {
0605     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0606     struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
0607 
0608     if (!dig || !dig->afmt)
0609         return;
0610 
0611     if (radeon_encoder->audio && radeon_encoder->audio->set_audio_packet)
0612         radeon_encoder->audio->set_audio_packet(encoder, dig->afmt->offset);
0613 }
0614 
0615 static void radeon_audio_set_mute(struct drm_encoder *encoder, bool mute)
0616 {
0617     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0618     struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
0619 
0620     if (!dig || !dig->afmt)
0621         return;
0622 
0623     if (radeon_encoder->audio && radeon_encoder->audio->set_mute)
0624         radeon_encoder->audio->set_mute(encoder, dig->afmt->offset, mute);
0625 }
0626 
0627 /*
0628  * update the info frames with the data from the current display mode
0629  */
0630 static void radeon_audio_hdmi_mode_set(struct drm_encoder *encoder,
0631                        struct drm_display_mode *mode)
0632 {
0633     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0634     struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
0635     struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
0636 
0637     if (!dig || !dig->afmt)
0638         return;
0639 
0640     if (!connector)
0641         return;
0642 
0643     if (drm_detect_monitor_audio(radeon_connector_edid(connector))) {
0644         radeon_audio_set_mute(encoder, true);
0645 
0646         radeon_audio_write_speaker_allocation(encoder);
0647         radeon_audio_write_sad_regs(encoder);
0648         radeon_audio_write_latency_fields(encoder, mode);
0649         radeon_audio_set_dto(encoder, mode->clock);
0650         radeon_audio_set_vbi_packet(encoder);
0651         radeon_hdmi_set_color_depth(encoder);
0652         radeon_audio_update_acr(encoder, mode->clock);
0653         radeon_audio_set_audio_packet(encoder);
0654         radeon_audio_select_pin(encoder);
0655 
0656         if (radeon_audio_set_avi_packet(encoder, mode) < 0)
0657             return;
0658 
0659         radeon_audio_set_mute(encoder, false);
0660     } else {
0661         radeon_hdmi_set_color_depth(encoder);
0662 
0663         if (radeon_audio_set_avi_packet(encoder, mode) < 0)
0664             return;
0665     }
0666 }
0667 
0668 static void radeon_audio_dp_mode_set(struct drm_encoder *encoder,
0669                      struct drm_display_mode *mode)
0670 {
0671     struct drm_device *dev = encoder->dev;
0672     struct radeon_device *rdev = dev->dev_private;
0673     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0674     struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv;
0675     struct drm_connector *connector = radeon_get_connector_for_encoder(encoder);
0676 
0677     if (!dig || !dig->afmt)
0678         return;
0679 
0680     if (!connector)
0681         return;
0682 
0683     if (drm_detect_monitor_audio(radeon_connector_edid(connector))) {
0684         radeon_audio_write_speaker_allocation(encoder);
0685         radeon_audio_write_sad_regs(encoder);
0686         radeon_audio_write_latency_fields(encoder, mode);
0687         radeon_audio_set_dto(encoder, rdev->clock.vco_freq * 10);
0688         radeon_audio_set_audio_packet(encoder);
0689         radeon_audio_select_pin(encoder);
0690 
0691         if (radeon_audio_set_avi_packet(encoder, mode) < 0)
0692             return;
0693     }
0694 }
0695 
0696 void radeon_audio_mode_set(struct drm_encoder *encoder,
0697                struct drm_display_mode *mode)
0698 {
0699     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0700 
0701     if (radeon_encoder->audio && radeon_encoder->audio->mode_set)
0702         radeon_encoder->audio->mode_set(encoder, mode);
0703 }
0704 
0705 void radeon_audio_dpms(struct drm_encoder *encoder, int mode)
0706 {
0707     struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
0708 
0709     if (radeon_encoder->audio && radeon_encoder->audio->dpms)
0710         radeon_encoder->audio->dpms(encoder, mode == DRM_MODE_DPMS_ON);
0711 }
0712 
0713 unsigned int radeon_audio_decode_dfs_div(unsigned int div)
0714 {
0715     if (div >= 8 && div < 64)
0716         return (div - 8) * 25 + 200;
0717     else if (div >= 64 && div < 96)
0718         return (div - 64) * 50 + 1600;
0719     else if (div >= 96 && div < 128)
0720         return (div - 96) * 100 + 3200;
0721     else
0722         return 0;
0723 }
[ 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!