sys/arm64/rockchip/clk/rk_clk_mux.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright 2016 Michal Meloun <mmel@FreeBSD.org>
   5  * All rights reserved.
   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  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32
  33 #include <sys/param.h>
  34 #include <sys/conf.h>
  35 #include <sys/bus.h>
  36 #include <sys/kernel.h>
  37 #include <sys/systm.h>
  38
  39 #include <machine/bus.h>
  40
  41 #include <dev/extres/clk/clk.h>
  42
  43 #include <arm64/rockchip/clk/rk_cru.h>
  44 #include <arm64/rockchip/clk/rk_clk_mux.h>
  45
  46 #include "clkdev_if.h"
  47
  48 #define WR4(_clk, off, val)                                             \
  49         CLKDEV_WRITE_4(clknode_get_device(_clk), off, val)
  50 #define RD4(_clk, off, val)                                             \
  51         CLKDEV_READ_4(clknode_get_device(_clk), off, val)
  52 #define MD4(_clk, off, clr, set )                                       \
  53         CLKDEV_MODIFY_4(clknode_get_device(_clk), off, clr, set)
  54 #define DEVICE_LOCK(_clk)                                                       \
  55         CLKDEV_DEVICE_LOCK(clknode_get_device(_clk))
  56 #define DEVICE_UNLOCK(_clk)                                             \
  57         CLKDEV_DEVICE_UNLOCK(clknode_get_device(_clk))
  58
  59 static int rk_clk_mux_init(struct clknode *clk, device_t dev);
  60 static int rk_clk_mux_set_mux(struct clknode *clk, int idx);
  61
  62 struct rk_clk_mux_sc {
  63         uint32_t        offset;
  64         uint32_t        shift;
  65         uint32_t        mask;
  66         int             mux_flags;
  67 };
  68
  69 static clknode_method_t rk_clk_mux_methods[] = {
  70         /* Device interface */
  71         CLKNODEMETHOD(clknode_init,     rk_clk_mux_init),
  72         CLKNODEMETHOD(clknode_set_mux,  rk_clk_mux_set_mux),
  73         CLKNODEMETHOD_END
  74 };
  75 DEFINE_CLASS_1(rk_clk_mux, rk_clk_mux_class, rk_clk_mux_methods,
  76    sizeof(struct rk_clk_mux_sc), clknode_class);
  77
  78
  79 static int
  80 rk_clk_mux_init(struct clknode *clk, device_t dev)
  81 {
  82         uint32_t reg;
  83         struct rk_clk_mux_sc *sc;
  84         int rv;
  85
  86         sc = clknode_get_softc(clk);
  87
  88         DEVICE_LOCK(clk);
  89         rv = RD4(clk, sc->offset, &reg);
  90         DEVICE_UNLOCK(clk);
  91         if (rv != 0) {
  92                 return (rv);
  93         }
  94         reg = (reg >> sc->shift) & sc->mask;
  95         clknode_init_parent_idx(clk, reg);
  96         return(0);
  97 }
  98
  99 static int
 100 rk_clk_mux_set_mux(struct clknode *clk, int idx)
 101 {
 102         uint32_t reg;
 103         struct rk_clk_mux_sc *sc;
 104         int rv;
 105
 106         sc = clknode_get_softc(clk);
 107
 108         DEVICE_LOCK(clk);
 109         rv = MD4(clk, sc->offset, sc->mask << sc->shift,
 110             ((idx & sc->mask) << sc->shift) | RK_CLK_MUX_MASK);
 111         if (rv != 0) {
 112                 DEVICE_UNLOCK(clk);
 113                 return (rv);
 114         }
 115         RD4(clk, sc->offset, &reg);
 116         DEVICE_UNLOCK(clk);
 117
 118         return(0);
 119 }
 120
 121 int
 122 rk_clk_mux_register(struct clkdom *clkdom, struct rk_clk_mux_def *clkdef)
 123 {
 124         struct clknode *clk;
 125         struct rk_clk_mux_sc *sc;
 126
 127         clk = clknode_create(clkdom, &rk_clk_mux_class, &clkdef->clkdef);
 128         if (clk == NULL)
 129                 return (1);
 130
 131         sc = clknode_get_softc(clk);
 132         sc->offset = clkdef->offset;
 133         sc->shift = clkdef->shift;
 134         sc->mask =  (1 << clkdef->width) - 1;
 135         sc->mux_flags = clkdef->mux_flags;
 136
 137         clknode_register(clkdom, clk);
 138         return (0);
 139 }