drivers/gpu/drm/zte/zx_vga.c

   1 /*
   2  * Copyright (C) 2017 Sanechips Technology Co., Ltd.
   3  * Copyright 2017 Linaro Ltd.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  */
   9
  10 #include <linux/clk.h>
  11 #include <linux/component.h>
  12 #include <linux/mfd/syscon.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/regmap.h>
  16
  17 #include <drm/drm_atomic_helper.h>
  18 #include <drm/drm_print.h>
  19 #include <drm/drm_probe_helper.h>
  20
  21 #include "zx_drm_drv.h"
  22 #include "zx_vga_regs.h"
  23 #include "zx_vou.h"
  24
  25 struct zx_vga_pwrctrl {
  26         struct regmap *regmap;
  27         u32 reg;
  28         u32 mask;
  29 };
  30
  31 struct zx_vga_i2c {
  32         struct i2c_adapter adap;
  33         struct mutex lock;
  34 };
  35
  36 struct zx_vga {
  37         struct drm_connector connector;
  38         struct drm_encoder encoder;
  39         struct zx_vga_i2c *ddc;
  40         struct device *dev;
  41         void __iomem *mmio;
  42         struct clk *i2c_wclk;
  43         struct zx_vga_pwrctrl pwrctrl;
  44         struct completion complete;
  45         bool connected;
  46 };
  47
  48 #define to_zx_vga(x) container_of(x, struct zx_vga, x)
  49
  50 static void zx_vga_encoder_enable(struct drm_encoder *encoder)
  51 {
  52         struct zx_vga *vga = to_zx_vga(encoder);
  53         struct zx_vga_pwrctrl *pwrctrl = &vga->pwrctrl;
  54
  55         /* Set bit to power up VGA DACs */
  56         regmap_update_bits(pwrctrl->regmap, pwrctrl->reg, pwrctrl->mask,
  57                            pwrctrl->mask);
  58
  59         vou_inf_enable(VOU_VGA, encoder->crtc);
  60 }
  61
  62 static void zx_vga_encoder_disable(struct drm_encoder *encoder)
  63 {
  64         struct zx_vga *vga = to_zx_vga(encoder);
  65         struct zx_vga_pwrctrl *pwrctrl = &vga->pwrctrl;
  66
  67         vou_inf_disable(VOU_VGA, encoder->crtc);
  68
  69         /* Clear bit to power down VGA DACs */
  70         regmap_update_bits(pwrctrl->regmap, pwrctrl->reg, pwrctrl->mask, 0);
  71 }
  72
  73 static const struct drm_encoder_helper_funcs zx_vga_encoder_helper_funcs = {
  74         .enable = zx_vga_encoder_enable,
  75         .disable = zx_vga_encoder_disable,
  76 };
  77
  78 static const struct drm_encoder_funcs zx_vga_encoder_funcs = {
  79         .destroy = drm_encoder_cleanup,
  80 };
  81
  82 static int zx_vga_connector_get_modes(struct drm_connector *connector)
  83 {
  84         struct zx_vga *vga = to_zx_vga(connector);
  85         struct edid *edid;
  86         int ret;
  87
  88         /*
  89          * Clear both detection bits to switch I2C bus from device
  90          * detecting to EDID reading.
  91          */
  92         zx_writel(vga->mmio + VGA_AUTO_DETECT_SEL, 0);
  93
  94         edid = drm_get_edid(connector, &vga->ddc->adap);
  95         if (!edid) {
  96                 /*
  97                  * If EDID reading fails, we set the device state into
  98                  * disconnected.  Locking is not required here, since the
  99                  * VGA_AUTO_DETECT_SEL register write in irq handler cannot
 100                  * be triggered when both detection bits are cleared as above.
 101                  */
 102                 zx_writel(vga->mmio + VGA_AUTO_DETECT_SEL,
 103                           VGA_DETECT_SEL_NO_DEVICE);
 104                 vga->connected = false;
 105                 return 0;
 106         }
 107
 108         /*
 109          * As edid reading succeeds, device must be connected, so we set
 110          * up detection bit for unplug interrupt here.
 111          */
 112         zx_writel(vga->mmio + VGA_AUTO_DETECT_SEL, VGA_DETECT_SEL_HAS_DEVICE);
 113
 114         drm_connector_update_edid_property(connector, edid);
 115         ret = drm_add_edid_modes(connector, edid);
 116         kfree(edid);
 117
 118         return ret;
 119 }
 120
 121 static enum drm_mode_status
 122 zx_vga_connector_mode_valid(struct drm_connector *connector,
 123                             struct drm_display_mode *mode)
 124 {
 125         return MODE_OK;
 126 }
 127
 128 static struct drm_connector_helper_funcs zx_vga_connector_helper_funcs = {
 129         .get_modes = zx_vga_connector_get_modes,
 130         .mode_valid = zx_vga_connector_mode_valid,
 131 };
 132
 133 static enum drm_connector_status
 134 zx_vga_connector_detect(struct drm_connector *connector, bool force)
 135 {
 136         struct zx_vga *vga = to_zx_vga(connector);
 137
 138         return vga->connected ? connector_status_connected :
 139                                 connector_status_disconnected;
 140 }
 141
 142 static const struct drm_connector_funcs zx_vga_connector_funcs = {
 143         .fill_modes = drm_helper_probe_single_connector_modes,
 144         .detect = zx_vga_connector_detect,
 145         .destroy = drm_connector_cleanup,
 146         .reset = drm_atomic_helper_connector_reset,
 147         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 148         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 149 };
 150
 151 static int zx_vga_register(struct drm_device *drm, struct zx_vga *vga)
 152 {
 153         struct drm_encoder *encoder = &vga->encoder;
 154         struct drm_connector *connector = &vga->connector;
 155         struct device *dev = vga->dev;
 156         int ret;
 157
 158         encoder->possible_crtcs = VOU_CRTC_MASK;
 159
 160         ret = drm_encoder_init(drm, encoder, &zx_vga_encoder_funcs,
 161                                DRM_MODE_ENCODER_DAC, NULL);
 162         if (ret) {
 163                 DRM_DEV_ERROR(dev, "failed to init encoder: %d\n", ret);
 164                 return ret;
 165         };
 166
 167         drm_encoder_helper_add(encoder, &zx_vga_encoder_helper_funcs);
 168
 169         vga->connector.polled = DRM_CONNECTOR_POLL_HPD;
 170
 171         ret = drm_connector_init(drm, connector, &zx_vga_connector_funcs,
 172                                  DRM_MODE_CONNECTOR_VGA);
 173         if (ret) {
 174                 DRM_DEV_ERROR(dev, "failed to init connector: %d\n", ret);
 175                 goto clean_encoder;
 176         };
 177
 178         drm_connector_helper_add(connector, &zx_vga_connector_helper_funcs);
 179
 180         ret = drm_connector_attach_encoder(connector, encoder);
 181         if (ret) {
 182                 DRM_DEV_ERROR(dev, "failed to attach encoder: %d\n", ret);
 183                 goto clean_connector;
 184         };
 185
 186         return 0;
 187
 188 clean_connector:
 189         drm_connector_cleanup(connector);
 190 clean_encoder:
 191         drm_encoder_cleanup(encoder);
 192         return ret;
 193 }
 194
 195 static int zx_vga_pwrctrl_init(struct zx_vga *vga)
 196 {
 197         struct zx_vga_pwrctrl *pwrctrl = &vga->pwrctrl;
 198         struct device *dev = vga->dev;
 199         struct of_phandle_args out_args;
 200         struct regmap *regmap;
 201         int ret;
 202
 203         ret = of_parse_phandle_with_fixed_args(dev->of_node,
 204                                 "zte,vga-power-control", 2, 0, &out_args);
 205         if (ret)
 206                 return ret;
 207
 208         regmap = syscon_node_to_regmap(out_args.np);
 209         if (IS_ERR(regmap)) {
 210                 ret = PTR_ERR(regmap);
 211                 goto out;
 212         }
 213
 214         pwrctrl->regmap = regmap;
 215         pwrctrl->reg = out_args.args[0];
 216         pwrctrl->mask = out_args.args[1];
 217
 218 out:
 219         of_node_put(out_args.np);
 220         return ret;
 221 }
 222
 223 static int zx_vga_i2c_read(struct zx_vga *vga, struct i2c_msg *msg)
 224 {
 225         int len = msg->len;
 226         u8 *buf = msg->buf;
 227         u32 offset = 0;
 228         int i;
 229
 230         reinit_completion(&vga->complete);
 231
 232         /* Select combo write */
 233         zx_writel_mask(vga->mmio + VGA_CMD_CFG, VGA_CMD_COMBO, VGA_CMD_COMBO);
 234         zx_writel_mask(vga->mmio + VGA_CMD_CFG, VGA_CMD_RW, 0);
 235
 236         while (len > 0) {
 237                 u32 cnt;
 238
 239                 /* Clear RX FIFO */
 240                 zx_writel_mask(vga->mmio + VGA_RXF_CTRL, VGA_RX_FIFO_CLEAR,
 241                                VGA_RX_FIFO_CLEAR);
 242
 243                 /* Data offset to read from */
 244                 zx_writel(vga->mmio + VGA_SUB_ADDR, offset);
 245
 246                 /* Kick off the transfer */
 247                 zx_writel_mask(vga->mmio + VGA_CMD_CFG, VGA_CMD_TRANS,
 248                                VGA_CMD_TRANS);
 249
 250                 if (!wait_for_completion_timeout(&vga->complete,
 251                                                  msecs_to_jiffies(1000))) {
 252                         DRM_DEV_ERROR(vga->dev, "transfer timeout\n");
 253                         return -ETIMEDOUT;
 254                 }
 255
 256                 cnt = zx_readl(vga->mmio + VGA_RXF_STATUS);
 257                 cnt = (cnt & VGA_RXF_COUNT_MASK) >> VGA_RXF_COUNT_SHIFT;
 258                 /* FIFO status may report more data than we need to read */
 259                 cnt = min_t(u32, len, cnt);
 260
 261                 for (i = 0; i < cnt; i++)
 262                         *buf++ = zx_readl(vga->mmio + VGA_DATA);
 263
 264                 len -= cnt;
 265                 offset += cnt;
 266         }
 267
 268         return 0;
 269 }
 270
 271 static int zx_vga_i2c_write(struct zx_vga *vga, struct i2c_msg *msg)
 272 {
 273         /*
 274          * The DDC I2C adapter is only for reading EDID data, so we assume
 275          * that the write to this adapter must be the EDID data offset.
 276          */
 277         if ((msg->len != 1) || ((msg->addr != DDC_ADDR)))
 278                 return -EINVAL;
 279
 280         /* Hardware will take care of the slave address shifting */
 281         zx_writel(vga->mmio + VGA_DEVICE_ADDR, msg->addr);
 282
 283         return 0;
 284 }
 285
 286 static int zx_vga_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
 287                            int num)
 288 {
 289         struct zx_vga *vga = i2c_get_adapdata(adap);
 290         struct zx_vga_i2c *ddc = vga->ddc;
 291         int ret = 0;
 292         int i;
 293
 294         mutex_lock(&ddc->lock);
 295
 296         for (i = 0; i < num; i++) {
 297                 if (msgs[i].flags & I2C_M_RD)
 298                         ret = zx_vga_i2c_read(vga, &msgs[i]);
 299                 else
 300                         ret = zx_vga_i2c_write(vga, &msgs[i]);
 301
 302                 if (ret < 0)
 303                         break;
 304         }
 305
 306         if (!ret)
 307                 ret = num;
 308
 309         mutex_unlock(&ddc->lock);
 310
 311         return ret;
 312 }
 313
 314 static u32 zx_vga_i2c_func(struct i2c_adapter *adapter)
 315 {
 316         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 317 }
 318
 319 static const struct i2c_algorithm zx_vga_algorithm = {
 320         .master_xfer    = zx_vga_i2c_xfer,
 321         .functionality  = zx_vga_i2c_func,
 322 };
 323
 324 static int zx_vga_ddc_register(struct zx_vga *vga)
 325 {
 326         struct device *dev = vga->dev;
 327         struct i2c_adapter *adap;
 328         struct zx_vga_i2c *ddc;
 329         int ret;
 330
 331         ddc = devm_kzalloc(dev, sizeof(*ddc), GFP_KERNEL);
 332         if (!ddc)
 333                 return -ENOMEM;
 334
 335         vga->ddc = ddc;
 336         mutex_init(&ddc->lock);
 337
 338         adap = &ddc->adap;
 339         adap->owner = THIS_MODULE;
 340         adap->class = I2C_CLASS_DDC;
 341         adap->dev.parent = dev;
 342         adap->algo = &zx_vga_algorithm;
 343         snprintf(adap->name, sizeof(adap->name), "zx vga i2c");
 344
 345         ret = i2c_add_adapter(adap);
 346         if (ret) {
 347                 DRM_DEV_ERROR(dev, "failed to add I2C adapter: %d\n", ret);
 348                 return ret;
 349         }
 350
 351         i2c_set_adapdata(adap, vga);
 352
 353         return 0;
 354 }
 355
 356 static irqreturn_t zx_vga_irq_thread(int irq, void *dev_id)
 357 {
 358         struct zx_vga *vga = dev_id;
 359
 360         drm_helper_hpd_irq_event(vga->connector.dev);
 361
 362         return IRQ_HANDLED;
 363 }
 364
 365 static irqreturn_t zx_vga_irq_handler(int irq, void *dev_id)
 366 {
 367         struct zx_vga *vga = dev_id;
 368         u32 status;
 369
 370         status = zx_readl(vga->mmio + VGA_I2C_STATUS);
 371
 372         /* Clear interrupt status */
 373         zx_writel_mask(vga->mmio + VGA_I2C_STATUS, VGA_CLEAR_IRQ,
 374                        VGA_CLEAR_IRQ);
 375
 376         if (status & VGA_DEVICE_CONNECTED) {
 377                 /*
 378                  * Since VGA_DETECT_SEL bits need to be reset for switching DDC
 379                  * bus from device detection to EDID read, rather than setting
 380                  * up HAS_DEVICE bit here, we need to do that in .get_modes
 381                  * hook for unplug detecting after EDID read succeeds.
 382                  */
 383                 vga->connected = true;
 384                 return IRQ_WAKE_THREAD;
 385         }
 386
 387         if (status & VGA_DEVICE_DISCONNECTED) {
 388                 zx_writel(vga->mmio + VGA_AUTO_DETECT_SEL,
 389                           VGA_DETECT_SEL_NO_DEVICE);
 390                 vga->connected = false;
 391                 return IRQ_WAKE_THREAD;
 392         }
 393
 394         if (status & VGA_TRANS_DONE) {
 395                 complete(&vga->complete);
 396                 return IRQ_HANDLED;
 397         }
 398
 399         return IRQ_NONE;
 400 }
 401
 402 static void zx_vga_hw_init(struct zx_vga *vga)
 403 {
 404         unsigned long ref = clk_get_rate(vga->i2c_wclk);
 405         int div;
 406
 407         /*
 408          * Set up I2C fast speed divider per formula below to get 400kHz.
 409          *   scl = ref / ((div + 1) * 4)
 410          */
 411         div = DIV_ROUND_UP(ref / 1000, 400 * 4) - 1;
 412         zx_writel(vga->mmio + VGA_CLK_DIV_FS, div);
 413
 414         /* Set up device detection */
 415         zx_writel(vga->mmio + VGA_AUTO_DETECT_PARA, 0x80);
 416         zx_writel(vga->mmio + VGA_AUTO_DETECT_SEL, VGA_DETECT_SEL_NO_DEVICE);
 417
 418         /*
 419          * We need to poke monitor via DDC bus to get connection irq
 420          * start working.
 421          */
 422         zx_writel(vga->mmio + VGA_DEVICE_ADDR, DDC_ADDR);
 423         zx_writel_mask(vga->mmio + VGA_CMD_CFG, VGA_CMD_TRANS, VGA_CMD_TRANS);
 424 }
 425
 426 static int zx_vga_bind(struct device *dev, struct device *master, void *data)
 427 {
 428         struct platform_device *pdev = to_platform_device(dev);
 429         struct drm_device *drm = data;
 430         struct resource *res;
 431         struct zx_vga *vga;
 432         int irq;
 433         int ret;
 434
 435         vga = devm_kzalloc(dev, sizeof(*vga), GFP_KERNEL);
 436         if (!vga)
 437                 return -ENOMEM;
 438
 439         vga->dev = dev;
 440         dev_set_drvdata(dev, vga);
 441
 442         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 443         vga->mmio = devm_ioremap_resource(dev, res);
 444         if (IS_ERR(vga->mmio))
 445                 return PTR_ERR(vga->mmio);
 446
 447         irq = platform_get_irq(pdev, 0);
 448         if (irq < 0)
 449                 return irq;
 450
 451         vga->i2c_wclk = devm_clk_get(dev, "i2c_wclk");
 452         if (IS_ERR(vga->i2c_wclk)) {
 453                 ret = PTR_ERR(vga->i2c_wclk);
 454                 DRM_DEV_ERROR(dev, "failed to get i2c_wclk: %d\n", ret);
 455                 return ret;
 456         }
 457
 458         ret = zx_vga_pwrctrl_init(vga);
 459         if (ret) {
 460                 DRM_DEV_ERROR(dev, "failed to init power control: %d\n", ret);
 461                 return ret;
 462         }
 463
 464         ret = zx_vga_ddc_register(vga);
 465         if (ret) {
 466                 DRM_DEV_ERROR(dev, "failed to register ddc: %d\n", ret);
 467                 return ret;
 468         }
 469
 470         ret = zx_vga_register(drm, vga);
 471         if (ret) {
 472                 DRM_DEV_ERROR(dev, "failed to register vga: %d\n", ret);
 473                 return ret;
 474         }
 475
 476         init_completion(&vga->complete);
 477
 478         ret = devm_request_threaded_irq(dev, irq, zx_vga_irq_handler,
 479                                         zx_vga_irq_thread, IRQF_SHARED,
 480                                         dev_name(dev), vga);
 481         if (ret) {
 482                 DRM_DEV_ERROR(dev, "failed to request threaded irq: %d\n", ret);
 483                 return ret;
 484         }
 485
 486         ret = clk_prepare_enable(vga->i2c_wclk);
 487         if (ret)
 488                 return ret;
 489
 490         zx_vga_hw_init(vga);
 491
 492         return 0;
 493 }
 494
 495 static void zx_vga_unbind(struct device *dev, struct device *master,
 496                           void *data)
 497 {
 498         struct zx_vga *vga = dev_get_drvdata(dev);
 499
 500         clk_disable_unprepare(vga->i2c_wclk);
 501 }
 502
 503 static const struct component_ops zx_vga_component_ops = {
 504         .bind = zx_vga_bind,
 505         .unbind = zx_vga_unbind,
 506 };
 507
 508 static int zx_vga_probe(struct platform_device *pdev)
 509 {
 510         return component_add(&pdev->dev, &zx_vga_component_ops);
 511 }
 512
 513 static int zx_vga_remove(struct platform_device *pdev)
 514 {
 515         component_del(&pdev->dev, &zx_vga_component_ops);
 516         return 0;
 517 }
 518
 519 static const struct of_device_id zx_vga_of_match[] = {
 520         { .compatible = "zte,zx296718-vga", },
 521         { /* end */ },
 522 };
 523 MODULE_DEVICE_TABLE(of, zx_vga_of_match);
 524
 525 struct platform_driver zx_vga_driver = {
 526         .probe = zx_vga_probe,
 527         .remove = zx_vga_remove,
 528         .driver = {
 529                 .name = "zx-vga",
 530                 .of_match_table = zx_vga_of_match,
 531         },
 532 };