root/drivers/gpu/drm/pl111/pl111_vexpress.c

DEFINITIONS

1. pl111_vexpress_clcd_init
2. vexpress_muxfpga_probe
3. vexpress_muxfpga_init

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Versatile Express PL111 handling
   4  * Copyright (C) 2018 Linus Walleij
   5  *
   6  * This module binds to the "arm,vexpress-muxfpga" device on the
   7  * Versatile Express configuration bus and sets up which CLCD instance
   8  * gets muxed out on the DVI bridge.
   9  */
  10 #include <linux/device.h>
  11 #include <linux/module.h>
  12 #include <linux/regmap.h>
  13 #include <linux/vexpress.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/of.h>
  16 #include <linux/of_address.h>
  17 #include <linux/of_platform.h>
  18 #include "pl111_drm.h"
  19 #include "pl111_vexpress.h"
  20 
  21 #define VEXPRESS_FPGAMUX_MOTHERBOARD            0x00
  22 #define VEXPRESS_FPGAMUX_DAUGHTERBOARD_1        0x01
  23 #define VEXPRESS_FPGAMUX_DAUGHTERBOARD_2        0x02
  24 
  25 int pl111_vexpress_clcd_init(struct device *dev,
  26                              struct pl111_drm_dev_private *priv,
  27                              struct regmap *map)
  28 {
  29         struct device_node *root;
  30         struct device_node *child;
  31         struct device_node *ct_clcd = NULL;
  32         bool has_coretile_clcd = false;
  33         bool has_coretile_hdlcd = false;
  34         bool mux_motherboard = true;
  35         u32 val;
  36         int ret;
  37 
  38         /*
  39          * Check if we have a CLCD or HDLCD on the core tile by checking if a
  40          * CLCD or HDLCD is available in the root of the device tree.
  41          */
  42         root = of_find_node_by_path("/");
  43         if (!root)
  44                 return -EINVAL;
  45 
  46         for_each_available_child_of_node(root, child) {
  47                 if (of_device_is_compatible(child, "arm,pl111")) {
  48                         has_coretile_clcd = true;
  49                         ct_clcd = child;
  50                         break;
  51                 }
  52                 if (of_device_is_compatible(child, "arm,hdlcd")) {
  53                         has_coretile_hdlcd = true;
  54                         of_node_put(child);
  55                         break;
  56                 }
  57         }
  58 
  59         of_node_put(root);
  60 
  61         /*
  62          * If there is a coretile HDLCD and it has a driver,
  63          * do not mux the CLCD on the motherboard to the DVI.
  64          */
  65         if (has_coretile_hdlcd && IS_ENABLED(CONFIG_DRM_HDLCD))
  66                 mux_motherboard = false;
  67 
  68         /*
  69          * On the Vexpress CA9 we let the CLCD on the coretile
  70          * take precedence, so also in this case do not mux the
  71          * motherboard to the DVI.
  72          */
  73         if (has_coretile_clcd)
  74                 mux_motherboard = false;
  75 
  76         if (mux_motherboard) {
  77                 dev_info(dev, "DVI muxed to motherboard CLCD\n");
  78                 val = VEXPRESS_FPGAMUX_MOTHERBOARD;
  79         } else if (ct_clcd == dev->of_node) {
  80                 dev_info(dev,
  81                          "DVI muxed to daughterboard 1 (core tile) CLCD\n");
  82                 val = VEXPRESS_FPGAMUX_DAUGHTERBOARD_1;
  83         } else {
  84                 dev_info(dev, "core tile graphics present\n");
  85                 dev_info(dev, "this device will be deactivated\n");
  86                 return -ENODEV;
  87         }
  88 
  89         ret = regmap_write(map, 0, val);
  90         if (ret) {
  91                 dev_err(dev, "error setting DVI muxmode\n");
  92                 return -ENODEV;
  93         }
  94 
  95         return 0;
  96 }
  97 
  98 /*
  99  * This sets up the regmap pointer that will then be retrieved by
 100  * the detection code in pl111_versatile.c and passed in to the
 101  * pl111_vexpress_clcd_init() function above.
 102  */
 103 static int vexpress_muxfpga_probe(struct platform_device *pdev)
 104 {
 105         struct device *dev = &pdev->dev;
 106         struct regmap *map;
 107 
 108         map = devm_regmap_init_vexpress_config(&pdev->dev);
 109         if (IS_ERR(map))
 110                 return PTR_ERR(map);
 111         dev_set_drvdata(dev, map);
 112 
 113         return 0;
 114 }
 115 
 116 static const struct of_device_id vexpress_muxfpga_match[] = {
 117         { .compatible = "arm,vexpress-muxfpga", },
 118         {}
 119 };
 120 
 121 static struct platform_driver vexpress_muxfpga_driver = {
 122         .driver = {
 123                 .name = "vexpress-muxfpga",
 124                 .of_match_table = of_match_ptr(vexpress_muxfpga_match),
 125         },
 126         .probe = vexpress_muxfpga_probe,
 127 };
 128 
 129 int vexpress_muxfpga_init(void)
 130 {
 131         int ret;
 132 
 133         ret = platform_driver_register(&vexpress_muxfpga_driver);
 134         /* -EBUSY just means this driver is already registered */
 135         if (ret == -EBUSY)
 136                 ret = 0;
 137         return ret;
 138 }