drivers/gpu/drm/nouveau/nvkm/subdev/iccsense/base.c

   1 /*
   2  * Copyright 2015 Martin Peres
   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: Martin Peres
  23  */
  24 #include "priv.h"
  25
  26 #include <subdev/bios.h>
  27 #include <subdev/bios/extdev.h>
  28 #include <subdev/bios/iccsense.h>
  29 #include <subdev/i2c.h>
  30
  31 static bool
  32 nvkm_iccsense_validate_device(struct i2c_adapter *i2c, u8 addr,
  33                               enum nvbios_extdev_type type, u8 rail)
  34 {
  35         switch (type) {
  36         case NVBIOS_EXTDEV_INA209:
  37         case NVBIOS_EXTDEV_INA219:
  38                 return rail == 0 && nv_rd16i2cr(i2c, addr, 0x0) >= 0;
  39         case NVBIOS_EXTDEV_INA3221:
  40                 return rail <= 3 &&
  41                        nv_rd16i2cr(i2c, addr, 0xff) == 0x3220 &&
  42                        nv_rd16i2cr(i2c, addr, 0xfe) == 0x5449;
  43         default:
  44                 return false;
  45         }
  46 }
  47
  48 static int
  49 nvkm_iccsense_poll_lane(struct i2c_adapter *i2c, u8 addr, u8 shunt_reg,
  50                         u8 shunt_shift, u8 bus_reg, u8 bus_shift, u8 shunt,
  51                         u16 lsb)
  52 {
  53         int vshunt = nv_rd16i2cr(i2c, addr, shunt_reg);
  54         int vbus = nv_rd16i2cr(i2c, addr, bus_reg);
  55
  56         if (vshunt < 0 || vbus < 0)
  57                 return -EINVAL;
  58
  59         vshunt >>= shunt_shift;
  60         vbus >>= bus_shift;
  61
  62         return vbus * vshunt * lsb / shunt;
  63 }
  64
  65 static int
  66 nvkm_iccsense_ina2x9_read(struct nvkm_iccsense *iccsense,
  67                           struct nvkm_iccsense_rail *rail,
  68                           u8 shunt_reg, u8 bus_reg)
  69 {
  70         return nvkm_iccsense_poll_lane(rail->i2c, rail->addr, shunt_reg, 0,
  71                                        bus_reg, 3, rail->mohm, 10 * 4);
  72 }
  73
  74 static int
  75 nvkm_iccsense_ina209_read(struct nvkm_iccsense *iccsense,
  76                           struct nvkm_iccsense_rail *rail)
  77 {
  78         return nvkm_iccsense_ina2x9_read(iccsense, rail, 3, 4);
  79 }
  80
  81 static int
  82 nvkm_iccsense_ina219_read(struct nvkm_iccsense *iccsense,
  83                           struct nvkm_iccsense_rail *rail)
  84 {
  85         return nvkm_iccsense_ina2x9_read(iccsense, rail, 1, 2);
  86 }
  87
  88 static int
  89 nvkm_iccsense_ina3221_read(struct nvkm_iccsense *iccsense,
  90                            struct nvkm_iccsense_rail *rail)
  91 {
  92         return nvkm_iccsense_poll_lane(rail->i2c, rail->addr,
  93                                        1 + (rail->rail * 2), 3,
  94                                        2 + (rail->rail * 2), 3, rail->mohm,
  95                                        40 * 8);
  96 }
  97
  98 int
  99 nvkm_iccsense_read_all(struct nvkm_iccsense *iccsense)
 100 {
 101         int result = 0, i;
 102
 103         if (!iccsense)
 104                 return -EINVAL;
 105
 106         if (iccsense->rail_count == 0)
 107                 return -ENODEV;
 108
 109         for (i = 0; i < iccsense->rail_count; ++i) {
 110                 int res;
 111                 struct nvkm_iccsense_rail *rail = &iccsense->rails[i];
 112                 if (!rail->read)
 113                         return -ENODEV;
 114
 115                 res = rail->read(iccsense, rail);
 116                 if (res >= 0)
 117                         result += res;
 118                 else
 119                         return res;
 120         }
 121         return result;
 122 }
 123
 124 static void *
 125 nvkm_iccsense_dtor(struct nvkm_subdev *subdev)
 126 {
 127         struct nvkm_iccsense *iccsense = nvkm_iccsense(subdev);
 128
 129         if (iccsense->rails)
 130                 kfree(iccsense->rails);
 131
 132         return iccsense;
 133 }
 134
 135 static int
 136 nvkm_iccsense_oneinit(struct nvkm_subdev *subdev)
 137 {
 138         struct nvkm_iccsense *iccsense = nvkm_iccsense(subdev);
 139         struct nvkm_bios *bios = subdev->device->bios;
 140         struct nvkm_i2c *i2c = subdev->device->i2c;
 141         struct nvbios_iccsense stbl;
 142         int i;
 143
 144         if (!i2c || !bios || nvbios_iccsense_parse(bios, &stbl)
 145             || !stbl.nr_entry)
 146                 return 0;
 147
 148         iccsense->rails = kmalloc(sizeof(*iccsense->rails) * stbl.nr_entry,
 149                                   GFP_KERNEL);
 150         if (!iccsense->rails)
 151                 return -ENOMEM;
 152
 153         iccsense->data_valid = true;
 154         for (i = 0; i < stbl.nr_entry; ++i) {
 155                 struct pwr_rail_t *r = &stbl.rail[i];
 156                 struct nvbios_extdev_func extdev;
 157                 struct nvkm_iccsense_rail *rail;
 158                 struct nvkm_i2c_bus *i2c_bus;
 159                 u8 addr;
 160
 161                 if (!r->mode || r->resistor_mohm == 0)
 162                         continue;
 163
 164                 if (nvbios_extdev_parse(bios, r->extdev_id, &extdev))
 165                         continue;
 166
 167                 if (extdev.type == 0xff)
 168                         continue;
 169
 170                 if (extdev.bus)
 171                         i2c_bus = nvkm_i2c_bus_find(i2c, NVKM_I2C_BUS_SEC);
 172                 else
 173                         i2c_bus = nvkm_i2c_bus_find(i2c, NVKM_I2C_BUS_PRI);
 174                 if (!i2c_bus)
 175                         continue;
 176
 177                 addr = extdev.addr >> 1;
 178                 if (!nvkm_iccsense_validate_device(&i2c_bus->i2c, addr,
 179                                                    extdev.type, r->rail)) {
 180                         iccsense->data_valid = false;
 181                         nvkm_warn(subdev, "found unknown or invalid rail entry"
 182                                   " type 0x%x rail %i, power reading might be"
 183                                   " invalid\n", extdev.type, r->rail);
 184                         continue;
 185                 }
 186
 187                 rail = &iccsense->rails[iccsense->rail_count];
 188                 switch (extdev.type) {
 189                 case NVBIOS_EXTDEV_INA209:
 190                         rail->read = nvkm_iccsense_ina209_read;
 191                         break;
 192                 case NVBIOS_EXTDEV_INA219:
 193                         rail->read = nvkm_iccsense_ina219_read;
 194                         break;
 195                 case NVBIOS_EXTDEV_INA3221:
 196                         rail->read = nvkm_iccsense_ina3221_read;
 197                         break;
 198                 }
 199
 200                 rail->addr = addr;
 201                 rail->rail = r->rail;
 202                 rail->mohm = r->resistor_mohm;
 203                 rail->i2c = &i2c_bus->i2c;
 204                 ++iccsense->rail_count;
 205         }
 206         return 0;
 207 }
 208
 209 struct nvkm_subdev_func iccsense_func = {
 210         .oneinit = nvkm_iccsense_oneinit,
 211         .dtor = nvkm_iccsense_dtor,
 212 };
 213
 214 void
 215 nvkm_iccsense_ctor(struct nvkm_device *device, int index,
 216                    struct nvkm_iccsense *iccsense)
 217 {
 218         nvkm_subdev_ctor(&iccsense_func, device, index, 0, &iccsense->subdev);
 219 }
 220
 221 int
 222 nvkm_iccsense_new_(struct nvkm_device *device, int index,
 223                    struct nvkm_iccsense **iccsense)
 224 {
 225         if (!(*iccsense = kzalloc(sizeof(**iccsense), GFP_KERNEL)))
 226                 return -ENOMEM;
 227         nvkm_iccsense_ctor(device, index, *iccsense);
 228         return 0;
 229 }