drivers/gpu/drm/nouveau/nvkm/subdev/i2c/aux.c

   1 /*
   2  * Copyright 2009 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 #include "aux.h"
  25 #include "pad.h"
  26
  27 static int
  28 nvkm_i2c_aux_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
  29 {
  30         struct nvkm_i2c_aux *aux = container_of(adap, typeof(*aux), i2c);
  31         struct i2c_msg *msg = msgs;
  32         int ret, mcnt = num;
  33
  34         ret = nvkm_i2c_aux_acquire(aux);
  35         if (ret)
  36                 return ret;
  37
  38         while (mcnt--) {
  39                 u8 remaining = msg->len;
  40                 u8 *ptr = msg->buf;
  41
  42                 while (remaining) {
  43                         u8 cnt = (remaining > 16) ? 16 : remaining;
  44                         u8 cmd;
  45
  46                         if (msg->flags & I2C_M_RD)
  47                                 cmd = 1;
  48                         else
  49                                 cmd = 0;
  50
  51                         if (mcnt || remaining > 16)
  52                                 cmd |= 4; /* MOT */
  53
  54                         ret = aux->func->xfer(aux, true, cmd, msg->addr, ptr, cnt);
  55                         if (ret < 0) {
  56                                 nvkm_i2c_aux_release(aux);
  57                                 return ret;
  58                         }
  59
  60                         ptr += cnt;
  61                         remaining -= cnt;
  62                 }
  63
  64                 msg++;
  65         }
  66
  67         nvkm_i2c_aux_release(aux);
  68         return num;
  69 }
  70
  71 static u32
  72 nvkm_i2c_aux_i2c_func(struct i2c_adapter *adap)
  73 {
  74         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
  75 }
  76
  77 const struct i2c_algorithm
  78 nvkm_i2c_aux_i2c_algo = {
  79         .master_xfer = nvkm_i2c_aux_i2c_xfer,
  80         .functionality = nvkm_i2c_aux_i2c_func
  81 };
  82
  83 void
  84 nvkm_i2c_aux_monitor(struct nvkm_i2c_aux *aux, bool monitor)
  85 {
  86         struct nvkm_i2c_pad *pad = aux->pad;
  87         AUX_TRACE(aux, "monitor: %s", monitor ? "yes" : "no");
  88         if (monitor)
  89                 nvkm_i2c_pad_mode(pad, NVKM_I2C_PAD_AUX);
  90         else
  91                 nvkm_i2c_pad_mode(pad, NVKM_I2C_PAD_OFF);
  92 }
  93
  94 void
  95 nvkm_i2c_aux_release(struct nvkm_i2c_aux *aux)
  96 {
  97         struct nvkm_i2c_pad *pad = aux->pad;
  98         AUX_TRACE(aux, "release");
  99         nvkm_i2c_pad_release(pad);
 100         mutex_unlock(&aux->mutex);
 101 }
 102
 103 int
 104 nvkm_i2c_aux_acquire(struct nvkm_i2c_aux *aux)
 105 {
 106         struct nvkm_i2c_pad *pad = aux->pad;
 107         int ret;
 108
 109         AUX_TRACE(aux, "acquire");
 110         mutex_lock(&aux->mutex);
 111
 112         if (aux->enabled)
 113                 ret = nvkm_i2c_pad_acquire(pad, NVKM_I2C_PAD_AUX);
 114         else
 115                 ret = -EIO;
 116
 117         if (ret)
 118                 mutex_unlock(&aux->mutex);
 119         return ret;
 120 }
 121
 122 int
 123 nvkm_i2c_aux_xfer(struct nvkm_i2c_aux *aux, bool retry, u8 type,
 124                   u32 addr, u8 *data, u8 size)
 125 {
 126         return aux->func->xfer(aux, retry, type, addr, data, size);
 127 }
 128
 129 int
 130 nvkm_i2c_aux_lnk_ctl(struct nvkm_i2c_aux *aux, int nr, int bw, bool ef)
 131 {
 132         if (aux->func->lnk_ctl)
 133                 return aux->func->lnk_ctl(aux, nr, bw, ef);
 134         return -ENODEV;
 135 }
 136
 137 void
 138 nvkm_i2c_aux_del(struct nvkm_i2c_aux **paux)
 139 {
 140         struct nvkm_i2c_aux *aux = *paux;
 141         if (aux && !WARN_ON(!aux->func)) {
 142                 AUX_TRACE(aux, "dtor");
 143                 list_del(&aux->head);
 144                 i2c_del_adapter(&aux->i2c);
 145                 kfree(*paux);
 146                 *paux = NULL;
 147         }
 148 }
 149
 150 void
 151 nvkm_i2c_aux_init(struct nvkm_i2c_aux *aux)
 152 {
 153         AUX_TRACE(aux, "init");
 154         mutex_lock(&aux->mutex);
 155         aux->enabled = true;
 156         mutex_unlock(&aux->mutex);
 157 }
 158
 159 void
 160 nvkm_i2c_aux_fini(struct nvkm_i2c_aux *aux)
 161 {
 162         AUX_TRACE(aux, "fini");
 163         mutex_lock(&aux->mutex);
 164         aux->enabled = false;
 165         mutex_unlock(&aux->mutex);
 166 }
 167
 168 int
 169 nvkm_i2c_aux_ctor(const struct nvkm_i2c_aux_func *func,
 170                   struct nvkm_i2c_pad *pad, int id,
 171                   struct nvkm_i2c_aux *aux)
 172 {
 173         struct nvkm_device *device = pad->i2c->subdev.device;
 174
 175         aux->func = func;
 176         aux->pad = pad;
 177         aux->id = id;
 178         mutex_init(&aux->mutex);
 179         list_add_tail(&aux->head, &pad->i2c->aux);
 180         AUX_TRACE(aux, "ctor");
 181
 182         snprintf(aux->i2c.name, sizeof(aux->i2c.name), "nvkm-%s-aux-%04x",
 183                  dev_name(device->dev), id);
 184         aux->i2c.owner = THIS_MODULE;
 185         aux->i2c.dev.parent = device->dev;
 186         aux->i2c.algo = &nvkm_i2c_aux_i2c_algo;
 187         return i2c_add_adapter(&aux->i2c);
 188 }
 189
 190 int
 191 nvkm_i2c_aux_new_(const struct nvkm_i2c_aux_func *func,
 192                   struct nvkm_i2c_pad *pad, int id,
 193                   struct nvkm_i2c_aux **paux)
 194 {
 195         if (!(*paux = kzalloc(sizeof(**paux), GFP_KERNEL)))
 196                 return -ENOMEM;
 197         return nvkm_i2c_aux_ctor(func, pad, id, *paux);
 198 }