sys/dev/iicbus/acpi_iicbus.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2019-2020 Vladimir Kondratyev <wulf@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/bus.h>
  33 #include <sys/endian.h>
  34 #include <sys/kernel.h>
  35 #include <sys/malloc.h>
  36 #include <sys/module.h>
  37 #include <sys/rman.h>
  38 #include <sys/sbuf.h>
  39
  40 #include <machine/resource.h>
  41
  42 #include <contrib/dev/acpica/include/acpi.h>
  43 #include <contrib/dev/acpica/include/accommon.h>
  44 #include <contrib/dev/acpica/include/amlcode.h>
  45 #include <dev/acpica/acpivar.h>
  46
  47 #include <dev/iicbus/iiconf.h>
  48 #include <dev/iicbus/iicbus.h>
  49
  50 #define ACPI_IICBUS_LOCAL_BUFSIZE       32      /* Fits max SMBUS block size */
  51
  52 /*
  53  * Make a copy of ACPI_RESOURCE_I2C_SERIALBUS type and replace "pointer to ACPI
  54  * object name string" field with pointer to ACPI object itself.
  55  * This saves us extra strdup()/free() pair on acpi_iicbus_get_i2cres call.
  56  */
  57 typedef ACPI_RESOURCE_I2C_SERIALBUS     ACPI_IICBUS_RESOURCE_I2C_SERIALBUS;
  58 #define ResourceSource_Handle   ResourceSource.StringPtr
  59
  60 /* Hooks for the ACPI CA debugging infrastructure. */
  61 #define _COMPONENT      ACPI_BUS
  62 ACPI_MODULE_NAME("IIC")
  63
  64 struct gsb_buffer {
  65         UINT8 status;
  66         UINT8 len;
  67         UINT8 data[];
  68 } __packed;
  69
  70 struct acpi_iicbus_softc {
  71         struct iicbus_softc     super_sc;
  72         ACPI_CONNECTION_INFO    space_handler_info;
  73         bool                    space_handler_installed;
  74 };
  75
  76 struct acpi_iicbus_ivars {
  77         struct iicbus_ivar      super_ivar;
  78         ACPI_HANDLE             handle;
  79 };
  80
  81 static int install_space_handler = 0;
  82 TUNABLE_INT("hw.iicbus.enable_acpi_space_handler", &install_space_handler);
  83
  84 static inline bool
  85 acpi_resource_is_i2c_serialbus(ACPI_RESOURCE *res)
  86 {
  87
  88         return (res->Type == ACPI_RESOURCE_TYPE_SERIAL_BUS &&
  89             res->Data.CommonSerialBus.Type == ACPI_RESOURCE_SERIAL_TYPE_I2C);
  90 }
  91
  92 /*
  93  * IICBUS Address space handler
  94  */
  95 static int
  96 acpi_iicbus_sendb(device_t dev, u_char slave, char byte)
  97 {
  98         struct iic_msg msgs[] = {
  99             { slave, IIC_M_WR, 1, &byte },
 100         };
 101
 102         return (iicbus_transfer(dev, msgs, nitems(msgs)));
 103 }
 104
 105 static int
 106 acpi_iicbus_recvb(device_t dev, u_char slave, char *byte)
 107 {
 108         char buf;
 109         struct iic_msg msgs[] = {
 110             { slave, IIC_M_RD, 1, &buf },
 111         };
 112         int error;
 113
 114         error = iicbus_transfer(dev, msgs, nitems(msgs));
 115         if (error == 0)
 116                 *byte = buf;
 117
 118         return (error);
 119 }
 120
 121 static int
 122 acpi_iicbus_write(device_t dev, u_char slave, char cmd, void *buf,
 123     uint16_t buflen)
 124 {
 125         struct iic_msg msgs[] = {
 126             { slave, IIC_M_WR | IIC_M_NOSTOP, 1, &cmd },
 127             { slave, IIC_M_WR | IIC_M_NOSTART, buflen, buf },
 128         };
 129
 130         return (iicbus_transfer(dev, msgs, nitems(msgs)));
 131 }
 132
 133 static int
 134 acpi_iicbus_read(device_t dev, u_char slave, char cmd, void *buf,
 135     uint16_t buflen)
 136 {
 137         uint8_t local_buffer[ACPI_IICBUS_LOCAL_BUFSIZE];
 138         struct iic_msg msgs[] = {
 139             { slave, IIC_M_WR | IIC_M_NOSTOP, 1, &cmd },
 140             { slave, IIC_M_RD, buflen, NULL },
 141         };
 142         int error;
 143
 144         if (buflen <= sizeof(local_buffer))
 145                 msgs[1].buf = local_buffer;
 146         else
 147                 msgs[1].buf = malloc(buflen, M_DEVBUF, M_WAITOK);
 148         error = iicbus_transfer(dev, msgs, nitems(msgs));
 149         if (error == 0)
 150                 memcpy(buf, msgs[1].buf, buflen);
 151         if (msgs[1].buf != local_buffer)
 152                 free(msgs[1].buf, M_DEVBUF);
 153
 154         return (error);
 155 }
 156
 157 static int
 158 acpi_iicbus_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
 159 {
 160         uint8_t bytes[2] = { cmd, count };
 161         struct iic_msg msgs[] = {
 162             { slave, IIC_M_WR | IIC_M_NOSTOP, nitems(bytes), bytes },
 163             { slave, IIC_M_WR | IIC_M_NOSTART, count, buf },
 164         };
 165
 166         if (count == 0)
 167                 return (errno2iic(EINVAL));
 168
 169         return (iicbus_transfer(dev, msgs, nitems(msgs)));
 170 }
 171
 172 static int
 173 acpi_iicbus_bread(device_t dev, u_char slave, char cmd, u_char *count, char *buf)
 174 {
 175         uint8_t local_buffer[ACPI_IICBUS_LOCAL_BUFSIZE];
 176         u_char len;
 177         struct iic_msg msgs[] = {
 178             { slave, IIC_M_WR | IIC_M_NOSTOP, 1, &cmd },
 179             { slave, IIC_M_RD | IIC_M_NOSTOP, 1, &len },
 180         };
 181         struct iic_msg block_msg[] = {
 182             { slave, IIC_M_RD | IIC_M_NOSTART, 0, NULL },
 183         };
 184         device_t parent = device_get_parent(dev);
 185         int error;
 186
 187         /* Have to do this because the command is split in two transfers. */
 188         error = iicbus_request_bus(parent, dev, IIC_WAIT);
 189         if (error == 0)
 190                 error = iicbus_transfer(dev, msgs, nitems(msgs));
 191         if (error == 0) {
 192                 /*
 193                  * If the slave offers an empty reply,
 194                  * read one byte to generate the stop or abort.
 195                  */
 196                 if (len == 0)
 197                         block_msg[0].len = 1;
 198                 else
 199                         block_msg[0].len = len;
 200                 if (len <= sizeof(local_buffer))
 201                         block_msg[0].buf = local_buffer;
 202                 else
 203                         block_msg[0].buf = malloc(len, M_DEVBUF, M_WAITOK);
 204                 error = iicbus_transfer(dev, block_msg, nitems(block_msg));
 205                 if (len == 0)
 206                         error = errno2iic(EBADMSG);
 207                 if (error == 0) {
 208                         *count = len;
 209                         memcpy(buf, block_msg[0].buf, len);
 210                 }
 211                 if (block_msg[0].buf != local_buffer)
 212                         free(block_msg[0].buf, M_DEVBUF);
 213         }
 214         (void)iicbus_release_bus(parent, dev);
 215         return (error);
 216 }
 217
 218 static ACPI_STATUS
 219 acpi_iicbus_space_handler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address,
 220     UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
 221 {
 222         struct gsb_buffer *gsb;
 223         struct acpi_iicbus_softc *sc;
 224         device_t dev;
 225         ACPI_CONNECTION_INFO *info;
 226         ACPI_RESOURCE_I2C_SERIALBUS *sb;
 227         ACPI_RESOURCE *res;
 228         ACPI_STATUS s;
 229         int val;
 230
 231         gsb = (struct gsb_buffer *)Value;
 232         if (gsb == NULL)
 233                 return (AE_BAD_PARAMETER);
 234
 235         info = HandlerContext;
 236         s = AcpiBufferToResource(info->Connection, info->Length, &res);
 237         if (ACPI_FAILURE(s))
 238                 return (s);
 239
 240         if (!acpi_resource_is_i2c_serialbus(res)) {
 241                 s = AE_BAD_PARAMETER;
 242                 goto err;
 243         }
 244
 245         sb = &res->Data.I2cSerialBus;
 246
 247         /* XXX Ignore 10bit addressing for now */
 248         if (sb->AccessMode == ACPI_I2C_10BIT_MODE) {
 249                 s = AE_BAD_PARAMETER;
 250                 goto err;
 251         }
 252
 253 #define AML_FIELD_ATTRIB_MASK           0x0F
 254 #define AML_FIELD_ATTRIO(attr, io)      (((attr) << 16) | (io))
 255
 256         Function &= AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_MASK, ACPI_IO_MASK);
 257         sc = __containerof(info, struct acpi_iicbus_softc, space_handler_info);
 258         dev = sc->super_sc.dev;
 259
 260         switch (Function) {
 261         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_SEND_RECEIVE, ACPI_READ):
 262                 val = acpi_iicbus_recvb(dev, sb->SlaveAddress, gsb->data);
 263                 break;
 264
 265         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_SEND_RECEIVE, ACPI_WRITE):
 266                 val = acpi_iicbus_sendb(dev, sb->SlaveAddress, gsb->data[0]);
 267                 break;
 268
 269         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BYTE, ACPI_READ):
 270                 val = acpi_iicbus_read(dev, sb->SlaveAddress, Address,
 271                     gsb->data, 1);
 272                 break;
 273
 274         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BYTE, ACPI_WRITE):
 275                 val = acpi_iicbus_write(dev, sb->SlaveAddress, Address,
 276                     gsb->data, 1);
 277                 break;
 278
 279         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_WORD, ACPI_READ):
 280                 val = acpi_iicbus_read(dev, sb->SlaveAddress, Address,
 281                     gsb->data, 2);
 282                 break;
 283
 284         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_WORD, ACPI_WRITE):
 285                 val = acpi_iicbus_write(dev, sb->SlaveAddress, Address,
 286                     gsb->data, 2);
 287                 break;
 288
 289         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BLOCK, ACPI_READ):
 290                 val = acpi_iicbus_bread(dev, sb->SlaveAddress, Address,
 291                     &gsb->len, gsb->data);
 292                 break;
 293
 294         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BLOCK, ACPI_WRITE):
 295                 val = acpi_iicbus_bwrite(dev, sb->SlaveAddress, Address,
 296                     gsb->len, gsb->data);
 297                 break;
 298
 299         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BYTES, ACPI_READ):
 300                 val = acpi_iicbus_read(dev, sb->SlaveAddress, Address,
 301                     gsb->data, info->AccessLength);
 302                 break;
 303
 304         case AML_FIELD_ATTRIO(AML_FIELD_ATTRIB_BYTES, ACPI_WRITE):
 305                 val = acpi_iicbus_write(dev, sb->SlaveAddress, Address,
 306                     gsb->data, info->AccessLength);
 307                 break;
 308
 309         default:
 310                 device_printf(dev, "protocol(0x%04x) is not supported.\n",
 311                     Function);
 312                 s = AE_BAD_PARAMETER;
 313                 goto err;
 314         }
 315
 316         gsb->status = val;
 317
 318 err:
 319         ACPI_FREE(res);
 320
 321         return (s);
 322 }
 323
 324 static int
 325 acpi_iicbus_install_address_space_handler(struct acpi_iicbus_softc *sc)
 326 {
 327         ACPI_HANDLE handle;
 328         ACPI_STATUS s;
 329
 330         handle = acpi_get_handle(device_get_parent(sc->super_sc.dev));
 331         s = AcpiInstallAddressSpaceHandler(handle, ACPI_ADR_SPACE_GSBUS,
 332             &acpi_iicbus_space_handler, NULL, &sc->space_handler_info);
 333         if (ACPI_FAILURE(s)) {
 334                 device_printf(sc->super_sc.dev,
 335                     "Failed to install GSBUS Address Space Handler in ACPI\n");
 336                 return (ENXIO);
 337         }
 338
 339         return (0);
 340 }
 341
 342 static int
 343 acpi_iicbus_remove_address_space_handler(struct acpi_iicbus_softc *sc)
 344 {
 345         ACPI_HANDLE handle;
 346         ACPI_STATUS s;
 347
 348         handle = acpi_get_handle(device_get_parent(sc->super_sc.dev));
 349         s = AcpiRemoveAddressSpaceHandler(handle, ACPI_ADR_SPACE_GSBUS,
 350             &acpi_iicbus_space_handler);
 351         if (ACPI_FAILURE(s)) {
 352                 device_printf(sc->super_sc.dev,
 353                     "Failed to remove GSBUS Address Space Handler from ACPI\n");
 354                 return (ENXIO);
 355         }
 356
 357         return (0);
 358 }
 359
 360 static ACPI_STATUS
 361 acpi_iicbus_get_i2cres_cb(ACPI_RESOURCE *res, void *context)
 362 {
 363         ACPI_IICBUS_RESOURCE_I2C_SERIALBUS *sb = context;
 364         ACPI_STATUS status;
 365         ACPI_HANDLE handle;
 366
 367         if (acpi_resource_is_i2c_serialbus(res)) {
 368                 status = AcpiGetHandle(ACPI_ROOT_OBJECT,
 369                     res->Data.I2cSerialBus.ResourceSource.StringPtr, &handle);
 370                 if (ACPI_FAILURE(status))
 371                         return (status);
 372                 memcpy(sb, &res->Data.I2cSerialBus,
 373                     sizeof(ACPI_IICBUS_RESOURCE_I2C_SERIALBUS));
 374                 /*
 375                  * replace "pointer to ACPI object name string" field
 376                  * with pointer to ACPI object itself.
 377                  */
 378                 sb->ResourceSource_Handle = handle;
 379                 return (AE_CTRL_TERMINATE);
 380         } else if (res->Type == ACPI_RESOURCE_TYPE_END_TAG)
 381                 return (AE_NOT_FOUND);
 382
 383         return (AE_OK);
 384 }
 385
 386 static ACPI_STATUS
 387 acpi_iicbus_get_i2cres(ACPI_HANDLE handle, ACPI_RESOURCE_I2C_SERIALBUS *sb)
 388 {
 389
 390         return (AcpiWalkResources(handle, "_CRS",
 391             acpi_iicbus_get_i2cres_cb, sb));
 392 }
 393
 394 static ACPI_STATUS
 395 acpi_iicbus_parse_resources_cb(ACPI_RESOURCE *res, void *context)
 396 {
 397         device_t dev = context;
 398         struct iicbus_ivar *super_devi = device_get_ivars(dev);
 399         struct resource_list *rl = &super_devi->rl;
 400         int irq, gpio_pin;
 401
 402         switch(res->Type) {
 403         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 404                 if (res->Data.ExtendedIrq.InterruptCount > 0) {
 405                         irq = res->Data.ExtendedIrq.Interrupts[0];
 406                         if (bootverbose)
 407                                 printf("  IRQ:               %d\n", irq);
 408                         resource_list_add_next(rl, SYS_RES_IRQ, irq, irq, 1);
 409                         return (AE_CTRL_TERMINATE);
 410                 }
 411                 break;
 412         case ACPI_RESOURCE_TYPE_GPIO:
 413                 if (res->Data.Gpio.ConnectionType ==
 414                     ACPI_RESOURCE_GPIO_TYPE_INT) {
 415                         /* Not supported by FreeBSD yet */
 416                         gpio_pin = res->Data.Gpio.PinTable[0];
 417                         if (bootverbose)
 418                                 printf("  GPIO IRQ pin:      %d\n", gpio_pin);
 419                         return (AE_CTRL_TERMINATE);
 420                 }
 421                 break;
 422         default:
 423                 break;
 424         }
 425
 426         return (AE_OK);
 427 }
 428
 429 static ACPI_STATUS
 430 acpi_iicbus_parse_resources(ACPI_HANDLE handle, device_t dev)
 431 {
 432
 433         return (AcpiWalkResources(handle, "_CRS",
 434             acpi_iicbus_parse_resources_cb, dev));
 435 }
 436
 437 static void
 438 acpi_iicbus_dump_res(device_t dev, ACPI_IICBUS_RESOURCE_I2C_SERIALBUS *sb)
 439 {
 440         device_printf(dev, "found ACPI child\n");
 441         printf("  SlaveAddress:      0x%04hx\n", sb->SlaveAddress);
 442         printf("  ConnectionSpeed:   %uHz\n", sb->ConnectionSpeed);
 443         printf("  SlaveMode:         %s\n",
 444             sb->SlaveMode == ACPI_CONTROLLER_INITIATED ?
 445             "ControllerInitiated" : "DeviceInitiated");
 446         printf("  AddressingMode:    %uBit\n", sb->AccessMode == 0 ? 7 : 10);
 447         printf("  ConnectionSharing: %s\n", sb->ConnectionSharing == 0 ?
 448             "Exclusive" : "Shared");
 449 }
 450
 451 static device_t
 452 acpi_iicbus_add_child(device_t dev, u_int order, const char *name, int unit)
 453 {
 454
 455         return (iicbus_add_child_common(
 456             dev, order, name, unit, sizeof(struct acpi_iicbus_ivars)));
 457 }
 458
 459 static ACPI_STATUS
 460 acpi_iicbus_enumerate_child(ACPI_HANDLE handle, UINT32 level,
 461     void *context, void **result)
 462 {
 463         device_t iicbus, child, acpi_child, acpi0;
 464         struct iicbus_softc *super_sc;
 465         ACPI_IICBUS_RESOURCE_I2C_SERIALBUS sb;
 466         ACPI_STATUS status;
 467         UINT32 sta;
 468
 469         iicbus = context;
 470         super_sc = device_get_softc(iicbus);
 471
 472         /*
 473          * If no _STA method or if it failed, then assume that
 474          * the device is present.
 475          */
 476         if (!ACPI_FAILURE(acpi_GetInteger(handle, "_STA", &sta)) &&
 477             !ACPI_DEVICE_PRESENT(sta))
 478                 return (AE_OK);
 479
 480         if (!acpi_has_hid(handle))
 481                 return (AE_OK);
 482
 483         /*
 484          * Read "I2C Serial Bus Connection Resource Descriptor"
 485          * described in p.19.6.57 of ACPI specification.
 486          */
 487         bzero(&sb, sizeof(ACPI_IICBUS_RESOURCE_I2C_SERIALBUS));
 488         if (ACPI_FAILURE(acpi_iicbus_get_i2cres(handle, &sb)) ||
 489             sb.SlaveAddress == 0)
 490                 return (AE_OK);
 491         if (sb.ResourceSource_Handle !=
 492             acpi_get_handle(device_get_parent(iicbus)))
 493                 return (AE_OK);
 494         if (bootverbose)
 495                 acpi_iicbus_dump_res(iicbus, &sb);
 496
 497         /* Find out speed of the slowest slave */
 498         if (super_sc->bus_freq == 0 || super_sc->bus_freq > sb.ConnectionSpeed)
 499                 super_sc->bus_freq = sb.ConnectionSpeed;
 500
 501         /* Delete existing child of acpi bus */
 502         acpi_child = acpi_get_device(handle);
 503         if (acpi_child != NULL) {
 504                 acpi0 = devclass_get_device(devclass_find("acpi"), 0);
 505                 if (device_get_parent(acpi_child) != acpi0)
 506                         return (AE_OK);
 507
 508                 if (device_is_attached(acpi_child))
 509                         return (AE_OK);
 510
 511                 if (device_delete_child(acpi0, acpi_child) != 0)
 512                         return (AE_OK);
 513         }
 514
 515         child = BUS_ADD_CHILD(iicbus, 0, NULL, -1);
 516         if (child == NULL) {
 517                 device_printf(iicbus, "add child failed\n");
 518                 return (AE_OK);
 519         }
 520
 521         iicbus_set_addr(child, sb.SlaveAddress);
 522         acpi_set_handle(child, handle);
 523         (void)acpi_iicbus_parse_resources(handle, child);
 524
 525         /*
 526          * Update ACPI-CA to use the IIC enumerated device_t for this handle.
 527          */
 528         status = AcpiAttachData(handle, acpi_fake_objhandler, child);
 529         if (ACPI_FAILURE(status))
 530                 printf("WARNING: Unable to attach object data to %s - %s\n",
 531                     acpi_name(handle), AcpiFormatException(status));
 532
 533         return (AE_OK);
 534 }
 535
 536 static ACPI_STATUS
 537 acpi_iicbus_enumerate_children(device_t dev)
 538 {
 539
 540         return (AcpiWalkNamespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
 541             ACPI_UINT32_MAX, acpi_iicbus_enumerate_child, NULL, dev, NULL));
 542 }
 543
 544 static void
 545 acpi_iicbus_set_power_children(device_t dev, int state, bool all_children)
 546 {
 547         device_t *devlist;
 548         int i, numdevs;
 549
 550         if (device_get_children(dev, &devlist, &numdevs) != 0)
 551                 return;
 552
 553         for (i = 0; i < numdevs; i++)
 554                 if (all_children || device_is_attached(devlist[i]) != 0)
 555                         acpi_set_powerstate(devlist[i], state);
 556
 557         free(devlist, M_TEMP);
 558 }
 559
 560 static int
 561 acpi_iicbus_probe(device_t dev)
 562 {
 563         ACPI_HANDLE handle;
 564         device_t controller;
 565
 566         if (acpi_disabled("iicbus"))
 567                 return (ENXIO);
 568
 569         controller = device_get_parent(dev);
 570         if (controller == NULL)
 571                 return (ENXIO);
 572
 573         handle = acpi_get_handle(controller);
 574         if (handle == NULL)
 575                 return (ENXIO);
 576
 577         device_set_desc(dev, "Philips I2C bus (ACPI-hinted)");
 578         return (BUS_PROBE_DEFAULT);
 579 }
 580
 581 static int
 582 acpi_iicbus_attach(device_t dev)
 583 {
 584         struct acpi_iicbus_softc *sc = device_get_softc(dev);
 585         int error;
 586
 587         if (ACPI_FAILURE(acpi_iicbus_enumerate_children(dev)))
 588                 device_printf(dev, "children enumeration failed\n");
 589
 590         acpi_iicbus_set_power_children(dev, ACPI_STATE_D0, true);
 591         error = iicbus_attach_common(dev, sc->super_sc.bus_freq);
 592         if (error == 0 && install_space_handler != 0 &&
 593             acpi_iicbus_install_address_space_handler(sc) == 0)
 594                 sc->space_handler_installed = true;
 595
 596         return (error);
 597 }
 598
 599 static int
 600 acpi_iicbus_detach(device_t dev)
 601 {
 602         struct acpi_iicbus_softc *sc = device_get_softc(dev);
 603
 604         if (sc->space_handler_installed)
 605                 acpi_iicbus_remove_address_space_handler(sc);
 606         acpi_iicbus_set_power_children(dev, ACPI_STATE_D3, false);
 607
 608         return (iicbus_detach(dev));
 609 }
 610
 611 static int
 612 acpi_iicbus_suspend(device_t dev)
 613 {
 614         int error;
 615
 616         error = bus_generic_suspend(dev);
 617         if (error == 0)
 618                 acpi_iicbus_set_power_children(dev, ACPI_STATE_D3, false);
 619
 620         return (error);
 621 }
 622
 623 static int
 624 acpi_iicbus_resume(device_t dev)
 625 {
 626
 627         acpi_iicbus_set_power_children(dev, ACPI_STATE_D0, false);
 628
 629         return (bus_generic_resume(dev));
 630 }
 631
 632 /*
 633  * If this device is an ACPI child but no one claimed it, attempt
 634  * to power it off.  We'll power it back up when a driver is added.
 635  */
 636 static void
 637 acpi_iicbus_probe_nomatch(device_t bus, device_t child)
 638 {
 639
 640         iicbus_probe_nomatch(bus, child);
 641         acpi_set_powerstate(child, ACPI_STATE_D3);
 642 }
 643
 644 /*
 645  * If a new driver has a chance to probe a child, first power it up.
 646  */
 647 static void
 648 acpi_iicbus_driver_added(device_t dev, driver_t *driver)
 649 {
 650         device_t child, *devlist;
 651         int i, numdevs;
 652
 653         DEVICE_IDENTIFY(driver, dev);
 654         if (device_get_children(dev, &devlist, &numdevs) != 0)
 655                 return;
 656
 657         for (i = 0; i < numdevs; i++) {
 658                 child = devlist[i];
 659                 if (device_get_state(child) == DS_NOTPRESENT) {
 660                         acpi_set_powerstate(child, ACPI_STATE_D0);
 661                         if (device_probe_and_attach(child) != 0)
 662                                 acpi_set_powerstate(child, ACPI_STATE_D3);
 663                 }
 664         }
 665         free(devlist, M_TEMP);
 666 }
 667
 668 static void
 669 acpi_iicbus_child_deleted(device_t bus, device_t child)
 670 {
 671         struct acpi_iicbus_ivars *devi = device_get_ivars(child);
 672
 673         if (acpi_get_device(devi->handle) == child)
 674                 AcpiDetachData(devi->handle, acpi_fake_objhandler);
 675 }
 676
 677 static int
 678 acpi_iicbus_read_ivar(device_t bus, device_t child, int which, uintptr_t *res)
 679 {
 680         struct acpi_iicbus_ivars *devi = device_get_ivars(child);
 681
 682         switch (which) {
 683         case ACPI_IVAR_HANDLE:
 684                 *res = (uintptr_t)devi->handle;
 685                 break;
 686         default:
 687                 return (iicbus_read_ivar(bus, child, which, res));
 688         }
 689
 690         return (0);
 691 }
 692
 693 static int
 694 acpi_iicbus_write_ivar(device_t bus, device_t child, int which, uintptr_t val)
 695 {
 696         struct acpi_iicbus_ivars *devi = device_get_ivars(child);
 697
 698         switch (which) {
 699         case ACPI_IVAR_HANDLE:
 700                 if (devi->handle != NULL)
 701                         return (EINVAL);
 702                 devi->handle = (ACPI_HANDLE)val;
 703                 break;
 704         default:
 705                 return (iicbus_write_ivar(bus, child, which, val));
 706         }
 707
 708         return (0);
 709 }
 710
 711 /* Location hint for devctl(8). Concatenate IIC and ACPI hints. */
 712 static int
 713 acpi_iicbus_child_location(device_t bus, device_t child, struct sbuf *sb)
 714 {
 715         struct acpi_iicbus_ivars *devi = device_get_ivars(child);
 716         int error;
 717
 718         /* read IIC location hint string into the buffer. */
 719         error = iicbus_child_location(bus, child, sb);
 720         if (error != 0)
 721                 return (error);
 722
 723         /* Place ACPI string right after IIC one's terminating NUL. */
 724         if (devi->handle != NULL)
 725                 sbuf_printf(sb, " handle=%s", acpi_name(devi->handle));
 726
 727         return (0);
 728 }
 729
 730 /* PnP information for devctl(8). Concatenate IIC and ACPI info strings. */
 731 static int
 732 acpi_iicbus_child_pnpinfo(device_t bus, device_t child, struct sbuf *sb)
 733 {
 734         struct acpi_iicbus_ivars *devi = device_get_ivars(child);
 735         int error;
 736
 737         /* read IIC PnP string into the buffer. */
 738         error = iicbus_child_pnpinfo(bus, child, sb);
 739         if (error != 0)
 740                 return (error);
 741
 742         if (devi->handle == NULL)
 743                 return (0);
 744
 745         error = acpi_pnpinfo(devi->handle, sb);
 746
 747         return (error);
 748 }
 749
 750 static device_method_t acpi_iicbus_methods[] = {
 751         /* Device interface */
 752         DEVMETHOD(device_probe,         acpi_iicbus_probe),
 753         DEVMETHOD(device_attach,        acpi_iicbus_attach),
 754         DEVMETHOD(device_detach,        acpi_iicbus_detach),
 755         DEVMETHOD(device_suspend,       acpi_iicbus_suspend),
 756         DEVMETHOD(device_resume,        acpi_iicbus_resume),
 757
 758         /* Bus interface */
 759         DEVMETHOD(bus_add_child,        acpi_iicbus_add_child),
 760         DEVMETHOD(bus_probe_nomatch,    acpi_iicbus_probe_nomatch),
 761         DEVMETHOD(bus_driver_added,     acpi_iicbus_driver_added),
 762         DEVMETHOD(bus_child_deleted,    acpi_iicbus_child_deleted),
 763         DEVMETHOD(bus_read_ivar,        acpi_iicbus_read_ivar),
 764         DEVMETHOD(bus_write_ivar,       acpi_iicbus_write_ivar),
 765         DEVMETHOD(bus_child_location,   acpi_iicbus_child_location),
 766         DEVMETHOD(bus_child_pnpinfo,    acpi_iicbus_child_pnpinfo),
 767
 768         DEVMETHOD_END,
 769 };
 770
 771 DEFINE_CLASS_1(iicbus, acpi_iicbus_driver, acpi_iicbus_methods,
 772     sizeof(struct acpi_iicbus_softc), iicbus_driver);
 773 MODULE_VERSION(acpi_iicbus, 1);
 774 MODULE_DEPEND(acpi_iicbus, acpi, 1, 1, 1);