aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/gpu/drm/i915/intel_hdcp.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/gpu/drm/i915/intel_hdcp.c')
-rw-r--r--drivers/gpu/drm/i915/intel_hdcp.c214
1 files changed, 127 insertions, 87 deletions
diff --git a/drivers/gpu/drm/i915/intel_hdcp.c b/drivers/gpu/drm/i915/intel_hdcp.c
index 26e48fc95543..1bf487f94254 100644
--- a/drivers/gpu/drm/i915/intel_hdcp.c
+++ b/drivers/gpu/drm/i915/intel_hdcp.c
@@ -16,6 +16,62 @@
16 16
17#define KEY_LOAD_TRIES 5 17#define KEY_LOAD_TRIES 5
18 18
19static
20bool intel_hdcp_is_ksv_valid(u8 *ksv)
21{
22 int i, ones = 0;
23 /* KSV has 20 1's and 20 0's */
24 for (i = 0; i < DRM_HDCP_KSV_LEN; i++)
25 ones += hweight8(ksv[i]);
26 if (ones != 20)
27 return false;
28
29 return true;
30}
31
32static
33int intel_hdcp_read_valid_bksv(struct intel_digital_port *intel_dig_port,
34 const struct intel_hdcp_shim *shim, u8 *bksv)
35{
36 int ret, i, tries = 2;
37
38 /* HDCP spec states that we must retry the bksv if it is invalid */
39 for (i = 0; i < tries; i++) {
40 ret = shim->read_bksv(intel_dig_port, bksv);
41 if (ret)
42 return ret;
43 if (intel_hdcp_is_ksv_valid(bksv))
44 break;
45 }
46 if (i == tries) {
47 DRM_DEBUG_KMS("Bksv is invalid\n");
48 return -ENODEV;
49 }
50
51 return 0;
52}
53
54/* Is HDCP1.4 capable on Platform and Sink */
55bool intel_hdcp_capable(struct intel_connector *connector)
56{
57 struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
58 const struct intel_hdcp_shim *shim = connector->hdcp.shim;
59 bool capable = false;
60 u8 bksv[5];
61
62 if (!shim)
63 return capable;
64
65 if (shim->hdcp_capable) {
66 shim->hdcp_capable(intel_dig_port, &capable);
67 } else {
68 if (!intel_hdcp_read_valid_bksv(intel_dig_port, shim, bksv))
69 capable = true;
70 }
71
72 return capable;
73}
74
19static int intel_hdcp_poll_ksv_fifo(struct intel_digital_port *intel_dig_port, 75static int intel_hdcp_poll_ksv_fifo(struct intel_digital_port *intel_dig_port,
20 const struct intel_hdcp_shim *shim) 76 const struct intel_hdcp_shim *shim)
21{ 77{
@@ -168,18 +224,6 @@ u32 intel_hdcp_get_repeater_ctl(struct intel_digital_port *intel_dig_port)
168} 224}
169 225
170static 226static
171bool intel_hdcp_is_ksv_valid(u8 *ksv)
172{
173 int i, ones = 0;
174 /* KSV has 20 1's and 20 0's */
175 for (i = 0; i < DRM_HDCP_KSV_LEN; i++)
176 ones += hweight8(ksv[i]);
177 if (ones != 20)
178 return false;
179 return true;
180}
181
182static
183int intel_hdcp_validate_v_prime(struct intel_digital_port *intel_dig_port, 227int intel_hdcp_validate_v_prime(struct intel_digital_port *intel_dig_port,
184 const struct intel_hdcp_shim *shim, 228 const struct intel_hdcp_shim *shim,
185 u8 *ksv_fifo, u8 num_downstream, u8 *bstatus) 229 u8 *ksv_fifo, u8 num_downstream, u8 *bstatus)
@@ -383,7 +427,7 @@ int intel_hdcp_validate_v_prime(struct intel_digital_port *intel_dig_port,
383 if (intel_wait_for_register(dev_priv, HDCP_REP_CTL, 427 if (intel_wait_for_register(dev_priv, HDCP_REP_CTL,
384 HDCP_SHA1_COMPLETE, 428 HDCP_SHA1_COMPLETE,
385 HDCP_SHA1_COMPLETE, 1)) { 429 HDCP_SHA1_COMPLETE, 1)) {
386 DRM_DEBUG_KMS("Timed out waiting for SHA1 complete\n"); 430 DRM_ERROR("Timed out waiting for SHA1 complete\n");
387 return -ETIMEDOUT; 431 return -ETIMEDOUT;
388 } 432 }
389 if (!(I915_READ(HDCP_REP_CTL) & HDCP_SHA1_V_MATCH)) { 433 if (!(I915_READ(HDCP_REP_CTL) & HDCP_SHA1_V_MATCH)) {
@@ -404,7 +448,7 @@ int intel_hdcp_auth_downstream(struct intel_digital_port *intel_dig_port,
404 448
405 ret = intel_hdcp_poll_ksv_fifo(intel_dig_port, shim); 449 ret = intel_hdcp_poll_ksv_fifo(intel_dig_port, shim);
406 if (ret) { 450 if (ret) {
407 DRM_ERROR("KSV list failed to become ready (%d)\n", ret); 451 DRM_DEBUG_KMS("KSV list failed to become ready (%d)\n", ret);
408 return ret; 452 return ret;
409 } 453 }
410 454
@@ -414,7 +458,7 @@ int intel_hdcp_auth_downstream(struct intel_digital_port *intel_dig_port,
414 458
415 if (DRM_HDCP_MAX_DEVICE_EXCEEDED(bstatus[0]) || 459 if (DRM_HDCP_MAX_DEVICE_EXCEEDED(bstatus[0]) ||
416 DRM_HDCP_MAX_CASCADE_EXCEEDED(bstatus[1])) { 460 DRM_HDCP_MAX_CASCADE_EXCEEDED(bstatus[1])) {
417 DRM_ERROR("Max Topology Limit Exceeded\n"); 461 DRM_DEBUG_KMS("Max Topology Limit Exceeded\n");
418 return -EPERM; 462 return -EPERM;
419 } 463 }
420 464
@@ -450,7 +494,7 @@ int intel_hdcp_auth_downstream(struct intel_digital_port *intel_dig_port,
450 } 494 }
451 495
452 if (i == tries) { 496 if (i == tries) {
453 DRM_ERROR("V Prime validation failed.(%d)\n", ret); 497 DRM_DEBUG_KMS("V Prime validation failed.(%d)\n", ret);
454 goto err; 498 goto err;
455 } 499 }
456 500
@@ -499,7 +543,7 @@ static int intel_hdcp_auth(struct intel_digital_port *intel_dig_port,
499 if (ret) 543 if (ret)
500 return ret; 544 return ret;
501 if (!hdcp_capable) { 545 if (!hdcp_capable) {
502 DRM_ERROR("Panel is not HDCP capable\n"); 546 DRM_DEBUG_KMS("Panel is not HDCP capable\n");
503 return -EINVAL; 547 return -EINVAL;
504 } 548 }
505 } 549 }
@@ -527,18 +571,9 @@ static int intel_hdcp_auth(struct intel_digital_port *intel_dig_port,
527 571
528 memset(&bksv, 0, sizeof(bksv)); 572 memset(&bksv, 0, sizeof(bksv));
529 573
530 /* HDCP spec states that we must retry the bksv if it is invalid */ 574 ret = intel_hdcp_read_valid_bksv(intel_dig_port, shim, bksv.shim);
531 for (i = 0; i < tries; i++) { 575 if (ret < 0)
532 ret = shim->read_bksv(intel_dig_port, bksv.shim); 576 return ret;
533 if (ret)
534 return ret;
535 if (intel_hdcp_is_ksv_valid(bksv.shim))
536 break;
537 }
538 if (i == tries) {
539 DRM_ERROR("HDCP failed, Bksv is invalid\n");
540 return -ENODEV;
541 }
542 577
543 I915_WRITE(PORT_HDCP_BKSVLO(port), bksv.reg[0]); 578 I915_WRITE(PORT_HDCP_BKSVLO(port), bksv.reg[0]);
544 I915_WRITE(PORT_HDCP_BKSVHI(port), bksv.reg[1]); 579 I915_WRITE(PORT_HDCP_BKSVHI(port), bksv.reg[1]);
@@ -594,8 +629,8 @@ static int intel_hdcp_auth(struct intel_digital_port *intel_dig_port,
594 } 629 }
595 630
596 if (i == tries) { 631 if (i == tries) {
597 DRM_ERROR("Timed out waiting for Ri prime match (%x)\n", 632 DRM_DEBUG_KMS("Timed out waiting for Ri prime match (%x)\n",
598 I915_READ(PORT_HDCP_STATUS(port))); 633 I915_READ(PORT_HDCP_STATUS(port)));
599 return -ETIMEDOUT; 634 return -ETIMEDOUT;
600 } 635 }
601 636
@@ -618,14 +653,9 @@ static int intel_hdcp_auth(struct intel_digital_port *intel_dig_port,
618 return 0; 653 return 0;
619} 654}
620 655
621static
622struct intel_digital_port *conn_to_dig_port(struct intel_connector *connector)
623{
624 return enc_to_dig_port(&intel_attached_encoder(&connector->base)->base);
625}
626
627static int _intel_hdcp_disable(struct intel_connector *connector) 656static int _intel_hdcp_disable(struct intel_connector *connector)
628{ 657{
658 struct intel_hdcp *hdcp = &connector->hdcp;
629 struct drm_i915_private *dev_priv = connector->base.dev->dev_private; 659 struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
630 struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector); 660 struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
631 enum port port = intel_dig_port->base.port; 661 enum port port = intel_dig_port->base.port;
@@ -641,7 +671,7 @@ static int _intel_hdcp_disable(struct intel_connector *connector)
641 return -ETIMEDOUT; 671 return -ETIMEDOUT;
642 } 672 }
643 673
644 ret = connector->hdcp_shim->toggle_signalling(intel_dig_port, false); 674 ret = hdcp->shim->toggle_signalling(intel_dig_port, false);
645 if (ret) { 675 if (ret) {
646 DRM_ERROR("Failed to disable HDCP signalling\n"); 676 DRM_ERROR("Failed to disable HDCP signalling\n");
647 return ret; 677 return ret;
@@ -653,6 +683,7 @@ static int _intel_hdcp_disable(struct intel_connector *connector)
653 683
654static int _intel_hdcp_enable(struct intel_connector *connector) 684static int _intel_hdcp_enable(struct intel_connector *connector)
655{ 685{
686 struct intel_hdcp *hdcp = &connector->hdcp;
656 struct drm_i915_private *dev_priv = connector->base.dev->dev_private; 687 struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
657 int i, ret, tries = 3; 688 int i, ret, tries = 3;
658 689
@@ -677,8 +708,7 @@ static int _intel_hdcp_enable(struct intel_connector *connector)
677 708
678 /* Incase of authentication failures, HDCP spec expects reauth. */ 709 /* Incase of authentication failures, HDCP spec expects reauth. */
679 for (i = 0; i < tries; i++) { 710 for (i = 0; i < tries; i++) {
680 ret = intel_hdcp_auth(conn_to_dig_port(connector), 711 ret = intel_hdcp_auth(conn_to_dig_port(connector), hdcp->shim);
681 connector->hdcp_shim);
682 if (!ret) 712 if (!ret)
683 return 0; 713 return 0;
684 714
@@ -688,42 +718,50 @@ static int _intel_hdcp_enable(struct intel_connector *connector)
688 _intel_hdcp_disable(connector); 718 _intel_hdcp_disable(connector);
689 } 719 }
690 720
691 DRM_ERROR("HDCP authentication failed (%d tries/%d)\n", tries, ret); 721 DRM_DEBUG_KMS("HDCP authentication failed (%d tries/%d)\n", tries, ret);
692 return ret; 722 return ret;
693} 723}
694 724
725static inline
726struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)
727{
728 return container_of(hdcp, struct intel_connector, hdcp);
729}
730
695static void intel_hdcp_check_work(struct work_struct *work) 731static void intel_hdcp_check_work(struct work_struct *work)
696{ 732{
697 struct intel_connector *connector = container_of(to_delayed_work(work), 733 struct intel_hdcp *hdcp = container_of(to_delayed_work(work),
698 struct intel_connector, 734 struct intel_hdcp,
699 hdcp_check_work); 735 check_work);
736 struct intel_connector *connector = intel_hdcp_to_connector(hdcp);
737
700 if (!intel_hdcp_check_link(connector)) 738 if (!intel_hdcp_check_link(connector))
701 schedule_delayed_work(&connector->hdcp_check_work, 739 schedule_delayed_work(&hdcp->check_work,
702 DRM_HDCP_CHECK_PERIOD_MS); 740 DRM_HDCP_CHECK_PERIOD_MS);
703} 741}
704 742
705static void intel_hdcp_prop_work(struct work_struct *work) 743static void intel_hdcp_prop_work(struct work_struct *work)
706{ 744{
707 struct intel_connector *connector = container_of(work, 745 struct intel_hdcp *hdcp = container_of(work, struct intel_hdcp,
708 struct intel_connector, 746 prop_work);
709 hdcp_prop_work); 747 struct intel_connector *connector = intel_hdcp_to_connector(hdcp);
710 struct drm_device *dev = connector->base.dev; 748 struct drm_device *dev = connector->base.dev;
711 struct drm_connector_state *state; 749 struct drm_connector_state *state;
712 750
713 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 751 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
714 mutex_lock(&connector->hdcp_mutex); 752 mutex_lock(&hdcp->mutex);
715 753
716 /* 754 /*
717 * This worker is only used to flip between ENABLED/DESIRED. Either of 755 * This worker is only used to flip between ENABLED/DESIRED. Either of
718 * those to UNDESIRED is handled by core. If hdcp_value == UNDESIRED, 756 * those to UNDESIRED is handled by core. If value == UNDESIRED,
719 * we're running just after hdcp has been disabled, so just exit 757 * we're running just after hdcp has been disabled, so just exit
720 */ 758 */
721 if (connector->hdcp_value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) { 759 if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
722 state = connector->base.state; 760 state = connector->base.state;
723 state->content_protection = connector->hdcp_value; 761 state->content_protection = hdcp->value;
724 } 762 }
725 763
726 mutex_unlock(&connector->hdcp_mutex); 764 mutex_unlock(&hdcp->mutex);
727 drm_modeset_unlock(&dev->mode_config.connection_mutex); 765 drm_modeset_unlock(&dev->mode_config.connection_mutex);
728} 766}
729 767
@@ -735,8 +773,9 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port)
735} 773}
736 774
737int intel_hdcp_init(struct intel_connector *connector, 775int intel_hdcp_init(struct intel_connector *connector,
738 const struct intel_hdcp_shim *hdcp_shim) 776 const struct intel_hdcp_shim *shim)
739{ 777{
778 struct intel_hdcp *hdcp = &connector->hdcp;
740 int ret; 779 int ret;
741 780
742 ret = drm_connector_attach_content_protection_property( 781 ret = drm_connector_attach_content_protection_property(
@@ -744,51 +783,53 @@ int intel_hdcp_init(struct intel_connector *connector,
744 if (ret) 783 if (ret)
745 return ret; 784 return ret;
746 785
747 connector->hdcp_shim = hdcp_shim; 786 hdcp->shim = shim;
748 mutex_init(&connector->hdcp_mutex); 787 mutex_init(&hdcp->mutex);
749 INIT_DELAYED_WORK(&connector->hdcp_check_work, intel_hdcp_check_work); 788 INIT_DELAYED_WORK(&hdcp->check_work, intel_hdcp_check_work);
750 INIT_WORK(&connector->hdcp_prop_work, intel_hdcp_prop_work); 789 INIT_WORK(&hdcp->prop_work, intel_hdcp_prop_work);
751 return 0; 790 return 0;
752} 791}
753 792
754int intel_hdcp_enable(struct intel_connector *connector) 793int intel_hdcp_enable(struct intel_connector *connector)
755{ 794{
795 struct intel_hdcp *hdcp = &connector->hdcp;
756 int ret; 796 int ret;
757 797
758 if (!connector->hdcp_shim) 798 if (!hdcp->shim)
759 return -ENOENT; 799 return -ENOENT;
760 800
761 mutex_lock(&connector->hdcp_mutex); 801 mutex_lock(&hdcp->mutex);
762 802
763 ret = _intel_hdcp_enable(connector); 803 ret = _intel_hdcp_enable(connector);
764 if (ret) 804 if (ret)
765 goto out; 805 goto out;
766 806
767 connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_ENABLED; 807 hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
768 schedule_work(&connector->hdcp_prop_work); 808 schedule_work(&hdcp->prop_work);
769 schedule_delayed_work(&connector->hdcp_check_work, 809 schedule_delayed_work(&hdcp->check_work,
770 DRM_HDCP_CHECK_PERIOD_MS); 810 DRM_HDCP_CHECK_PERIOD_MS);
771out: 811out:
772 mutex_unlock(&connector->hdcp_mutex); 812 mutex_unlock(&hdcp->mutex);
773 return ret; 813 return ret;
774} 814}
775 815
776int intel_hdcp_disable(struct intel_connector *connector) 816int intel_hdcp_disable(struct intel_connector *connector)
777{ 817{
818 struct intel_hdcp *hdcp = &connector->hdcp;
778 int ret = 0; 819 int ret = 0;
779 820
780 if (!connector->hdcp_shim) 821 if (!hdcp->shim)
781 return -ENOENT; 822 return -ENOENT;
782 823
783 mutex_lock(&connector->hdcp_mutex); 824 mutex_lock(&hdcp->mutex);
784 825
785 if (connector->hdcp_value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) { 826 if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
786 connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED; 827 hdcp->value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
787 ret = _intel_hdcp_disable(connector); 828 ret = _intel_hdcp_disable(connector);
788 } 829 }
789 830
790 mutex_unlock(&connector->hdcp_mutex); 831 mutex_unlock(&hdcp->mutex);
791 cancel_delayed_work_sync(&connector->hdcp_check_work); 832 cancel_delayed_work_sync(&hdcp->check_work);
792 return ret; 833 return ret;
793} 834}
794 835
@@ -828,17 +869,18 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
828/* Implements Part 3 of the HDCP authorization procedure */ 869/* Implements Part 3 of the HDCP authorization procedure */
829int intel_hdcp_check_link(struct intel_connector *connector) 870int intel_hdcp_check_link(struct intel_connector *connector)
830{ 871{
872 struct intel_hdcp *hdcp = &connector->hdcp;
831 struct drm_i915_private *dev_priv = connector->base.dev->dev_private; 873 struct drm_i915_private *dev_priv = connector->base.dev->dev_private;
832 struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector); 874 struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
833 enum port port = intel_dig_port->base.port; 875 enum port port = intel_dig_port->base.port;
834 int ret = 0; 876 int ret = 0;
835 877
836 if (!connector->hdcp_shim) 878 if (!hdcp->shim)
837 return -ENOENT; 879 return -ENOENT;
838 880
839 mutex_lock(&connector->hdcp_mutex); 881 mutex_lock(&hdcp->mutex);
840 882
841 if (connector->hdcp_value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED) 883 if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)
842 goto out; 884 goto out;
843 885
844 if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) { 886 if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
@@ -846,17 +888,15 @@ int intel_hdcp_check_link(struct intel_connector *connector)
846 connector->base.name, connector->base.base.id, 888 connector->base.name, connector->base.base.id,
847 I915_READ(PORT_HDCP_STATUS(port))); 889 I915_READ(PORT_HDCP_STATUS(port)));
848 ret = -ENXIO; 890 ret = -ENXIO;
849 connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_DESIRED; 891 hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
850 schedule_work(&connector->hdcp_prop_work); 892 schedule_work(&hdcp->prop_work);
851 goto out; 893 goto out;
852 } 894 }
853 895
854 if (connector->hdcp_shim->check_link(intel_dig_port)) { 896 if (hdcp->shim->check_link(intel_dig_port)) {
855 if (connector->hdcp_value != 897 if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
856 DRM_MODE_CONTENT_PROTECTION_UNDESIRED) { 898 hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
857 connector->hdcp_value = 899 schedule_work(&hdcp->prop_work);
858 DRM_MODE_CONTENT_PROTECTION_ENABLED;
859 schedule_work(&connector->hdcp_prop_work);
860 } 900 }
861 goto out; 901 goto out;
862 } 902 }
@@ -867,20 +907,20 @@ int intel_hdcp_check_link(struct intel_connector *connector)
867 ret = _intel_hdcp_disable(connector); 907 ret = _intel_hdcp_disable(connector);
868 if (ret) { 908 if (ret) {
869 DRM_ERROR("Failed to disable hdcp (%d)\n", ret); 909 DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
870 connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_DESIRED; 910 hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
871 schedule_work(&connector->hdcp_prop_work); 911 schedule_work(&hdcp->prop_work);
872 goto out; 912 goto out;
873 } 913 }
874 914
875 ret = _intel_hdcp_enable(connector); 915 ret = _intel_hdcp_enable(connector);
876 if (ret) { 916 if (ret) {
877 DRM_ERROR("Failed to enable hdcp (%d)\n", ret); 917 DRM_DEBUG_KMS("Failed to enable hdcp (%d)\n", ret);
878 connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_DESIRED; 918 hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
879 schedule_work(&connector->hdcp_prop_work); 919 schedule_work(&hdcp->prop_work);
880 goto out; 920 goto out;
881 } 921 }
882 922
883out: 923out:
884 mutex_unlock(&connector->hdcp_mutex); 924 mutex_unlock(&hdcp->mutex);
885 return ret; 925 return ret;
886} 926}
generated by cgit v1.2.2 (git 2.25.0) at 2025-05-23 16:41:55 -0400