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(&parent->refcount);
 146                 atomic_dec(&engine->refcount);
 147         }
 148
 149         return ret;
 150 }
 151
 152 /******************************************************************************
 153  * base i2c subdev class implementation
 154  *****************************************************************************/
 155
 156 static struct nouveau_i2c_port *
 157 nouveau_i2c_find(struct nouveau_i2c *i2c, u8 index)
 158 {
 159         struct nouveau_bios *bios = nouveau_bios(i2c);
 160         struct nouveau_i2c_port *port;
 161
 162         if (index == NV_I2C_DEFAULT(0) ||
 163             index == NV_I2C_DEFAULT(1)) {
 164                 u8  ver, hdr, cnt, len;
 165                 u16 i2c = dcb_i2c_table(bios, &ver, &hdr, &cnt, &len);
 166                 if (i2c && ver >= 0x30) {
 167                         u8 auxidx = nv_ro08(bios, i2c + 4);
 168                         if (index == NV_I2C_DEFAULT(0))
 169                                 index = (auxidx & 0x0f) >> 0;
 170                         else
 171                                 index = (auxidx & 0xf0) >> 4;
 172                 } else {
 173                         index = 2;
 174                 }
 175         }
 176
 177         list_for_each_entry(port, &i2c->ports, head) {
 178                 if (port->index == index)
 179                         return port;
 180         }
 181
 182         return NULL;
 183 }
 184
 185 static struct nouveau_i2c_port *
 186 nouveau_i2c_find_type(struct nouveau_i2c *i2c, u16 type)
 187 {
 188         struct nouveau_i2c_port *port;
 189
 190         list_for_each_entry(port, &i2c->ports, head) {
 191                 if (nv_hclass(port) == type)
 192                         return port;
 193         }
 194
 195         return NULL;
 196 }
 197
 198 static int
 199 nouveau_i2c_identify(struct nouveau_i2c *i2c, int index, const char *what,
 200                      struct i2c_board_info *info,
 201                      bool (*match)(struct nouveau_i2c_port *,
 202                                    struct i2c_board_info *))
 203 {
 204         struct nouveau_i2c_port *port = nouveau_i2c_find(i2c, index);
 205         int i;
 206
 207         if (!port) {
 208                 nv_debug(i2c, "no bus when probing %s on %d\n", what, index);
 209                 return -ENODEV;
 210         }
 211
 212         nv_debug(i2c, "probing %ss on bus: %d\n", what, port->index);
 213         for (i = 0; info[i].addr; i++) {
 214                 if (nv_probe_i2c(port, info[i].addr) &&
 215                     (!match || match(port, &info[i]))) {
 216                         nv_info(i2c, "detected %s: %s\n", what, info[i].type);
 217                         return i;
 218                 }
 219         }
 220
 221         nv_debug(i2c, "no devices found.\n");
 222         return -ENODEV;
 223 }
 224
 225 int
 226 _nouveau_i2c_fini(struct nouveau_object *object, bool suspend)
 227 {
 228         struct nouveau_i2c *i2c = (void *)object;
 229         struct nouveau_i2c_port *port;
 230         int ret;
 231
 232         list_for_each_entry(port, &i2c->ports, head) {
 233                 ret = nv_ofuncs(port)->fini(nv_object(port), suspend);
 234                 if (ret && suspend)
 235                         goto fail;
 236         }
 237
 238         return nouveau_subdev_fini(&i2c->base, suspend);
 239 fail:
 240         list_for_each_entry_continue_reverse(port, &i2c->ports, head) {
 241                 nv_ofuncs(port)->init(nv_object(port));
 242         }
 243
 244         return ret;
 245 }
 246
 247 int
 248 _nouveau_i2c_init(struct nouveau_object *object)
 249 {
 250         struct nouveau_i2c *i2c = (void *)object;
 251         struct nouveau_i2c_port *port;
 252         int ret;
 253
 254         ret = nouveau_subdev_init(&i2c->base);
 255         if (ret == 0) {
 256                 list_for_each_entry(port, &i2c->ports, head) {
 257                         ret = nv_ofuncs(port)->init(nv_object(port));
 258                         if (ret)
 259                                 goto fail;
 260                 }
 261         }
 262
 263         return ret;
 264 fail:
 265         list_for_each_entry_continue_reverse(port, &i2c->ports, head) {
 266                 nv_ofuncs(port)->fini(nv_object(port), false);
 267         }
 268
 269         return ret;
 270 }
 271
 272 void
 273 _nouveau_i2c_dtor(struct nouveau_object *object)
 274 {
 275         struct nouveau_i2c *i2c = (void *)object;
 276         struct nouveau_i2c_port *port, *temp;
 277
 278         list_for_each_entry_safe(port, temp, &i2c->ports, head) {
 279                 nouveau_object_ref(NULL, (struct nouveau_object **)&port);
 280         }
 281
 282         nouveau_subdev_destroy(&i2c->base);
 283 }
 284
 285 static struct nouveau_oclass *
 286 nouveau_i2c_extdev_sclass[] = {
 287         nouveau_anx9805_sclass,
 288 };
 289
 290 int
 291 nouveau_i2c_create_(struct nouveau_object *parent,
 292                     struct nouveau_object *engine,
 293                     struct nouveau_oclass *oclass,
 294                     struct nouveau_oclass *sclass,
 295                     int length, void **pobject)
 296 {
 297         struct nouveau_bios *bios = nouveau_bios(parent);
 298         struct nouveau_i2c *i2c;
 299         struct nouveau_object *object;
 300         struct dcb_i2c_entry info;
 301         int ret, i, j, index = -1;
 302         struct dcb_output outp;
 303         u8  ver, hdr;
 304         u32 data;
 305
 306         ret = nouveau_subdev_create(parent, engine, oclass, 0,
 307                                     "I2C", "i2c", &i2c);
 308         *pobject = nv_object(i2c);
 309         if (ret)
 310                 return ret;
 311
 312         i2c->find = nouveau_i2c_find;
 313         i2c->find_type = nouveau_i2c_find_type;
 314         i2c->identify = nouveau_i2c_identify;
 315         INIT_LIST_HEAD(&i2c->ports);
 316
 317         while (!dcb_i2c_parse(bios, ++index, &info)) {
 318                 if (info.type == DCB_I2C_UNUSED)
 319                         continue;
 320
 321                 oclass = sclass;
 322                 do {
 323                         ret = -EINVAL;
 324                         if (oclass->handle == info.type) {
 325                                 ret = nouveau_object_ctor(*pobject, *pobject,
 326                                                           oclass, &info,
 327                                                           index, &object);
 328                         }
 329                 } while (ret && (++oclass)->handle);
 330         }
 331
 332         /* in addition to the busses specified in the i2c table, there
 333          * may be ddc/aux channels hiding behind external tmds/dp/etc
 334          * transmitters.
 335          */
 336         index = ((index + 0x0f) / 0x10) * 0x10;
 337         i = -1;
 338         while ((data = dcb_outp_parse(bios, ++i, &ver, &hdr, &outp))) {
 339                 if (!outp.location || !outp.extdev)
 340                         continue;
 341
 342                 switch (outp.type) {
 343                 case DCB_OUTPUT_TMDS:
 344                         info.type = NV_I2C_TYPE_EXTDDC(outp.extdev);
 345                         break;
 346                 case DCB_OUTPUT_DP:
 347                         info.type = NV_I2C_TYPE_EXTAUX(outp.extdev);
 348                         break;
 349                 default:
 350                         continue;
 351                 }
 352
 353                 ret = -ENODEV;
 354                 j = -1;
 355                 while (ret && ++j < ARRAY_SIZE(nouveau_i2c_extdev_sclass)) {
 356                         parent = nv_object(i2c->find(i2c, outp.i2c_index));
 357                         oclass = nouveau_i2c_extdev_sclass[j];
 358                         do {
 359                                 if (oclass->handle != info.type)
 360                                         continue;
 361                                 ret = nouveau_object_ctor(parent, *pobject,
 362                                                           oclass, NULL,
 363                                                           index++, &object);
 364                         } while (ret && (++oclass)->handle);
 365                 }
 366         }
 367
 368         return 0;
 369 }