Pileus Git - ~andy/linux/blob - drivers/gpu/drm/nouveau/core/subdev/i2c/base.c

   1 /*
   2  * Copyright 2013 Red Hat Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Ben Skeggs
  23  */
  24
  25 #include <core/option.h>
  26
  27 #include <subdev/bios.h>
  28 #include <subdev/bios/dcb.h>
  29 #include <subdev/bios/i2c.h>
  30 #include <subdev/i2c.h>
  31 #include <subdev/vga.h>
  32
  33 /******************************************************************************
  34  * interface to linux i2c bit-banging algorithm
  35  *****************************************************************************/
  36
  37 #ifdef CONFIG_NOUVEAU_I2C_INTERNAL_DEFAULT
  38 #define CSTMSEL true
  39 #else
  40 #define CSTMSEL false
  41 #endif
  42
  43 static int
  44 nouveau_i2c_pre_xfer(struct i2c_adapter *adap)
  45 {
  46         struct i2c_algo_bit_data *bit = adap->algo_data;
  47         struct nouveau_i2c_port *port = bit->data;
  48         if (port->func->acquire)
  49                 port->func->acquire(port);
  50         return 0;
  51 }
  52
  53 static void
  54 nouveau_i2c_setscl(void *data, int state)
  55 {
  56         struct nouveau_i2c_port *port = data;
  57         port->func->drive_scl(port, state);
  58 }
  59
  60 static void
  61 nouveau_i2c_setsda(void *data, int state)
  62 {
  63         struct nouveau_i2c_port *port = data;
  64         port->func->drive_sda(port, state);
  65 }
  66
  67 static int
  68 nouveau_i2c_getscl(void *data)
  69 {
  70         struct nouveau_i2c_port *port = data;
  71         return port->func->sense_scl(port);
  72 }
  73
  74 static int
  75 nouveau_i2c_getsda(void *data)
  76 {
  77         struct nouveau_i2c_port *port = data;
  78         return port->func->sense_sda(port);
  79 }
  80
  81 /******************************************************************************
  82  * base i2c "port" class implementation
  83  *****************************************************************************/
  84
  85 void
  86 _nouveau_i2c_port_dtor(struct nouveau_object *object)
  87 {
  88         struct nouveau_i2c_port *port = (void *)object;
  89         i2c_del_adapter(&port->adapter);
  90         nouveau_object_destroy(&port->base);
  91 }
  92
  93 int
  94 nouveau_i2c_port_create_(struct nouveau_object *parent,
  95                          struct nouveau_object *engine,
  96                          struct nouveau_oclass *oclass, u8 index,
  97                          const struct i2c_algorithm *algo,
  98                          int size, void **pobject)
  99 {
 100         struct nouveau_device *device = nv_device(parent);
 101         struct nouveau_i2c *i2c = (void *)engine;
 102         struct nouveau_i2c_port *port;
 103         int ret;
 104
 105         ret = nouveau_object_create_(parent, engine, oclass, 0, size, pobject);
 106         port = *pobject;
 107         if (ret)
 108                 return ret;
 109
 110         snprintf(port->adapter.name, sizeof(port->adapter.name),
 111                  "nouveau-%s-%d", device->name, index);
 112         port->adapter.owner = THIS_MODULE;
 113         port->adapter.dev.parent = &device->pdev->dev;
 114         port->index = index;
 115         i2c_set_adapdata(&port->adapter, i2c);
 116
 117         if ( algo == &nouveau_i2c_bit_algo &&
 118             !nouveau_boolopt(device->cfgopt, "NvI2C", CSTMSEL)) {
 119                 struct i2c_algo_bit_data *bit;
 120
 121                 bit = kzalloc(sizeof(*bit), GFP_KERNEL);
 122                 if (!bit)
 123                         return -ENOMEM;
 124
 125                 bit->udelay = 10;
 126                 bit->timeout = usecs_to_jiffies(2200);
 127                 bit->data = port;
 128                 bit->pre_xfer = nouveau_i2c_pre_xfer;
 129                 bit->setsda = nouveau_i2c_setsda;
 130                 bit->setscl = nouveau_i2c_setscl;
 131                 bit->getsda = nouveau_i2c_getsda;
 132                 bit->getscl = nouveau_i2c_getscl;
 133
 134                 port->adapter.algo_data = bit;
 135                 ret = i2c_bit_add_bus(&port->adapter);
 136         } else {
 137                 port->adapter.algo_data = port;
 138                 port->adapter.algo = algo;
 139                 ret = i2c_add_adapter(&port->adapter);
 140         }
 141
 142         /* drop port's i2c subdev refcount, i2c handles this itself */
 143         if (ret == 0) {
 144                 list_add_tail(&port->head, &i2c->ports);
 145                 atomic_dec(&engine->refcount);
 146         }
 147
 148         return ret;
 149 }
 150
 151 /******************************************************************************
 152  * base i2c subdev class implementation
 153  *****************************************************************************/
 154
 155 static struct nouveau_i2c_port *
 156 nouveau_i2c_find(struct nouveau_i2c *i2c, u8 index)
 157 {
 158         struct nouveau_bios *bios = nouveau_bios(i2c);
 159         struct nouveau_i2c_port *port;
 160
 161         if (index == NV_I2C_DEFAULT(0) ||
 162             index == NV_I2C_DEFAULT(1)) {
 163                 u8  ver, hdr, cnt, len;
 164                 u16 i2c = dcb_i2c_table(bios, &ver, &hdr, &cnt, &len);
 165                 if (i2c && ver >= 0x30) {
 166                         u8 auxidx = nv_ro08(bios, i2c + 4);
 167                         if (index == NV_I2C_DEFAULT(0))
 168                                 index = (auxidx & 0x0f) >> 0;
 169                         else
 170                                 index = (auxidx & 0xf0) >> 4;
 171                 } else {
 172                         index = 2;
 173                 }
 174         }
 175
 176         list_for_each_entry(port, &i2c->ports, head) {
 177                 if (port->index == index)
 178                         return port;
 179         }
 180
 181         return NULL;
 182 }
 183
 184 static struct nouveau_i2c_port *
 185 nouveau_i2c_find_type(struct nouveau_i2c *i2c, u16 type)
 186 {
 187         struct nouveau_i2c_port *port;
 188
 189         list_for_each_entry(port, &i2c->ports, head) {
 190                 if (nv_hclass(port) == type)
 191                         return port;
 192         }
 193
 194         return NULL;
 195 }
 196
 197 static int
 198 nouveau_i2c_identify(struct nouveau_i2c *i2c, int index, const char *what,
 199                      struct i2c_board_info *info,
 200                      bool (*match)(struct nouveau_i2c_port *,
 201                                    struct i2c_board_info *))
 202 {
 203         struct nouveau_i2c_port *port = nouveau_i2c_find(i2c, index);
 204         int i;
 205
 206         if (!port) {
 207                 nv_debug(i2c, "no bus when probing %s on %d\n", what, index);
 208                 return -ENODEV;
 209         }
 210
 211         nv_debug(i2c, "probing %ss on bus: %d\n", what, port->index);
 212         for (i = 0; info[i].addr; i++) {
 213                 if (nv_probe_i2c(port, info[i].addr) &&
 214                     (!match || match(port, &info[i]))) {
 215                         nv_info(i2c, "detected %s: %s\n", what, info[i].type);
 216                         return i;
 217                 }
 218         }
 219
 220         nv_debug(i2c, "no devices found.\n");
 221         return -ENODEV;
 222 }
 223
 224 int
 225 _nouveau_i2c_fini(struct nouveau_object *object, bool suspend)
 226 {
 227         struct nouveau_i2c *i2c = (void *)object;
 228         struct nouveau_i2c_port *port;
 229         int ret;
 230
 231         list_for_each_entry(port, &i2c->ports, head) {
 232                 ret = nv_ofuncs(port)->fini(nv_object(port), suspend);
 233                 if (ret && suspend)
 234                         goto fail;
 235         }
 236
 237         return nouveau_subdev_fini(&i2c->base, suspend);
 238 fail:
 239         list_for_each_entry_continue_reverse(port, &i2c->ports, head) {
 240                 nv_ofuncs(port)->init(nv_object(port));
 241         }
 242
 243         return ret;
 244 }
 245
 246 int
 247 _nouveau_i2c_init(struct nouveau_object *object)
 248 {
 249         struct nouveau_i2c *i2c = (void *)object;
 250         struct nouveau_i2c_port *port;
 251         int ret;
 252
 253         ret = nouveau_subdev_init(&i2c->base);
 254         if (ret == 0) {
 255                 list_for_each_entry(port, &i2c->ports, head) {
 256                         ret = nv_ofuncs(port)->init(nv_object(port));
 257                         if (ret)
 258                                 goto fail;
 259                 }
 260         }
 261
 262         return ret;
 263 fail:
 264         list_for_each_entry_continue_reverse(port, &i2c->ports, head) {
 265                 nv_ofuncs(port)->fini(nv_object(port), false);
 266         }
 267
 268         return ret;
 269 }
 270
 271 void
 272 _nouveau_i2c_dtor(struct nouveau_object *object)
 273 {
 274         struct nouveau_i2c *i2c = (void *)object;
 275         struct nouveau_i2c_port *port, *temp;
 276
 277         list_for_each_entry_safe(port, temp, &i2c->ports, head) {
 278                 nouveau_object_ref(NULL, (struct nouveau_object **)&port);
 279         }
 280
 281         nouveau_subdev_destroy(&i2c->base);
 282 }
 283
 284 static struct nouveau_oclass *
 285 nouveau_i2c_extdev_sclass[] = {
 286         nouveau_anx9805_sclass,
 287 };
 288
 289 int
 290 nouveau_i2c_create_(struct nouveau_object *parent,
 291                     struct nouveau_object *engine,
 292                     struct nouveau_oclass *oclass,
 293                     struct nouveau_oclass *sclass,
 294                     int length, void **pobject)
 295 {
 296         struct nouveau_bios *bios = nouveau_bios(parent);
 297         struct nouveau_i2c *i2c;
 298         struct nouveau_object *object;
 299         struct dcb_i2c_entry info;
 300         int ret, i, j, index = -1;
 301         struct dcb_output outp;
 302         u8  ver, hdr;
 303         u32 data;
 304
 305         ret = nouveau_subdev_create(parent, engine, oclass, 0,
 306                                     "I2C", "i2c", &i2c);
 307         *pobject = nv_object(i2c);
 308         if (ret)
 309                 return ret;
 310
 311         i2c->find = nouveau_i2c_find;
 312         i2c->find_type = nouveau_i2c_find_type;
 313         i2c->identify = nouveau_i2c_identify;
 314         INIT_LIST_HEAD(&i2c->ports);
 315
 316         while (!dcb_i2c_parse(bios, ++index, &info)) {
 317                 if (info.type == DCB_I2C_UNUSED)
 318                         continue;
 319
 320                 oclass = sclass;
 321                 do {
 322                         ret = -EINVAL;
 323                         if (oclass->handle == info.type) {
 324                                 ret = nouveau_object_ctor(*pobject, *pobject,
 325                                                           oclass, &info,
 326                                                           index, &object);
 327                         }
 328                 } while (ret && (++oclass)->handle);
 329         }
 330
 331         /* in addition to the busses specified in the i2c table, there
 332          * may be ddc/aux channels hiding behind external tmds/dp/etc
 333          * transmitters.
 334          */
 335         index = ((index + 0x0f) / 0x10) * 0x10;
 336         i = -1;
 337         while ((data = dcb_outp_parse(bios, ++i, &ver, &hdr, &outp))) {
 338                 if (!outp.location || !outp.extdev)
 339                         continue;
 340
 341                 switch (outp.type) {
 342                 case DCB_OUTPUT_TMDS:
 343                         info.type = NV_I2C_TYPE_EXTDDC(outp.extdev);
 344                         break;
 345                 case DCB_OUTPUT_DP:
 346                         info.type = NV_I2C_TYPE_EXTAUX(outp.extdev);
 347                         break;
 348                 default:
 349                         continue;
 350                 }
 351
 352                 ret = -ENODEV;
 353                 j = -1;
 354                 while (ret && ++j < ARRAY_SIZE(nouveau_i2c_extdev_sclass)) {
 355                         parent = nv_object(i2c->find(i2c, outp.i2c_index));
 356                         oclass = nouveau_i2c_extdev_sclass[j];
 357                         do {
 358                                 if (oclass->handle != info.type)
 359                                         continue;
 360                                 ret = nouveau_object_ctor(parent, *pobject,
 361                                                           oclass, NULL,
 362                                                           index++, &object);
 363                         } while (ret && (++oclass)->handle);
 364                 }
 365         }
 366
 367         return 0;
 368 }