/*      $NetBSD: apple_smc.c,v 1.9 2023/08/08 05:20:14 mrg Exp $        */

/*
* Apple System Management Controller
*/

/*-
* Copyright (c) 2013 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Taylor R. Campbell.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: apple_smc.c,v 1.9 2023/08/08 05:20:14 mrg Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/device.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/module.h>
#include <sys/mutex.h>
#include <sys/rwlock.h>
#if 0                           /* XXX sysctl */
#include <sys/sysctl.h>
#endif
#include <sys/systm.h>

#include <dev/ic/apple_smc.h>
#include <dev/ic/apple_smcreg.h>
#include <dev/ic/apple_smcvar.h>

/* Must match the config(5) name.  */
#define APPLE_SMC_BUS   "applesmcbus"

static int      apple_smc_search(device_t, cfdata_t, const int *, void *);
static uint8_t  apple_smc_bus_read_1(struct apple_smc_tag *, bus_size_t);
static void     apple_smc_bus_write_1(struct apple_smc_tag *, bus_size_t,
                   uint8_t);
static int      apple_smc_read_data(struct apple_smc_tag *, uint8_t *);
static int      apple_smc_write(struct apple_smc_tag *, bus_size_t, uint8_t);
static int      apple_smc_write_cmd(struct apple_smc_tag *, uint8_t);
static int      apple_smc_write_data(struct apple_smc_tag *, uint8_t);
static int      apple_smc_begin(struct apple_smc_tag *, uint8_t,
                   const char *, uint8_t);
static int      apple_smc_input(struct apple_smc_tag *, uint8_t,
                   const char *, void *, uint8_t);
static int      apple_smc_output(struct apple_smc_tag *, uint8_t,
                   const char *, const void *, uint8_t);

void
apple_smc_attach(struct apple_smc_tag *smc)
{

       mutex_init(&smc->smc_io_lock, MUTEX_DEFAULT, IPL_NONE);
#if 0                           /* XXX sysctl */
       apple_smc_sysctl_setup(smc);
#endif

       /* Attach any children.  */
       (void)apple_smc_rescan(smc, NULL, NULL);
}

int
apple_smc_detach(struct apple_smc_tag *smc, int flags)
{
       int error;

       /* Fail if we can't detach all our children.  */
       error = config_detach_children(smc->smc_dev, flags);
       if (error)
               return error;

#if 0                           /* XXX sysctl */
       sysctl_teardown(&smc->smc_log);
#endif
       mutex_destroy(&smc->smc_io_lock);

       return 0;
}

int
apple_smc_rescan(struct apple_smc_tag *smc, const char *ifattr,
   const int *locators)
{

       /* Let autoconf(9) do the work of finding new children.  */
       config_search(smc->smc_dev, smc,
           CFARGS(.search = apple_smc_search));
       return 0;
}

static int
apple_smc_search(device_t parent, cfdata_t cf, const int *locators, void *aux)
{
       struct apple_smc_tag *const smc = aux;
       static const struct apple_smc_attach_args zero_asa;
       struct apple_smc_attach_args asa = zero_asa;
       device_t dev;
       deviter_t di;
       bool attached = false;

       /*
        * If this device has already attached, don't attach it again.
        *
        * XXX This is a pretty silly way to query the children, but
        * struct device doesn't seem to list its children.
        */
       for (dev = deviter_first(&di, DEVITER_F_LEAVES_FIRST);
            dev != NULL;
            dev = deviter_next(&di)) {
               if (device_parent(dev) != parent)
                       continue;
               if (!device_is_a(dev, cf->cf_name))
                       continue;
               attached = true;
               break;
       }
       deviter_release(&di);
       if (attached)
               return 0;

       /* If this device doesn't match, don't attach it.  */
       if (!config_probe(parent, cf, aux))
               return 0;

       /* Looks hunky-dory.  Attach.  */
       asa.asa_smc = smc;
       config_attach(parent, cf, &asa, NULL,
           CFARGS(.locators = locators));
       return 0;
}

void
apple_smc_child_detached(struct apple_smc_tag *smc __unused,
   device_t child __unused)
{
       /* We keep no books about our children.  */
}

static uint8_t
apple_smc_bus_read_1(struct apple_smc_tag *smc, bus_size_t reg)
{

       return bus_space_read_1(smc->smc_bst, smc->smc_bsh, reg);
}

static void
apple_smc_bus_write_1(struct apple_smc_tag *smc, bus_size_t reg, uint8_t v)
{

       bus_space_write_1(smc->smc_bst, smc->smc_bsh, reg, v);
}

/*
* XXX These delays are pretty randomly chosen.  Wait in 100 us
* increments, up to a total of 1 ms.
*/

static int
apple_smc_read_data(struct apple_smc_tag *smc, uint8_t *byte)
{
       uint8_t status;
       unsigned int i;

       KASSERT(mutex_owned(&smc->smc_io_lock));

       /*
        * Wait until the status register says there's data to read and
        * read it.
        */
       for (i = 0; i < 100; i++) {
               status = apple_smc_bus_read_1(smc, APPLE_SMC_CSR);
               if (status & APPLE_SMC_STATUS_READ_READY) {
                       *byte = apple_smc_bus_read_1(smc, APPLE_SMC_DATA);
                       return 0;
               }
               DELAY(100);
       }

       return ETIMEDOUT;
}

static int
apple_smc_write(struct apple_smc_tag *smc, bus_size_t reg, uint8_t byte)
{
       uint8_t status;
       unsigned int i;

       KASSERT(mutex_owned(&smc->smc_io_lock));

       /*
        * Write the byte and then wait until the status register says
        * it has been accepted.
        */
       apple_smc_bus_write_1(smc, reg, byte);
       for (i = 0; i < 100; i++) {
               status = apple_smc_bus_read_1(smc, APPLE_SMC_CSR);
               if (status & APPLE_SMC_STATUS_WRITE_ACCEPTED)
                       return 0;
               DELAY(100);

               /* Write again if it hasn't been acknowledged at all.  */
               if (!(status & APPLE_SMC_STATUS_WRITE_PENDING))
                       apple_smc_bus_write_1(smc, reg, byte);
       }

       return ETIMEDOUT;
}

static int
apple_smc_write_cmd(struct apple_smc_tag *smc, uint8_t cmd)
{

       return apple_smc_write(smc, APPLE_SMC_CSR, cmd);
}

static int
apple_smc_write_data(struct apple_smc_tag *smc, uint8_t data)
{

       return apple_smc_write(smc, APPLE_SMC_DATA, data);
}

static int
apple_smc_begin(struct apple_smc_tag *smc, uint8_t cmd, const char *key,
   uint8_t size)
{
       unsigned int i;
       int error;

       KASSERT(mutex_owned(&smc->smc_io_lock));

       /* Write the command first.  */
       error = apple_smc_write_cmd(smc, cmd);
       if (error)
               return error;

       /* Write the key next.  */
       for (i = 0; i < 4; i++) {
               error = apple_smc_write_data(smc, key[i]);
               if (error)
                       return error;
       }

       /* Finally, report how many bytes of data we want to send/receive.  */
       error = apple_smc_write_data(smc, size);
       if (error)
               return error;

       return 0;
}

static int
apple_smc_input(struct apple_smc_tag *smc, uint8_t cmd, const char *key,
   void *buffer, uint8_t size)
{
       uint8_t *bytes = buffer;
       uint8_t i;
       int error;

       /* Grab the SMC I/O lock.  */
       mutex_enter(&smc->smc_io_lock);

       /* Initiate the command with this key.  */
       error = apple_smc_begin(smc, cmd, key, size);
       if (error)
               goto out;

       /* Read each byte of data in sequence.  */
       for (i = 0; i < size; i++) {
               error = apple_smc_read_data(smc, &bytes[i]);
               if (error)
                       goto out;
       }

       /* Success!  */
       error = 0;

out:    mutex_exit(&smc->smc_io_lock);
       return error;
}

static int
apple_smc_output(struct apple_smc_tag *smc, uint8_t cmd, const char *key,
   const void *buffer, uint8_t size)
{
       const uint8_t *bytes = buffer;
       uint8_t i;
       int error;

       /* Grab the SMC I/O lock.  */
       mutex_enter(&smc->smc_io_lock);

       /* Initiate the command with this key.  */
       error = apple_smc_begin(smc, cmd, key, size);
       if (error)
               goto out;

       /* Write each byte of data in sequence.  */
       for (i = 0; i < size; i++) {
               error = apple_smc_write_data(smc, bytes[i]);
               if (error)
                       goto out;
       }

       /* Success!  */
       error = 0;

out:    mutex_exit(&smc->smc_io_lock);
       return error;
}

struct apple_smc_key {
       char ask_name[4 + 1];
       struct apple_smc_desc ask_desc;
#ifdef DIAGNOSTIC
       struct apple_smc_tag *ask_smc;
#endif
};

const char *
apple_smc_key_name(const struct apple_smc_key *key)
{

       return key->ask_name;
}

const struct apple_smc_desc *
apple_smc_key_desc(const struct apple_smc_key *key)
{

       return &key->ask_desc;
}

uint32_t
apple_smc_nkeys(struct apple_smc_tag *smc)
{

       return smc->smc_nkeys;
}

int
apple_smc_nth_key(struct apple_smc_tag *smc, uint32_t index,
   const char type[4 + 1], struct apple_smc_key **keyp)
{
       union { uint32_t u32; char name[4]; } index_be;
       struct apple_smc_key *key;
       int error;

       /* Paranoia: type must be NULL or 4 non-null characters long.  */
       if ((type != NULL) && (strlen(type) != 4))
               return EINVAL;

       /* Create a new key.  XXX Consider caching these.  */
       key = kmem_alloc(sizeof(*key), KM_SLEEP);
#ifdef DIAGNOSTIC
       key->ask_smc = smc;
#endif

       /* Ask the SMC what the name of the key by this number is.  */
       index_be.u32 = htobe32(index);
       error = apple_smc_input(smc, APPLE_SMC_CMD_NTH_KEY, index_be.name,
           key->ask_name, 4);
       if (error)
               goto fail;

       /* Null-terminate the name. */
       key->ask_name[4] = '\0';

       /* Ask the SMC for a description of this key by name.  */
       CTASSERT(sizeof(key->ask_desc) == 6);
       error = apple_smc_input(smc, APPLE_SMC_CMD_KEY_DESC, key->ask_name,
           &key->ask_desc, 6);
       if (error)
               goto fail;

       /* Fail with EINVAL if the types don't match.  */
       if ((type != NULL) && (0 != memcmp(key->ask_desc.asd_type, type, 4))) {
               error = EINVAL;
               goto fail;
       }

       /* Success!  */
       *keyp = key;
       return 0;

fail:   kmem_free(key, sizeof(*key));
       return error;
}

int
apple_smc_named_key(struct apple_smc_tag *smc, const char name[4 + 1],
   const char type[4 + 1], struct apple_smc_key **keyp)
{
       struct apple_smc_key *key;
       int error;

       /* Paranoia: name must be 4 non-null characters long.  */
       KASSERT(name != NULL);
       if (strlen(name) != 4)
               return EINVAL;

       /* Paranoia: type must be NULL or 4 non-null characters long.  */
       if ((type != NULL) && (strlen(type) != 4))
               return EINVAL;

       /* Create a new key.  XXX Consider caching these.  */
       key = kmem_alloc(sizeof(*key), KM_SLEEP);
#ifdef DIAGNOSTIC
       key->ask_smc = smc;
#endif

       /* Use the specified name, and make sure it's null-terminated.  */
       (void)memcpy(key->ask_name, name, 4);
       key->ask_name[4] = '\0';

       /* Ask the SMC for a description of this key by name.  */
       CTASSERT(sizeof(key->ask_desc) == 6);
       error = apple_smc_input(smc, APPLE_SMC_CMD_KEY_DESC, key->ask_name,
           &key->ask_desc, 6);
       if (error)
               goto fail;

       /* Fail with EINVAL if the types don't match.  */
       if ((type != NULL) && (0 != memcmp(key->ask_desc.asd_type, type, 4))) {
               error = EINVAL;
               goto fail;
       }

       /* Success!  */
       *keyp = key;
       return 0;

fail:   kmem_free(key, sizeof(*key));
       return error;
}

void
apple_smc_release_key(struct apple_smc_tag *smc, struct apple_smc_key *key)
{

#ifdef DIAGNOSTIC
       /* Make sure the caller didn't mix up SMC tags.  */
       if (key->ask_smc != smc)
               aprint_error_dev(smc->smc_dev,
                   "releasing key with wrong tag: %p != %p",
                   smc, key->ask_smc);
#endif

       /* Nothing to do but free the key's memory.  */
       kmem_free(key, sizeof(*key));
}

int
apple_smc_key_search(struct apple_smc_tag *smc, const char name[4 + 1],
   uint32_t *result)
{
       struct apple_smc_key *key;
       uint32_t start = 0, end = apple_smc_nkeys(smc), median;
       int cmp;
       int error;

       /* Do a binary search on the SMC's key space.  */
       while (start < end) {
               median = (start + ((end - start) / 2));
               error = apple_smc_nth_key(smc, median, NULL, &key);
               if (error)
                       return error;

               cmp = memcmp(name, apple_smc_key_name(key), 4);
               if (cmp < 0)
                       end = median;
               else if (cmp > 0)
                       start = (median + 1);
               else
                       start = end = median; /* stop here */

               apple_smc_release_key(smc, key);
       }

       /* Success!  */
       *result = start;
       return 0;
}

int
apple_smc_read_key(struct apple_smc_tag *smc, const struct apple_smc_key *key,
   void *buffer, uint8_t size)
{

       /* Refuse if software and hardware disagree on the key's size.  */
       if (key->ask_desc.asd_size != size)
               return EINVAL;

       /* Refuse if the hardware doesn't want us to read it.  */
       if (!(key->ask_desc.asd_flags & APPLE_SMC_FLAG_READ))
               return EACCES;

       /* Looks good.  Try reading it from the hardware.  */
       return apple_smc_input(smc, APPLE_SMC_CMD_READ_KEY, key->ask_name,
           buffer, size);
}

int
apple_smc_read_key_1(struct apple_smc_tag *smc,
   const struct apple_smc_key *key, uint8_t *p)
{

       return apple_smc_read_key(smc, key, p, 1);
}

int
apple_smc_read_key_2(struct apple_smc_tag *smc,
   const struct apple_smc_key *key, uint16_t *p)
{
       uint16_t be;
       int error;

       /* Read a big-endian quantity from the hardware.  */
       error = apple_smc_read_key(smc, key, &be, 2);
       if (error)
               return error;

       /* Convert it to host order.  */
       *p = be16toh(be);

       /* Success!  */
       return 0;
}

int
apple_smc_read_key_4(struct apple_smc_tag *smc,
   const struct apple_smc_key *key, uint32_t *p)
{
       uint32_t be;
       int error;

       /* Read a big-endian quantity from the hardware.  */
       error = apple_smc_read_key(smc, key, &be, 4);
       if (error)
               return error;

       /* Convert it to host order.  */
       *p = be32toh(be);

       /* Success!  */
       return 0;
}

int
apple_smc_write_key(struct apple_smc_tag *smc, const struct apple_smc_key *key,
   const void *buffer, uint8_t size)
{

       /* Refuse if software and hardware disagree on the key's size.  */
       if (key->ask_desc.asd_size != size)
               return EINVAL;

       /* Refuse if the hardware doesn't want us to write it.  */
       if (!(key->ask_desc.asd_flags & APPLE_SMC_FLAG_WRITE))
               return EACCES;

       /* Looks good.  Try writing it to the hardware.  */
       return apple_smc_output(smc, APPLE_SMC_CMD_WRITE_KEY, key->ask_name,
           buffer, size);
}

int
apple_smc_write_key_1(struct apple_smc_tag *smc,
   const struct apple_smc_key *key, uint8_t v)
{

       return apple_smc_write_key(smc, key, &v, 1);
}

int
apple_smc_write_key_2(struct apple_smc_tag *smc,
   const struct apple_smc_key *key, uint16_t v)
{
       /* Convert the quantity from host to big-endian byte order.  */
       const uint16_t v_be = htobe16(v);

       /* Write the big-endian quantity to the hardware.  */
       return apple_smc_write_key(smc, key, &v_be, 2);
}

int
apple_smc_write_key_4(struct apple_smc_tag *smc,
   const struct apple_smc_key *key, uint32_t v)
{
       /* Convert the quantity from host to big-endian byte order.  */
       const uint32_t v_be = htobe32(v);

       /* Write the big-endian quantity to the hardware.  */
       return apple_smc_write_key(smc, key, &v_be, 4);
}

MODULE(MODULE_CLASS_MISC, apple_smc, NULL)

static int
apple_smc_modcmd(modcmd_t cmd, void *data __unused)
{

       /* Nothing to do for now to set up or tear down the module.  */
       switch (cmd) {
       case MODULE_CMD_INIT:
               return 0;

       case MODULE_CMD_FINI:
               return 0;

       default:
               return ENOTTY;
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.