/* $NetBSD: clk.c,v 1.8 2024/06/12 06:23:56 rin Exp $ */

/*-
* Copyright (c) 2015 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 AUTHOR ``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 AUTHOR 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: clk.c,v 1.8 2024/06/12 06:23:56 rin Exp $");

#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/kmem.h>

#include <dev/clk/clk.h>
#include <dev/clk/clk_backend.h>

static struct sysctllog *clk_log;
static const struct sysctlnode *clk_node;

static int
create_clk_node(void)
{
       const struct sysctlnode *hw_node;
       int error;

       if (clk_node)
               return 0;

       error = sysctl_createv(&clk_log, 0, NULL, &hw_node,
           CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL,
           NULL, 0, NULL, 0, CTL_HW, CTL_EOL);
       if (error)
               return error;

       error = sysctl_createv(&clk_log, 0, &hw_node, &clk_node,
           CTLFLAG_PERMANENT, CTLTYPE_NODE, "clk", NULL,
           NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL);
       if (error)
               return error;

       return 0;
}

static int
create_domain_node(struct clk_domain *domain)
{
       int error;

       if (domain->node)
               return 0;

       error = create_clk_node();
       if (error)
               return error;

       error = sysctl_createv(&clk_log, 0, &clk_node, &domain->node,
           0, CTLTYPE_NODE, domain->name, NULL,
           NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL);
       if (error)
               return error;

       return 0;
}

static int
clk_sysctl_rate_helper(SYSCTLFN_ARGS)
{
       struct sysctlnode node;
       struct clk *clk;
       uint64_t rate;

       node = *rnode;
       clk = node.sysctl_data;
       node.sysctl_data = &rate;

       rate = clk_get_rate(clk);

       return sysctl_lookup(SYSCTLFN_CALL(&node));
}

static int
clk_sysctl_parent_helper(SYSCTLFN_ARGS)
{
       struct sysctlnode node;
       struct clk *clk, *clk_parent;

       node = *rnode;
       clk = node.sysctl_data;

       clk_parent = clk_get_parent(clk);
       if (clk_parent && clk_parent->name)
               node.sysctl_data = __UNCONST(clk_parent->name);
       else
               node.sysctl_data = __UNCONST("?");

       return sysctl_lookup(SYSCTLFN_CALL(&node));
}

static int
clk_sysctl_parent_domain_helper(SYSCTLFN_ARGS)
{
       struct sysctlnode node;
       struct clk *clk, *clk_parent;

       node = *rnode;
       clk = node.sysctl_data;

       clk_parent = clk_get_parent(clk);
       if (clk_parent && clk_parent->domain && clk_parent->domain->name)
               node.sysctl_data = __UNCONST(clk_parent->domain->name);
       else
               node.sysctl_data = __UNCONST("?");

       return sysctl_lookup(SYSCTLFN_CALL(&node));
}

static void
clk_normalize_name(char *name)
{
       unsigned char *p;

       for (p = (unsigned char *)name; *p; p++)
               if (!isalpha(*p) && !isdigit(*p) && *p != '-' && *p != '_')
                       *p = '_';
}

int
clk_attach(struct clk *clk)
{
       const struct sysctlnode *node;
       struct clk_domain *domain = clk->domain;
       char *name;
       size_t namelen;
       int error;

       KASSERT(domain != NULL);

       if (!domain->name || !clk->name) {
               /* Names are required to create sysctl nodes */
               return 0;
       }

       namelen = strlen(clk->name) + 1;
       name = kmem_zalloc(namelen, KM_SLEEP);
       memcpy(name, clk->name, namelen);
       clk_normalize_name(name);

       error = create_domain_node(domain);
       if (error != 0)
               goto sysctl_failed;

       error = sysctl_createv(&clk_log, 0, &domain->node, &node,
           CTLFLAG_PRIVATE, CTLTYPE_NODE, name, NULL,
           NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;

       error = sysctl_createv(&clk_log, 0, &node, NULL,
           CTLFLAG_PRIVATE, CTLTYPE_QUAD, "rate", NULL,
           clk_sysctl_rate_helper, 0, (void *)clk, 0,
           CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;

       error = sysctl_createv(&clk_log, 0, &node, NULL,
           CTLFLAG_PRIVATE, CTLTYPE_STRING, "parent", NULL,
           clk_sysctl_parent_helper, 0, (void *)clk, 0,
           CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;

       error = sysctl_createv(&clk_log, 0, &node, NULL,
           CTLFLAG_PRIVATE, CTLTYPE_STRING, "parent_domain", NULL,
           clk_sysctl_parent_domain_helper, 0, (void *)clk, 0,
           CTL_CREATE, CTL_EOL);
       if (error)
               goto sysctl_failed;

sysctl_failed:
       if (error)
               aprint_error("%s: failed to create sysctl node for %s (%s): %d\n",
                   domain->name, clk->name, name, error);

       kmem_free(name, namelen);
       return error;
}

struct clk *
clk_get(struct clk_domain *domain, const char *name)
{
       return domain->funcs->get(domain->priv, name);
}

void
clk_put(struct clk *clk)
{
       if (clk->domain->funcs->put)
               clk->domain->funcs->put(clk->domain->priv, clk);
}

u_int
clk_get_rate(struct clk *clk)
{
       return clk->domain->funcs->get_rate(clk->domain->priv, clk);
}

int
clk_set_rate(struct clk *clk, u_int rate)
{
       KASSERT(clk != NULL);

       if (clk->flags & CLK_SET_RATE_PARENT)
               return clk_set_rate(clk_get_parent(clk), rate);

       if (clk->domain->funcs->set_rate)
               return clk->domain->funcs->set_rate(clk->domain->priv,
                   clk, rate);

       if (clk_get_rate(clk) == rate)
               return 0;

       return EINVAL;
}

u_int
clk_round_rate(struct clk *clk, u_int rate)
{
       if (clk->domain->funcs->round_rate) {
               return clk->domain->funcs->round_rate(clk->domain->priv,
                   clk, rate);
       }
       return 0;
}

int
clk_enable(struct clk *clk)
{
       if (clk->domain->funcs->enable)
               return clk->domain->funcs->enable(clk->domain->priv, clk);
       else
               return 0;
}

int
clk_disable(struct clk *clk)
{
       if (clk->domain->funcs->disable)
               return clk->domain->funcs->disable(clk->domain->priv, clk);
       else
               return EINVAL;
}

int
clk_set_parent(struct clk *clk, struct clk *parent_clk)
{
       if (clk->domain->funcs->set_parent)
               return clk->domain->funcs->set_parent(clk->domain->priv,
                   clk, parent_clk);
       else
               return EINVAL;
}

struct clk *
clk_get_parent(struct clk *clk)
{
       if (clk->domain->funcs->get_parent)
               return clk->domain->funcs->get_parent(clk->domain->priv, clk);
       else
               return NULL;
}

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.