/* $NetBSD: rpi_vcmbox.c,v 1.8 2021/03/08 13:53:08 mlelstv Exp $ */

/*-
* Copyright (c) 2013 Jared D. McNeill <[email protected]>
* All rights reserved.
*
* 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.
*/

/*
* Raspberry Pi VC Mailbox Interface
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: rpi_vcmbox.c,v 1.8 2021/03/08 13:53:08 mlelstv Exp $");

#include <sys/param.h>
#include <sys/types.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/endian.h>
#include <sys/kmem.h>
#include <sys/systm.h>
#include <sys/sysctl.h>

#include <dev/sysmon/sysmonvar.h>

#include <arm/broadcom/bcm2835_mbox.h>

#include <evbarm/rpi/vcio.h>
#include <evbarm/rpi/vcprop.h>

struct vcmbox_temp_request {
       struct vcprop_buffer_hdr        vb_hdr;
       struct vcprop_tag_temperature   vbt_temp;
       struct vcprop_tag end;
} __packed;

struct vcmbox_clockrate_request {
       struct vcprop_buffer_hdr        vb_hdr;
       struct vcprop_tag_clockrate     vbt_clockrate;
       struct vcprop_tag end;
} __packed;

#define RATE2MHZ(rate)  ((rate) / 1000000)
#define MHZ2RATE(mhz)   ((mhz) * 1000000)

#define VCMBOX_INIT_REQUEST(r)          VCPROP_INIT_REQUEST(r)
#define VCMBOX_INIT_TAG(s, t)           VCPROP_INIT_TAG(s, t)

struct vcmbox_softc {
       device_t                sc_dev;

       /* temperature sensor */
       struct sysmon_envsys    *sc_sme;
#define VCMBOX_SENSOR_TEMP      0
#define VCMBOX_NSENSORS         1
       envsys_data_t           sc_sensor[VCMBOX_NSENSORS];

       /* cpu frequency scaling */
       struct sysctllog        *sc_log;
       uint32_t                sc_cpu_minrate;
       uint32_t                sc_cpu_maxrate;
       int                     sc_node_target;
       int                     sc_node_current;
       int                     sc_node_min;
       int                     sc_node_max;
};

static const char *vcmbox_sensor_name[VCMBOX_NSENSORS] = {
       "temperature",
};

static int vcmbox_sensor_id[VCMBOX_NSENSORS] = {
       VCPROP_TEMP_SOC,
};

static int      vcmbox_match(device_t, cfdata_t, void *);
static void     vcmbox_attach(device_t, device_t, void *);

static int      vcmbox_read_temp(struct vcmbox_softc *, uint32_t, int,
                                uint32_t *);
static int      vcmbox_read_clockrate(struct vcmbox_softc *, uint32_t, int,
                                uint32_t *);
static int      vcmbox_write_clockrate(struct vcmbox_softc *, uint32_t, int,
                                uint32_t);

static int      vcmbox_cpufreq_init(struct vcmbox_softc *);
static int      vcmbox_cpufreq_sysctl_helper(SYSCTLFN_PROTO);

static void     vcmbox_create_sensors(struct vcmbox_softc *);
static void     vcmbox_sensor_get_limits(struct sysmon_envsys *,
                                        envsys_data_t *,
                                        sysmon_envsys_lim_t *, uint32_t *);
static void     vcmbox_sensor_refresh(struct sysmon_envsys *,
                                     envsys_data_t *);

CFATTACH_DECL_NEW(vcmbox, sizeof(struct vcmbox_softc),
   vcmbox_match, vcmbox_attach, NULL, NULL);

static int
vcmbox_match(device_t parent, cfdata_t match, void *aux)
{
       return 1;
}

static void
vcmbox_attach(device_t parent, device_t self, void *aux)
{
       struct vcmbox_softc *sc = device_private(self);

       sc->sc_dev = self;

       aprint_naive("\n");
       aprint_normal("\n");

       vcmbox_cpufreq_init(sc);

       sc->sc_sme = sysmon_envsys_create();
       sc->sc_sme->sme_cookie = sc;
       sc->sc_sme->sme_name = device_xname(sc->sc_dev);
       sc->sc_sme->sme_refresh = vcmbox_sensor_refresh;
       sc->sc_sme->sme_get_limits = vcmbox_sensor_get_limits;
       vcmbox_create_sensors(sc);
       if (sysmon_envsys_register(sc->sc_sme) == 0)
               return;

       aprint_error_dev(self, "unable to register with sysmon\n");
       sysmon_envsys_destroy(sc->sc_sme);
}

static int
vcmbox_read_temp(struct vcmbox_softc *sc, uint32_t tag, int id, uint32_t *val)
{
       struct vcmbox_temp_request vb;
       uint32_t res;
       int error;

       VCMBOX_INIT_REQUEST(vb);
       VCMBOX_INIT_TAG(vb.vbt_temp, tag);
       vb.vbt_temp.id = htole32(id);
       error = bcmmbox_request(BCMMBOX_CHANARM2VC, &vb, sizeof(vb), &res);
       if (error)
               return error;
       if (!vcprop_buffer_success_p(&vb.vb_hdr) ||
           !vcprop_tag_success_p(&vb.vbt_temp.tag)) {
               return EIO;
       }
       *val = le32toh(vb.vbt_temp.value);

       return 0;
}

static int
vcmbox_read_clockrate(struct vcmbox_softc *sc, uint32_t tag, int id,
   uint32_t *val)
{
       struct vcmbox_clockrate_request vb;
       uint32_t res;
       int error;

       VCMBOX_INIT_REQUEST(vb);
       VCMBOX_INIT_TAG(vb.vbt_clockrate, tag);
       vb.vbt_clockrate.id = htole32(id);
       error = bcmmbox_request(BCMMBOX_CHANARM2VC, &vb, sizeof(vb), &res);
       if (error)
               return error;
       if (!vcprop_buffer_success_p(&vb.vb_hdr) ||
           !vcprop_tag_success_p(&vb.vbt_clockrate.tag)) {
               return EIO;
       }
       *val = le32toh(vb.vbt_clockrate.rate);

       return 0;
}

static int
vcmbox_write_clockrate(struct vcmbox_softc *sc, uint32_t tag, int id,
   uint32_t val)
{
       struct vcmbox_clockrate_request vb;
       uint32_t res;
       int error;

       VCMBOX_INIT_REQUEST(vb);
       VCMBOX_INIT_TAG(vb.vbt_clockrate, tag);
       vb.vbt_clockrate.id = htole32(id);
       vb.vbt_clockrate.rate = htole32(val);
       error = bcmmbox_request(BCMMBOX_CHANARM2VC, &vb, sizeof(vb), &res);
       if (error)
               return error;
       if (!vcprop_buffer_success_p(&vb.vb_hdr) ||
           !vcprop_tag_success_p(&vb.vbt_clockrate.tag)) {
               return EIO;
       }

       return 0;
}


static int
vcmbox_cpufreq_init(struct vcmbox_softc *sc)
{
       const struct sysctlnode *node, *cpunode, *freqnode;
       int error;
       static char available[20];

       error = vcmbox_read_clockrate(sc, VCPROPTAG_GET_MIN_CLOCKRATE,
           VCPROP_CLK_ARM, &sc->sc_cpu_minrate);
       if (error) {
               aprint_error_dev(sc->sc_dev, "couldn't read min clkrate (%d)\n",
                   error);
               return error;
       }
       error = vcmbox_read_clockrate(sc, VCPROPTAG_GET_MAX_CLOCKRATE,
           VCPROP_CLK_ARM, &sc->sc_cpu_maxrate);
       if (error) {
               aprint_error_dev(sc->sc_dev, "couldn't read max clkrate (%d)\n",
                   error);
               return error;
       }

       error = sysctl_createv(&sc->sc_log, 0, NULL, &node,
           CTLFLAG_PERMANENT, CTLTYPE_NODE, "machdep", NULL,
           NULL, 0, NULL, 0, CTL_MACHDEP, CTL_EOL);
       if (error)
               goto sysctl_failed;
       error = sysctl_createv(&sc->sc_log, 0, &node, &cpunode,
           0, CTLTYPE_NODE, "cpu", NULL,
           NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;
       error = sysctl_createv(&sc->sc_log, 0, &cpunode, &freqnode,
           0, CTLTYPE_NODE, "frequency", NULL,
           NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;

       error = sysctl_createv(&sc->sc_log, 0, &freqnode, &node,
           CTLFLAG_READWRITE, CTLTYPE_INT, "target", NULL,
           vcmbox_cpufreq_sysctl_helper, 0, (void *)sc, 0,
           CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;
       sc->sc_node_target = node->sysctl_num;

       error = sysctl_createv(&sc->sc_log, 0, &freqnode, &node,
           0, CTLTYPE_INT, "current", NULL,
           vcmbox_cpufreq_sysctl_helper, 0, (void *)sc, 0,
           CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;
       sc->sc_node_current = node->sysctl_num;

       error = sysctl_createv(&sc->sc_log, 0, &freqnode, &node,
           0, CTLTYPE_INT, "min", NULL,
           vcmbox_cpufreq_sysctl_helper, 0, (void *)sc, 0,
           CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;
       sc->sc_node_min = node->sysctl_num;

       error = sysctl_createv(&sc->sc_log, 0, &freqnode, &node,
           0, CTLTYPE_INT, "max", NULL,
           vcmbox_cpufreq_sysctl_helper, 0, (void *)sc, 0,
           CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;
       sc->sc_node_max = node->sysctl_num;

       snprintf(available, sizeof(available), "%" PRIu32 " %" PRIu32,
           RATE2MHZ(sc->sc_cpu_minrate), RATE2MHZ(sc->sc_cpu_maxrate));

       error = sysctl_createv(&sc->sc_log, 0, &freqnode, &node,
           CTLFLAG_PERMANENT, CTLTYPE_STRING, "available", NULL,
           NULL, 0, available, strlen(available),
           CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;

       return 0;

sysctl_failed:
       aprint_error_dev(sc->sc_dev, "couldn't create sysctl nodes (%d)\n",
           error);
       sysctl_teardown(&sc->sc_log);
       return error;
}

static int
vcmbox_cpufreq_sysctl_helper(SYSCTLFN_ARGS)
{
       struct sysctlnode node;
       struct vcmbox_softc *sc;
       int fq, oldfq = 0, error;
       uint32_t rate;

       node = *rnode;
       sc = node.sysctl_data;

       node.sysctl_data = &fq;

       if (rnode->sysctl_num == sc->sc_node_target ||
           rnode->sysctl_num == sc->sc_node_current) {
               error = vcmbox_read_clockrate(sc, VCPROPTAG_GET_CLOCKRATE,
                   VCPROP_CLK_ARM, &rate);
               if (error)
                       return error;
               fq = RATE2MHZ(rate);
               if (rnode->sysctl_num == sc->sc_node_target)
                       oldfq = fq;
       } else if (rnode->sysctl_num == sc->sc_node_min) {
               fq = RATE2MHZ(sc->sc_cpu_minrate);
       } else if (rnode->sysctl_num == sc->sc_node_max) {
               fq = RATE2MHZ(sc->sc_cpu_maxrate);
       } else
               return EOPNOTSUPP;

       error = sysctl_lookup(SYSCTLFN_CALL(&node));
       if (error || newp == NULL)
               return error;

       if (fq == oldfq || rnode->sysctl_num != sc->sc_node_target)
               return 0;

       if (fq < RATE2MHZ(sc->sc_cpu_minrate))
               fq = RATE2MHZ(sc->sc_cpu_minrate);
       if (fq > RATE2MHZ(sc->sc_cpu_maxrate))
               fq = RATE2MHZ(sc->sc_cpu_maxrate);

       return vcmbox_write_clockrate(sc, VCPROPTAG_SET_CLOCKRATE,
           VCPROP_CLK_ARM, MHZ2RATE(fq));
}

static void
vcmbox_create_sensors(struct vcmbox_softc *sc)
{
       uint32_t val;

       sc->sc_sensor[VCMBOX_SENSOR_TEMP].sensor = VCMBOX_SENSOR_TEMP;
       sc->sc_sensor[VCMBOX_SENSOR_TEMP].units = ENVSYS_STEMP;
       sc->sc_sensor[VCMBOX_SENSOR_TEMP].state = ENVSYS_SINVALID;
       sc->sc_sensor[VCMBOX_SENSOR_TEMP].flags = ENVSYS_FMONLIMITS |
                                                 ENVSYS_FHAS_ENTROPY;
       strlcpy(sc->sc_sensor[VCMBOX_SENSOR_TEMP].desc,
           vcmbox_sensor_name[VCMBOX_SENSOR_TEMP],
           sizeof(sc->sc_sensor[VCMBOX_SENSOR_TEMP].desc));
       if (vcmbox_read_temp(sc, VCPROPTAG_GET_MAX_TEMPERATURE,
                            vcmbox_sensor_id[VCMBOX_SENSOR_TEMP], &val) == 0) {
               sc->sc_sensor[VCMBOX_SENSOR_TEMP].value_max =
                   val * 1000 + 273150000;
               sc->sc_sensor[VCMBOX_SENSOR_TEMP].flags |= ENVSYS_FVALID_MAX;
       }
       sysmon_envsys_sensor_attach(sc->sc_sme,
           &sc->sc_sensor[VCMBOX_SENSOR_TEMP]);
}

static void
vcmbox_sensor_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
   sysmon_envsys_lim_t *limits, uint32_t *props)
{
       struct vcmbox_softc *sc = sme->sme_cookie;
       uint32_t val;

       *props = 0;

       if (edata->units == ENVSYS_STEMP) {
               if (vcmbox_read_temp(sc, VCPROPTAG_GET_MAX_TEMPERATURE,
                                    vcmbox_sensor_id[edata->sensor], &val))
                       return;
               *props = PROP_CRITMAX;
               limits->sel_critmax = val * 1000 + 273150000;
       }
}

static void
vcmbox_sensor_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
       struct vcmbox_softc *sc = sme->sme_cookie;
       uint32_t val;

       edata->state = ENVSYS_SINVALID;

       if (edata->units == ENVSYS_STEMP) {
               if (vcmbox_read_temp(sc, VCPROPTAG_GET_TEMPERATURE,
                                    vcmbox_sensor_id[edata->sensor], &val))
                       return;

               edata->value_cur = val * 1000 + 273150000;
               edata->state = ENVSYS_SVALID;
       }
}

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.