sys/bus/smbus/smbacpi/smbacpi.c

   1 /*
   2  * Copyright (c) 2016 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Imre Vadász <imre@vdsz.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 /* Register SMBUS device with ACPICA for ACPI-5.0 GPIO functionality */
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/module.h>
  41 #include <sys/errno.h>
  42 #include <sys/lock.h>
  43 #include <sys/bus.h>
  44
  45 #include "opt_acpi.h"
  46 #include "acpi.h"
  47 #include <dev/acpica/acpivar.h>
  48 #include <contrib/dev/acpica/source/include/amlcode.h>
  49
  50 #include <bus/smbus/smbconf.h>
  51
  52 #include "smbus_if.h"
  53
  54 struct gsb_buffer {
  55         UINT8 status;
  56         UINT8 len;
  57         UINT8 data[];
  58 } __packed;
  59
  60 struct acpi_i2c_handler_data {
  61         struct acpi_connection_info info;
  62         device_t dev;
  63 };
  64
  65 struct smbus_acpi_softc {
  66         device_t dev;
  67         device_t parent;
  68         struct acpi_i2c_handler_data space_handler_data;
  69 };
  70
  71 static int      smbus_acpi_probe(device_t dev);
  72 static int      smbus_acpi_attach(device_t dev);
  73 static int      smbus_acpi_detach(device_t dev);
  74
  75 /* SMBUS Address Space Handler */
  76 static void             smbus_acpi_install_address_space_handler(
  77                             struct smbus_acpi_softc *sc);
  78 static void             smbus_acpi_remove_address_space_handler(
  79                             struct smbus_acpi_softc *sc);
  80 static ACPI_STATUS      smbus_acpi_space_handler(UINT32 Function,
  81                             ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth,
  82                             UINT64 *Value, void *HandlerContext,
  83                             void *RegionContext);
  84
  85 /*
  86  * SMBUS Address space handler
  87  */
  88
  89 static void
  90 smbus_acpi_install_address_space_handler(struct smbus_acpi_softc *sc)
  91 {
  92         ACPI_HANDLE handle;
  93         ACPI_STATUS s;
  94
  95         handle = acpi_get_handle(sc->parent);
  96         sc->space_handler_data.dev = sc->parent;
  97         s = AcpiInstallAddressSpaceHandler(handle, ACPI_ADR_SPACE_GSBUS,
  98             &smbus_acpi_space_handler, NULL, &sc->space_handler_data);
  99         if (ACPI_FAILURE(s)) {
 100                 device_printf(sc->dev,
 101                     "Failed to install GSBUS Address Space Handler in ACPI\n");
 102         }
 103 }
 104
 105 static void
 106 smbus_acpi_remove_address_space_handler(struct smbus_acpi_softc *sc)
 107 {
 108         ACPI_HANDLE handle;
 109         ACPI_STATUS s;
 110
 111         handle = acpi_get_handle(sc->parent);
 112         s = AcpiRemoveAddressSpaceHandler(handle, ACPI_ADR_SPACE_GSBUS,
 113             &smbus_acpi_space_handler);
 114         if (ACPI_FAILURE(s)) {
 115                 device_printf(sc->dev,
 116                     "Failed to remove GSBUS Address Space Handler from ACPI\n");
 117         }
 118 }
 119
 120 static ACPI_STATUS
 121 smbus_acpi_space_handler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address,
 122     UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
 123 {
 124         struct gsb_buffer *gsb = (struct gsb_buffer *)Value;
 125         struct acpi_i2c_handler_data *data = HandlerContext;
 126         device_t dev = data->dev;
 127         struct acpi_connection_info *info = &data->info;
 128         struct acpi_resource_i2c_serialbus *sb;
 129         ACPI_RESOURCE *Resource;
 130         UINT32 accessor_type = Function >> 16;
 131         UINT8 action = Function & ACPI_IO_MASK;
 132         ACPI_STATUS s = AE_OK;
 133         int cnt, val = 0;
 134         uint16_t *wdata;
 135         short word;
 136         char byte;
 137         char buf[32];
 138         u_char count;
 139
 140         if (Value == NULL)
 141                 return (AE_BAD_PARAMETER);
 142
 143         s = AcpiBufferToResource(info->Connection, info->Length,
 144             &Resource);
 145         if (ACPI_FAILURE(s))
 146                 return s;
 147         if (Resource->Type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
 148                 s = AE_BAD_PARAMETER;
 149                 goto err;
 150         }
 151
 152         sb = &Resource->Data.I2cSerialBus;
 153         if (sb->Type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
 154                 s = AE_BAD_PARAMETER;
 155                 goto err;
 156         }
 157
 158         /* XXX Ignore 10bit addressing for now */
 159         if (sb->AccessMode == ACPI_I2C_10BIT_MODE) {
 160                 s = AE_BAD_PARAMETER;
 161                 goto err;
 162         }
 163
 164         switch (accessor_type) {
 165         case AML_FIELD_ATTRIB_SEND_RCV:
 166                 if (action == ACPI_READ) {
 167                         val = SMBUS_RECVB(dev, sb->SlaveAddress, &byte);
 168                         if (val == 0)
 169                                 gsb->data[0] = byte;
 170                 } else {
 171                         val = SMBUS_SENDB(dev, sb->SlaveAddress,
 172                             gsb->data[0]);
 173                 }
 174                 break;
 175         case AML_FIELD_ATTRIB_BYTE:
 176                 if (action == ACPI_READ) {
 177                         val = SMBUS_READB(dev, sb->SlaveAddress, Address,
 178                             &byte);
 179                         if (val == 0)
 180                                 gsb->data[0] = byte;
 181                 } else {
 182                         val = SMBUS_WRITEB(dev, sb->SlaveAddress, Address,
 183                             gsb->data[0]);
 184                 }
 185                 break;
 186         case AML_FIELD_ATTRIB_WORD:
 187                 wdata = (uint16_t *)gsb->data;
 188                 if (action == ACPI_READ) {
 189                         val = SMBUS_READW(dev, sb->SlaveAddress, Address,
 190                             &word);
 191                         if (val == 0)
 192                                 wdata[0] = word;
 193                 } else {
 194                         val = SMBUS_WRITEW(dev, sb->SlaveAddress, Address,
 195                             wdata[0]);
 196                 }
 197                 break;
 198         case AML_FIELD_ATTRIB_BLOCK:
 199                 if (action == ACPI_READ) {
 200                         count = 32;
 201                         val = SMBUS_BREAD(dev, sb->SlaveAddress, Address,
 202                             &count, buf);
 203                         if (val == 0) {
 204                                 gsb->len = count;
 205                                 memcpy(gsb->data, buf, count);
 206                         }
 207                 } else {
 208                         memcpy(buf, gsb->data, gsb->len);
 209                         count = gsb->len;
 210                         val = SMBUS_BWRITE(dev, sb->SlaveAddress, Address,
 211                             count, buf);
 212                 }
 213                 break;
 214         case AML_FIELD_ATTRIB_MULTIBYTE:
 215                 if (action == ACPI_READ) {
 216                         cnt = 0;
 217                         val = SMBUS_TRANS(dev, sb->SlaveAddress, Address,
 218                             SMB_TRANS_NOCNT | SMB_TRANS_7BIT, NULL, 0,
 219                             buf, info->AccessLength, &cnt);
 220                         if (val == 0)
 221                                 memcpy(gsb->data, buf, cnt);
 222                 } else {
 223                         memcpy(buf, gsb->data, info->AccessLength);
 224                         val = SMBUS_TRANS(dev, sb->SlaveAddress, Address,
 225                             SMB_TRANS_NOCNT | SMB_TRANS_7BIT,
 226                             buf, info->AccessLength, NULL, 0, NULL);
 227                 }
 228                 break;
 229         default:
 230                 device_printf(dev, "protocol(0x%02x) is not supported.\n",
 231                     accessor_type);
 232                 s = AE_BAD_PARAMETER;
 233                 goto err;
 234         }
 235
 236         gsb->status = val;
 237
 238 err:
 239         ACPI_FREE(Resource);
 240
 241         return (s);
 242 }
 243
 244 static int
 245 smbus_acpi_probe(device_t dev)
 246 {
 247         if (acpi_get_handle(device_get_parent(dev)) == NULL)
 248                 return (ENXIO);
 249
 250         device_set_desc(dev, "ACPI I2cSerialBus backend");
 251
 252         return (0);
 253 }
 254
 255 static int
 256 smbus_acpi_attach(device_t dev)
 257 {
 258         struct smbus_acpi_softc *sc = device_get_softc(dev);
 259
 260         sc->dev = dev;
 261         sc->parent = device_get_parent(dev);
 262
 263         smbus_acpi_install_address_space_handler(sc);
 264
 265         return (0);
 266 }
 267
 268 static int
 269 smbus_acpi_detach(device_t dev)
 270 {
 271         struct smbus_acpi_softc *sc = device_get_softc(dev);
 272
 273         smbus_acpi_remove_address_space_handler(sc);
 274
 275         return (0);
 276 }
 277
 278 static device_method_t smbacpi_methods[] = {
 279         /* Device interface */
 280         DEVMETHOD(device_probe, smbus_acpi_probe),
 281         DEVMETHOD(device_attach, smbus_acpi_attach),
 282         DEVMETHOD(device_detach, smbus_acpi_detach),
 283
 284         DEVMETHOD_END
 285 };
 286
 287 static driver_t smbacpi_driver = {
 288         "smbacpi",
 289         smbacpi_methods,
 290         sizeof(struct smbus_acpi_softc)
 291 };
 292
 293 static devclass_t smbacpi_devclass;
 294
 295 DRIVER_MODULE(smbacpi, ig4iic, smbacpi_driver, smbacpi_devclass,
 296     NULL, NULL);
 297 MODULE_DEPEND(smbacpi, acpi, 1, 1, 1);
 298 MODULE_DEPEND(smbacpi, smbus, 1, 1, 1);
 299 MODULE_VERSION(smbacpi, 1);