dm: define LOG_CATEGORY for all uclass
[platform/kernel/u-boot.git] / drivers / rtc / rtc-uclass.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * (C) Copyright 2015 Google, Inc
4  * Written by Simon Glass <sjg@chromium.org>
5  */
6
7 #define LOG_CATEGORY UCLASS_RTC
8
9 #include <common.h>
10 #include <dm.h>
11 #include <errno.h>
12 #include <log.h>
13 #include <rtc.h>
14
15 int dm_rtc_get(struct udevice *dev, struct rtc_time *time)
16 {
17         struct rtc_ops *ops = rtc_get_ops(dev);
18
19         assert(ops);
20         if (!ops->get)
21                 return -ENOSYS;
22         return ops->get(dev, time);
23 }
24
25 int dm_rtc_set(struct udevice *dev, struct rtc_time *time)
26 {
27         struct rtc_ops *ops = rtc_get_ops(dev);
28
29         assert(ops);
30         if (!ops->set)
31                 return -ENOSYS;
32         return ops->set(dev, time);
33 }
34
35 int dm_rtc_reset(struct udevice *dev)
36 {
37         struct rtc_ops *ops = rtc_get_ops(dev);
38
39         assert(ops);
40         if (!ops->reset)
41                 return -ENOSYS;
42         return ops->reset(dev);
43 }
44
45 int dm_rtc_read(struct udevice *dev, unsigned int reg, u8 *buf, unsigned int len)
46 {
47         struct rtc_ops *ops = rtc_get_ops(dev);
48
49         assert(ops);
50         if (ops->read)
51                 return ops->read(dev, reg, buf, len);
52         if (!ops->read8)
53                 return -ENOSYS;
54         while (len--) {
55                 int ret = ops->read8(dev, reg++);
56
57                 if (ret < 0)
58                         return ret;
59                 *buf++ = ret;
60         }
61         return 0;
62 }
63
64 int dm_rtc_write(struct udevice *dev, unsigned int reg,
65                  const u8 *buf, unsigned int len)
66 {
67         struct rtc_ops *ops = rtc_get_ops(dev);
68
69         assert(ops);
70         if (ops->write)
71                 return ops->write(dev, reg, buf, len);
72         if (!ops->write8)
73                 return -ENOSYS;
74         while (len--) {
75                 int ret = ops->write8(dev, reg++, *buf++);
76
77                 if (ret < 0)
78                         return ret;
79         }
80         return 0;
81 }
82
83 int rtc_read8(struct udevice *dev, unsigned int reg)
84 {
85         struct rtc_ops *ops = rtc_get_ops(dev);
86
87         assert(ops);
88         if (ops->read8)
89                 return ops->read8(dev, reg);
90         if (ops->read) {
91                 u8 buf[1];
92                 int ret = ops->read(dev, reg, buf, 1);
93
94                 if (ret < 0)
95                         return ret;
96                 return buf[0];
97         }
98         return -ENOSYS;
99 }
100
101 int rtc_write8(struct udevice *dev, unsigned int reg, int val)
102 {
103         struct rtc_ops *ops = rtc_get_ops(dev);
104
105         assert(ops);
106         if (ops->write8)
107                 return ops->write8(dev, reg, val);
108         if (ops->write) {
109                 u8 buf[1] = { val };
110
111                 return ops->write(dev, reg, buf, 1);
112         }
113         return -ENOSYS;
114 }
115
116 int rtc_read16(struct udevice *dev, unsigned int reg, u16 *valuep)
117 {
118         u16 value = 0;
119         int ret;
120         int i;
121
122         for (i = 0; i < sizeof(value); i++) {
123                 ret = rtc_read8(dev, reg + i);
124                 if (ret < 0)
125                         return ret;
126                 value |= ret << (i << 3);
127         }
128
129         *valuep = value;
130         return 0;
131 }
132
133 int rtc_write16(struct udevice *dev, unsigned int reg, u16 value)
134 {
135         int i, ret;
136
137         for (i = 0; i < sizeof(value); i++) {
138                 ret = rtc_write8(dev, reg + i, (value >> (i << 3)) & 0xff);
139                 if (ret)
140                         return ret;
141         }
142
143         return 0;
144 }
145
146 int rtc_read32(struct udevice *dev, unsigned int reg, u32 *valuep)
147 {
148         u32 value = 0;
149         int ret;
150         int i;
151
152         for (i = 0; i < sizeof(value); i++) {
153                 ret = rtc_read8(dev, reg + i);
154                 if (ret < 0)
155                         return ret;
156                 value |= ret << (i << 3);
157         }
158
159         *valuep = value;
160         return 0;
161 }
162
163 int rtc_write32(struct udevice *dev, unsigned int reg, u32 value)
164 {
165         int i, ret;
166
167         for (i = 0; i < sizeof(value); i++) {
168                 ret = rtc_write8(dev, reg + i, (value >> (i << 3)) & 0xff);
169                 if (ret)
170                         return ret;
171         }
172
173         return 0;
174 }
175
176 UCLASS_DRIVER(rtc) = {
177         .name           = "rtc",
178         .id             = UCLASS_RTC,
179 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
180         .post_bind      = dm_scan_fdt_dev,
181 #endif
182 };