drivers/gpu/drm/nouveau/core/subdev/gpio/base.c

   1 /*
   2  * Copyright 2011 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 <subdev/bios.h>
  26 #include <subdev/bios/gpio.h>
  27
  28 #include "priv.h"
  29
  30 static int
  31 nouveau_gpio_drive(struct nouveau_gpio *gpio,
  32                    int idx, int line, int dir, int out)
  33 {
  34         const struct nouveau_gpio_impl *impl = (void *)nv_object(gpio)->oclass;
  35         return impl->drive ? impl->drive(gpio, line, dir, out) : -ENODEV;
  36 }
  37
  38 static int
  39 nouveau_gpio_sense(struct nouveau_gpio *gpio, int idx, int line)
  40 {
  41         const struct nouveau_gpio_impl *impl = (void *)nv_object(gpio)->oclass;
  42         return impl->sense ? impl->sense(gpio, line) : -ENODEV;
  43 }
  44
  45 static int
  46 nouveau_gpio_find(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line,
  47                   struct dcb_gpio_func *func)
  48 {
  49         struct nouveau_bios *bios = nouveau_bios(gpio);
  50         u8  ver, len;
  51         u16 data;
  52
  53         if (line == 0xff && tag == 0xff)
  54                 return -EINVAL;
  55
  56         data = dcb_gpio_match(bios, idx, tag, line, &ver, &len, func);
  57         if (data)
  58                 return 0;
  59
  60         /* Apple iMac G4 NV18 */
  61         if (nv_device_match(nv_object(gpio), 0x0189, 0x10de, 0x0010)) {
  62                 if (tag == DCB_GPIO_TVDAC0) {
  63                         *func = (struct dcb_gpio_func) {
  64                                 .func = DCB_GPIO_TVDAC0,
  65                                 .line = 4,
  66                                 .log[0] = 0,
  67                                 .log[1] = 1,
  68                         };
  69                         return 0;
  70                 }
  71         }
  72
  73         return -ENOENT;
  74 }
  75
  76 static int
  77 nouveau_gpio_set(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line, int state)
  78 {
  79         struct dcb_gpio_func func;
  80         int ret;
  81
  82         ret = nouveau_gpio_find(gpio, idx, tag, line, &func);
  83         if (ret == 0) {
  84                 int dir = !!(func.log[state] & 0x02);
  85                 int out = !!(func.log[state] & 0x01);
  86                 ret = nouveau_gpio_drive(gpio, idx, func.line, dir, out);
  87         }
  88
  89         return ret;
  90 }
  91
  92 static int
  93 nouveau_gpio_get(struct nouveau_gpio *gpio, int idx, u8 tag, u8 line)
  94 {
  95         struct dcb_gpio_func func;
  96         int ret;
  97
  98         ret = nouveau_gpio_find(gpio, idx, tag, line, &func);
  99         if (ret == 0) {
 100                 ret = nouveau_gpio_sense(gpio, idx, func.line);
 101                 if (ret >= 0)
 102                         ret = (ret == (func.log[1] & 1));
 103         }
 104
 105         return ret;
 106 }
 107
 108 static void
 109 nouveau_gpio_intr_disable(struct nouveau_event *event, int type, int index)
 110 {
 111         struct nouveau_gpio *gpio = nouveau_gpio(event->priv);
 112         const struct nouveau_gpio_impl *impl = (void *)nv_object(gpio)->oclass;
 113         impl->intr_mask(gpio, NVKM_GPIO_TOGGLED, 1 << index, 0);
 114 }
 115
 116 static void
 117 nouveau_gpio_intr_enable(struct nouveau_event *event, int type, int index)
 118 {
 119         struct nouveau_gpio *gpio = nouveau_gpio(event->priv);
 120         const struct nouveau_gpio_impl *impl = (void *)nv_object(gpio)->oclass;
 121         impl->intr_mask(gpio, NVKM_GPIO_TOGGLED, 1 << index, 1 << index);
 122 }
 123
 124 static void
 125 nouveau_gpio_intr(struct nouveau_subdev *subdev)
 126 {
 127         struct nouveau_gpio *gpio = nouveau_gpio(subdev);
 128         const struct nouveau_gpio_impl *impl = (void *)nv_object(gpio)->oclass;
 129         u32 hi, lo, i;
 130
 131         impl->intr_stat(gpio, &hi, &lo);
 132
 133         for (i = 0; (hi | lo) && i < impl->lines; i++) {
 134                 if ((hi | lo) & (1 << i))
 135                         nouveau_event_trigger(gpio->events, 1, i);
 136         }
 137 }
 138
 139 int
 140 _nouveau_gpio_fini(struct nouveau_object *object, bool suspend)
 141 {
 142         const struct nouveau_gpio_impl *impl = (void *)object->oclass;
 143         struct nouveau_gpio *gpio = nouveau_gpio(object);
 144         u32 mask = (1 << impl->lines) - 1;
 145
 146         impl->intr_mask(gpio, NVKM_GPIO_TOGGLED, mask, 0);
 147         impl->intr_stat(gpio, &mask, &mask);
 148
 149         return nouveau_subdev_fini(&gpio->base, suspend);
 150 }
 151
 152 static struct dmi_system_id gpio_reset_ids[] = {
 153         {
 154                 .ident = "Apple Macbook 10,1",
 155                 .matches = {
 156                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
 157                         DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro10,1"),
 158                 }
 159         },
 160         { }
 161 };
 162
 163 int
 164 _nouveau_gpio_init(struct nouveau_object *object)
 165 {
 166         struct nouveau_gpio *gpio = nouveau_gpio(object);
 167         int ret;
 168
 169         ret = nouveau_subdev_init(&gpio->base);
 170         if (ret)
 171                 return ret;
 172
 173         if (gpio->reset && dmi_check_system(gpio_reset_ids))
 174                 gpio->reset(gpio, DCB_GPIO_UNUSED);
 175
 176         return ret;
 177 }
 178
 179 void
 180 _nouveau_gpio_dtor(struct nouveau_object *object)
 181 {
 182         struct nouveau_gpio *gpio = (void *)object;
 183         nouveau_event_destroy(&gpio->events);
 184         nouveau_subdev_destroy(&gpio->base);
 185 }
 186
 187 int
 188 nouveau_gpio_create_(struct nouveau_object *parent,
 189                      struct nouveau_object *engine,
 190                      struct nouveau_oclass *oclass,
 191                      int length, void **pobject)
 192 {
 193         const struct nouveau_gpio_impl *impl = (void *)oclass;
 194         struct nouveau_gpio *gpio;
 195         int ret;
 196
 197         ret = nouveau_subdev_create_(parent, engine, oclass, 0, "GPIO", "gpio",
 198                                      length, pobject);
 199         gpio = *pobject;
 200         if (ret)
 201                 return ret;
 202
 203         gpio->find = nouveau_gpio_find;
 204         gpio->set  = nouveau_gpio_set;
 205         gpio->get  = nouveau_gpio_get;
 206         gpio->reset = impl->reset;
 207
 208         ret = nouveau_event_create(1, impl->lines, &gpio->events);
 209         if (ret)
 210                 return ret;
 211
 212         gpio->events->priv = gpio;
 213         gpio->events->enable = nouveau_gpio_intr_enable;
 214         gpio->events->disable = nouveau_gpio_intr_disable;
 215         nv_subdev(gpio)->intr = nouveau_gpio_intr;
 216         return 0;
 217 }
 218
 219 int
 220 _nouveau_gpio_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
 221                    struct nouveau_oclass *oclass, void *data, u32 size,
 222                    struct nouveau_object **pobject)
 223 {
 224         struct nouveau_gpio *gpio;
 225         int ret;
 226
 227         ret = nouveau_gpio_create(parent, engine, oclass, &gpio);
 228         *pobject = nv_object(gpio);
 229         if (ret)
 230                 return ret;
 231
 232         return 0;
 233 }