shared-core/radeon_ms_i2c.c

   1 /*
   2  * Copyright 2007 Jérôme Glisse
   3  * Copyright 2007 Alex Deucher
   4  * Copyright 2007 Dave Airlie
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining
   8  * a copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation on the rights to use, copy, modify, merge,
  11  * publish, distribute, sublicense, and/or sell copies of the Software,
  12  * and to permit persons to whom the Software is furnished to do so,
  13  * subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial
  17  * portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22  * NON-INFRINGEMENT.  IN NO EVENT SHALL ATI, VA LINUX SYSTEMS AND/OR
  23  * THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26  * DEALINGS IN THE SOFTWARE.
  27  */
  28 #include "radeon_ms.h"
  29
  30 static int get_clock(void *data)
  31 {
  32         struct radeon_ms_i2c *i2c = data;
  33         struct drm_radeon_private *dev_priv = i2c->drm_dev->dev_private;
  34         int v;
  35
  36         switch (i2c->reg) {
  37         case VIPPAD_EN:
  38                 v = MMIO_R(VIPPAD_Y);
  39                 if ((REG_G(VIPPAD_Y, VIPPAD_Y_VHAD, v) & 2)) {
  40                         v = 1;
  41                 } else {
  42                         v = 0;
  43                 }
  44                 break;
  45         case VIPPAD1_EN:
  46                 v = MMIO_R(VIPPAD1_Y);
  47                 if ((REG_G(VIPPAD1_Y, VIPPAD_Y_DVODATA, v) & 8)) {
  48                         v = 1;
  49                 } else {
  50                         v = 0;
  51                 }
  52                 break;
  53         case GPIO_DDC1:
  54                 v = MMIO_R(GPIO_DDC1);
  55                 if ((GPIO_DDC1__DDC1_CLK_INPUT & v)) {
  56                         v = 1;
  57                 } else {
  58                         v = 0;
  59                 }
  60                 break;
  61         case GPIO_DDC2:
  62                 v = MMIO_R(GPIO_DDC2);
  63                 if ((GPIO_DDC2__DDC2_CLK_INPUT & v)) {
  64                         v = 1;
  65                 } else {
  66                         v = 0;
  67                 }
  68                 break;
  69         case GPIO_MONID:
  70                 v = MMIO_R(GPIO_MONID);
  71                 if ((GPIO_MONID__GPIO_MONID_1_INPUT & v)) {
  72                         v = 1;
  73                 } else {
  74                         v = 0;
  75                 }
  76                 break;
  77         case GPIO_CRT2_DDC:
  78                 v = MMIO_R(GPIO_CRT2_DDC);
  79                 if ((GPIO_CRT2_DDC__CRT2_DDC_CLK_INPUT & v)) {
  80                         v = 1;
  81                 } else {
  82                         v = 0;
  83                 }
  84                 break;
  85         default:
  86                 v = 0;
  87                 break;
  88         }
  89         return v;
  90 }
  91
  92 static int get_data(void *data)
  93 {
  94         struct radeon_ms_i2c *i2c = data;
  95         struct drm_radeon_private *dev_priv = i2c->drm_dev->dev_private;
  96         int v;
  97
  98         switch (i2c->reg) {
  99         case VIPPAD_EN:
 100                 v = MMIO_R(VIPPAD_Y);
 101                 if ((REG_G(VIPPAD_Y, VIPPAD_Y_VHAD, v) & 1)) {
 102                         v = 1;
 103                 } else {
 104                         v = 0;
 105                 }
 106                 break;
 107         case VIPPAD1_EN:
 108                 v = MMIO_R(VIPPAD1_Y);
 109                 if ((REG_G(VIPPAD1_Y, VIPPAD_Y_DVODATA, v) & 4)) {
 110                         v = 1;
 111                 } else {
 112                         v = 0;
 113                 }
 114                 break;
 115         case GPIO_DDC1:
 116                 v = MMIO_R(GPIO_DDC1);
 117                 if ((GPIO_DDC1__DDC1_DATA_INPUT & v)) {
 118                         v = 1;
 119                 } else {
 120                         v = 0;
 121                 }
 122                 break;
 123         case GPIO_DDC2:
 124                 v = MMIO_R(GPIO_DDC2);
 125                 if ((GPIO_DDC2__DDC2_DATA_INPUT & v)) {
 126                         v = 1;
 127                 } else {
 128                         v = 0;
 129                 }
 130                 break;
 131         case GPIO_MONID:
 132                 v = MMIO_R(GPIO_MONID);
 133                 if ((GPIO_MONID__GPIO_MONID_0_INPUT & v)) {
 134                         v = 1;
 135                 } else {
 136                         v = 0;
 137                 }
 138                 break;
 139         case GPIO_CRT2_DDC:
 140                 v = MMIO_R(GPIO_CRT2_DDC);
 141                 if ((GPIO_CRT2_DDC__CRT2_DDC_DATA_INPUT & v)) {
 142                         v = 1;
 143                 } else {
 144                         v = 0;
 145                 }
 146                 break;
 147         default:
 148                 v = 0;
 149                 break;
 150         }
 151         return v;
 152 }
 153
 154 static void set_clock(void *i2c_priv, int clock)
 155 {
 156         struct radeon_ms_i2c *i2c = i2c_priv;
 157         struct drm_radeon_private *dev_priv = i2c->drm_dev->dev_private;
 158         int v, line;
 159
 160         v = MMIO_R(i2c->reg);
 161         switch (i2c->reg) {
 162         case VIPPAD_EN:
 163                 line = REG_G(VIPPAD_EN, VIPPAD_EN_VHAD, v) & ~2;
 164                 v &= ~VIPPAD_EN__VIPPAD_EN_VHAD__MASK;
 165                 if (!clock) {
 166                         v |= REG_S(VIPPAD_EN, VIPPAD_EN_VHAD, line | 2);
 167                 } else {
 168                         v |= REG_S(VIPPAD_EN, VIPPAD_EN_VHAD, line);
 169                 }
 170                 break;
 171         case VIPPAD1_EN:
 172                 line = REG_G(VIPPAD1_EN, VIPPAD_EN_DVODATA, v) & ~8;
 173                 v &= ~VIPPAD1_EN__VIPPAD_EN_DVODATA__MASK;
 174                 if (!clock) {
 175                         v |= REG_S(VIPPAD1_EN, VIPPAD_EN_DVODATA, line | 8);
 176                 } else {
 177                         v |= REG_S(VIPPAD1_EN, VIPPAD_EN_DVODATA, line);
 178                 }
 179                 break;
 180         case GPIO_DDC1:
 181                 v &= ~GPIO_DDC1__DDC1_CLK_OUT_EN;
 182                 if (!clock) {
 183                         v |= GPIO_DDC1__DDC1_CLK_OUT_EN;
 184                 }
 185                 break;
 186         case GPIO_DDC2:
 187                 v &= ~GPIO_DDC2__DDC2_CLK_OUT_EN;
 188                 if (!clock) {
 189                         v |= GPIO_DDC2__DDC2_CLK_OUT_EN;
 190                 }
 191                 break;
 192         case GPIO_MONID:
 193                 v &= ~GPIO_MONID__GPIO_MONID_1_OUT_EN;
 194                 if (!clock) {
 195                         v |= GPIO_MONID__GPIO_MONID_1_OUT_EN;
 196                 }
 197                 break;
 198         case GPIO_CRT2_DDC:
 199                 v &= ~GPIO_CRT2_DDC__CRT2_DDC_CLK_OUT_EN;
 200                 if (!clock) {
 201                         v |= GPIO_CRT2_DDC__CRT2_DDC_CLK_OUT_EN;
 202                 }
 203                 break;
 204         default:
 205                 return;
 206         }
 207         MMIO_W(i2c->reg, v);
 208 }
 209
 210 static void set_data(void *i2c_priv, int data)
 211 {
 212         struct radeon_ms_i2c *i2c = i2c_priv;
 213         struct drm_radeon_private *dev_priv = i2c->drm_dev->dev_private;
 214         int v, line;
 215
 216         v = MMIO_R(i2c->reg);
 217         switch (i2c->reg) {
 218         case VIPPAD_EN:
 219                 line = REG_G(VIPPAD_EN, VIPPAD_EN_VHAD, v) & ~1;
 220                 v &= ~VIPPAD_EN__VIPPAD_EN_VHAD__MASK;
 221                 if (!data) {
 222                         v |= REG_S(VIPPAD_EN, VIPPAD_EN_VHAD, line | 1);
 223                 } else {
 224                         v |= REG_S(VIPPAD_EN, VIPPAD_EN_VHAD, line);
 225                 }
 226                 break;
 227         case VIPPAD1_EN:
 228                 line = REG_G(VIPPAD1_EN, VIPPAD_EN_DVODATA, v) & ~4;
 229                 v &= ~VIPPAD1_EN__VIPPAD_EN_DVODATA__MASK;
 230                 if (!data) {
 231                         v |= REG_S(VIPPAD1_EN, VIPPAD_EN_DVODATA, line | 4);
 232                 } else {
 233                         v |= REG_S(VIPPAD1_EN, VIPPAD_EN_DVODATA, line);
 234                 }
 235                 break;
 236         case GPIO_DDC1:
 237                 v &= ~GPIO_DDC1__DDC1_DATA_OUT_EN;
 238                 if (!data) {
 239                         v |= GPIO_DDC1__DDC1_DATA_OUT_EN;
 240                 }
 241                 break;
 242         case GPIO_DDC2:
 243                 v &= ~GPIO_DDC2__DDC2_DATA_OUT_EN;
 244                 if (!data) {
 245                         v |= GPIO_DDC2__DDC2_DATA_OUT_EN;
 246                 }
 247                 break;
 248         case GPIO_MONID:
 249                 v &= ~GPIO_MONID__GPIO_MONID_0_OUT_EN;
 250                 if (!data) {
 251                         v |= GPIO_MONID__GPIO_MONID_0_OUT_EN;
 252                 }
 253                 break;
 254         case GPIO_CRT2_DDC:
 255                 v &= ~GPIO_CRT2_DDC__CRT2_DDC_DATA_OUT_EN;
 256                 if (!data) {
 257                         v |= GPIO_CRT2_DDC__CRT2_DDC_DATA_OUT_EN;
 258                 }
 259                 break;
 260         default:
 261                 return;
 262         }
 263         MMIO_W(i2c->reg, v);
 264 }
 265
 266 /**
 267  * radeon_ms_i2c_create - instantiate an radeon i2c bus on specified GPIO reg
 268  * @dev: DRM device
 269  * @output: driver specific output device
 270  * @reg: GPIO reg to use
 271  * @name: name for this bus
 272  *
 273  * Creates and registers a new i2c bus with the Linux i2c layer, for use
 274  * in output probing and control (e.g. DDC or SDVO control functions).
 275  *
 276  */
 277 struct radeon_ms_i2c *radeon_ms_i2c_create(struct drm_device *dev,
 278                                            const uint32_t reg,
 279                                            const char *name)
 280 {
 281         struct radeon_ms_i2c *i2c;
 282         int ret;
 283
 284         i2c = drm_alloc(sizeof(struct radeon_ms_i2c), DRM_MEM_DRIVER);
 285         if (i2c == NULL) {
 286                 return NULL;
 287         }
 288         memset(i2c, 0, sizeof(struct radeon_ms_i2c));
 289
 290         i2c->drm_dev = dev;
 291         i2c->reg = reg;
 292         snprintf(i2c->adapter.name, I2C_NAME_SIZE, "radeon-%s", name);
 293         i2c->adapter.owner = THIS_MODULE;
 294         /* fixme need to take a look at what its needed for */
 295         i2c->adapter.id = I2C_HW_B_RADEON;
 296         i2c->adapter.algo_data = &i2c->algo;
 297         i2c->adapter.dev.parent = &dev->pdev->dev;
 298         i2c->algo.setsda = set_data;
 299         i2c->algo.setscl = set_clock;
 300         i2c->algo.getsda = get_data;
 301         i2c->algo.getscl = get_clock;
 302         i2c->algo.udelay = 20;
 303         i2c->algo.timeout = usecs_to_jiffies(2200);
 304         i2c->algo.data = i2c;
 305
 306         i2c_set_adapdata(&i2c->adapter, i2c);
 307
 308         ret = i2c_bit_add_bus(&i2c->adapter);
 309         if(ret) {
 310                 DRM_INFO("[radeon_ms] failed to register I2C '%s' bus (0x%X)\n",
 311                          i2c->adapter.name, reg);
 312                 goto out_free;
 313         }
 314         DRM_INFO("[radeon_ms] registered I2C '%s' bus (0x%X)\n",
 315                  i2c->adapter.name, reg);
 316         return i2c;
 317
 318 out_free:
 319         drm_free(i2c, sizeof(struct radeon_ms_i2c), DRM_MEM_DRIVER);
 320         return NULL;
 321 }
 322
 323 /**
 324  * radeon_ms_i2c_destroy - unregister and free i2c bus resources
 325  * @output: channel to free
 326  *
 327  * Unregister the adapter from the i2c layer, then free the structure.
 328  */
 329 void radeon_ms_i2c_destroy(struct radeon_ms_i2c *i2c)
 330 {
 331         if (i2c == NULL) {
 332                 return;
 333         }
 334         i2c_del_adapter(&i2c->adapter);
 335         drm_free(i2c, sizeof(struct radeon_ms_i2c), DRM_MEM_DRIVER);
 336 }