drivers/rtc/rtc-optee.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2022 Microchip.
   4  */
   5
   6 #include <linux/device.h>
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/rtc.h>
  10 #include <linux/tee_drv.h>
  11
  12 #define RTC_INFO_VERSION        0x1
  13
  14 #define TA_CMD_RTC_GET_INFO             0x0
  15 #define TA_CMD_RTC_GET_TIME             0x1
  16 #define TA_CMD_RTC_SET_TIME             0x2
  17 #define TA_CMD_RTC_GET_OFFSET           0x3
  18 #define TA_CMD_RTC_SET_OFFSET           0x4
  19
  20 #define TA_RTC_FEATURE_CORRECTION       BIT(0)
  21
  22 struct optee_rtc_time {
  23         u32 tm_sec;
  24         u32 tm_min;
  25         u32 tm_hour;
  26         u32 tm_mday;
  27         u32 tm_mon;
  28         u32 tm_year;
  29         u32 tm_wday;
  30 };
  31
  32 struct optee_rtc_info {
  33         u64 version;
  34         u64 features;
  35         struct optee_rtc_time range_min;
  36         struct optee_rtc_time range_max;
  37 };
  38
  39 /**
  40  * struct optee_rtc - OP-TEE RTC private data
  41  * @dev:                OP-TEE based RTC device.
  42  * @ctx:                OP-TEE context handler.
  43  * @session_id:         RTC TA session identifier.
  44  * @shm:                Memory pool shared with RTC device.
  45  * @features:           Bitfield of RTC features
  46  */
  47 struct optee_rtc {
  48         struct device *dev;
  49         struct tee_context *ctx;
  50         u32 session_id;
  51         struct tee_shm *shm;
  52         u64 features;
  53 };
  54
  55 static int optee_rtc_readtime(struct device *dev, struct rtc_time *tm)
  56 {
  57         struct optee_rtc *priv = dev_get_drvdata(dev);
  58         struct tee_ioctl_invoke_arg inv_arg = {0};
  59         struct optee_rtc_time *optee_tm;
  60         struct tee_param param[4] = {0};
  61         int ret;
  62
  63         inv_arg.func = TA_CMD_RTC_GET_TIME;
  64         inv_arg.session = priv->session_id;
  65         inv_arg.num_params = 4;
  66
  67         /* Fill invoke cmd params */
  68         param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT;
  69         param[0].u.memref.shm = priv->shm;
  70         param[0].u.memref.size = sizeof(struct optee_rtc_time);
  71
  72         ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
  73         if (ret < 0 || inv_arg.ret != 0)
  74                 return ret ? ret : -EPROTO;
  75
  76         optee_tm = tee_shm_get_va(priv->shm, 0);
  77         if (IS_ERR(optee_tm))
  78                 return PTR_ERR(optee_tm);
  79
  80         if (param[0].u.memref.size != sizeof(*optee_tm))
  81                 return -EPROTO;
  82
  83         tm->tm_sec = optee_tm->tm_sec;
  84         tm->tm_min = optee_tm->tm_min;
  85         tm->tm_hour = optee_tm->tm_hour;
  86         tm->tm_mday = optee_tm->tm_mday;
  87         tm->tm_mon = optee_tm->tm_mon;
  88         tm->tm_year = optee_tm->tm_year - 1900;
  89         tm->tm_wday = optee_tm->tm_wday;
  90         tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
  91
  92         return 0;
  93 }
  94
  95 static int optee_rtc_settime(struct device *dev, struct rtc_time *tm)
  96 {
  97         struct optee_rtc *priv = dev_get_drvdata(dev);
  98         struct tee_ioctl_invoke_arg inv_arg = {0};
  99         struct tee_param param[4] = {0};
 100         struct optee_rtc_time optee_tm;
 101         void *rtc_data;
 102         int ret;
 103
 104         optee_tm.tm_sec = tm->tm_sec;
 105         optee_tm.tm_min = tm->tm_min;
 106         optee_tm.tm_hour = tm->tm_hour;
 107         optee_tm.tm_mday = tm->tm_mday;
 108         optee_tm.tm_mon = tm->tm_mon;
 109         optee_tm.tm_year = tm->tm_year + 1900;
 110         optee_tm.tm_wday = tm->tm_wday;
 111
 112         inv_arg.func = TA_CMD_RTC_SET_TIME;
 113         inv_arg.session = priv->session_id;
 114         inv_arg.num_params = 4;
 115
 116         param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
 117         param[0].u.memref.shm = priv->shm;
 118         param[0].u.memref.size = sizeof(struct optee_rtc_time);
 119
 120         rtc_data = tee_shm_get_va(priv->shm, 0);
 121         if (IS_ERR(rtc_data))
 122                 return PTR_ERR(rtc_data);
 123
 124         memcpy(rtc_data, &optee_tm, sizeof(struct optee_rtc_time));
 125
 126         ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
 127         if (ret < 0 || inv_arg.ret != 0)
 128                 return ret ? ret : -EPROTO;
 129
 130         return 0;
 131 }
 132
 133 static int optee_rtc_readoffset(struct device *dev, long *offset)
 134 {
 135         struct optee_rtc *priv = dev_get_drvdata(dev);
 136         struct tee_ioctl_invoke_arg inv_arg = {0};
 137         struct tee_param param[4] = {0};
 138         int ret;
 139
 140         if (!(priv->features & TA_RTC_FEATURE_CORRECTION))
 141                 return -EOPNOTSUPP;
 142
 143         inv_arg.func = TA_CMD_RTC_GET_OFFSET;
 144         inv_arg.session = priv->session_id;
 145         inv_arg.num_params = 4;
 146
 147         param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT;
 148
 149         ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
 150         if (ret < 0 || inv_arg.ret != 0)
 151                 return ret ? ret : -EPROTO;
 152
 153         *offset = param[0].u.value.a;
 154
 155         return 0;
 156 }
 157
 158 static int optee_rtc_setoffset(struct device *dev, long offset)
 159 {
 160         struct optee_rtc *priv = dev_get_drvdata(dev);
 161         struct tee_ioctl_invoke_arg inv_arg = {0};
 162         struct tee_param param[4] = {0};
 163         int ret;
 164
 165         if (!(priv->features & TA_RTC_FEATURE_CORRECTION))
 166                 return -EOPNOTSUPP;
 167
 168         inv_arg.func = TA_CMD_RTC_SET_OFFSET;
 169         inv_arg.session = priv->session_id;
 170         inv_arg.num_params = 4;
 171
 172         param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT;
 173         param[0].u.value.a = offset;
 174
 175         ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
 176         if (ret < 0 || inv_arg.ret != 0)
 177                 return ret ? ret : -EPROTO;
 178
 179         return 0;
 180 }
 181
 182 static const struct rtc_class_ops optee_rtc_ops = {
 183         .read_time      = optee_rtc_readtime,
 184         .set_time       = optee_rtc_settime,
 185         .set_offset     = optee_rtc_setoffset,
 186         .read_offset    = optee_rtc_readoffset,
 187 };
 188
 189 static int optee_rtc_read_info(struct device *dev, struct rtc_device *rtc,
 190                                u64 *features)
 191 {
 192         struct optee_rtc *priv = dev_get_drvdata(dev);
 193         struct tee_ioctl_invoke_arg inv_arg = {0};
 194         struct tee_param param[4] = {0};
 195         struct optee_rtc_info *info;
 196         struct optee_rtc_time *tm;
 197         int ret;
 198
 199         inv_arg.func = TA_CMD_RTC_GET_INFO;
 200         inv_arg.session = priv->session_id;
 201         inv_arg.num_params = 4;
 202
 203         param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT;
 204         param[0].u.memref.shm = priv->shm;
 205         param[0].u.memref.size = sizeof(*info);
 206
 207         ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
 208         if (ret < 0 || inv_arg.ret != 0)
 209                 return ret ? ret : -EPROTO;
 210
 211         info = tee_shm_get_va(priv->shm, 0);
 212         if (IS_ERR(info))
 213                 return PTR_ERR(info);
 214
 215         if (param[0].u.memref.size != sizeof(*info))
 216                 return -EPROTO;
 217
 218         if (info->version != RTC_INFO_VERSION)
 219                 return -EPROTO;
 220
 221         *features = info->features;
 222
 223         tm = &info->range_min;
 224         rtc->range_min = mktime64(tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min,
 225                                   tm->tm_sec);
 226         tm = &info->range_max;
 227         rtc->range_max = mktime64(tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min,
 228                                   tm->tm_sec);
 229
 230         return 0;
 231 }
 232
 233 static int optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data)
 234 {
 235         if (ver->impl_id == TEE_IMPL_ID_OPTEE)
 236                 return 1;
 237         else
 238                 return 0;
 239 }
 240
 241 static int optee_rtc_probe(struct device *dev)
 242 {
 243         struct tee_client_device *rtc_device = to_tee_client_device(dev);
 244         struct tee_ioctl_open_session_arg sess_arg;
 245         struct optee_rtc *priv;
 246         struct rtc_device *rtc;
 247         struct tee_shm *shm;
 248         int ret, err;
 249
 250         memset(&sess_arg, 0, sizeof(sess_arg));
 251
 252         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 253         if (!priv)
 254                 return -ENOMEM;
 255
 256         rtc = devm_rtc_allocate_device(dev);
 257         if (IS_ERR(rtc))
 258                 return PTR_ERR(rtc);
 259
 260         /* Open context with TEE driver */
 261         priv->ctx = tee_client_open_context(NULL, optee_ctx_match, NULL, NULL);
 262         if (IS_ERR(priv->ctx))
 263                 return -ENODEV;
 264
 265         /* Open session with rtc Trusted App */
 266         export_uuid(sess_arg.uuid, &rtc_device->id.uuid);
 267         sess_arg.clnt_login = TEE_IOCTL_LOGIN_REE_KERNEL;
 268
 269         ret = tee_client_open_session(priv->ctx, &sess_arg, NULL);
 270         if (ret < 0 || sess_arg.ret != 0) {
 271                 dev_err(dev, "tee_client_open_session failed, err: %x\n", sess_arg.ret);
 272                 err = -EINVAL;
 273                 goto out_ctx;
 274         }
 275         priv->session_id = sess_arg.session;
 276
 277         shm = tee_shm_alloc_kernel_buf(priv->ctx, sizeof(struct optee_rtc_info));
 278         if (IS_ERR(shm)) {
 279                 dev_err(priv->dev, "tee_shm_alloc_kernel_buf failed\n");
 280                 err = PTR_ERR(shm);
 281                 goto out_sess;
 282         }
 283
 284         priv->shm = shm;
 285         priv->dev = dev;
 286         dev_set_drvdata(dev, priv);
 287
 288         rtc->ops = &optee_rtc_ops;
 289
 290         err = optee_rtc_read_info(dev, rtc, &priv->features);
 291         if (err) {
 292                 dev_err(dev, "Failed to get RTC features from OP-TEE\n");
 293                 goto out_shm;
 294         }
 295
 296         err = devm_rtc_register_device(rtc);
 297         if (err)
 298                 goto out_shm;
 299
 300         /*
 301          * We must clear this bit after registering because rtc_register_device
 302          * will set it if it sees that .set_offset is provided.
 303          */
 304         if (!(priv->features & TA_RTC_FEATURE_CORRECTION))
 305                 clear_bit(RTC_FEATURE_CORRECTION, rtc->features);
 306
 307         return 0;
 308
 309 out_shm:
 310         tee_shm_free(priv->shm);
 311 out_sess:
 312         tee_client_close_session(priv->ctx, priv->session_id);
 313 out_ctx:
 314         tee_client_close_context(priv->ctx);
 315
 316         return err;
 317 }
 318
 319 static int optee_rtc_remove(struct device *dev)
 320 {
 321         struct optee_rtc *priv = dev_get_drvdata(dev);
 322
 323         tee_client_close_session(priv->ctx, priv->session_id);
 324         tee_client_close_context(priv->ctx);
 325
 326         return 0;
 327 }
 328
 329 static const struct tee_client_device_id optee_rtc_id_table[] = {
 330         {UUID_INIT(0xf389f8c8, 0x845f, 0x496c,
 331                    0x8b, 0xbe, 0xd6, 0x4b, 0xd2, 0x4c, 0x92, 0xfd)},
 332         {}
 333 };
 334
 335 MODULE_DEVICE_TABLE(tee, optee_rtc_id_table);
 336
 337 static struct tee_client_driver optee_rtc_driver = {
 338         .id_table       = optee_rtc_id_table,
 339         .driver         = {
 340                 .name           = "optee_rtc",
 341                 .bus            = &tee_bus_type,
 342                 .probe          = optee_rtc_probe,
 343                 .remove         = optee_rtc_remove,
 344         },
 345 };
 346
 347 static int __init optee_rtc_mod_init(void)
 348 {
 349         return driver_register(&optee_rtc_driver.driver);
 350 }
 351
 352 static void __exit optee_rtc_mod_exit(void)
 353 {
 354         driver_unregister(&optee_rtc_driver.driver);
 355 }
 356
 357 module_init(optee_rtc_mod_init);
 358 module_exit(optee_rtc_mod_exit);
 359
 360 MODULE_LICENSE("GPL v2");
 361 MODULE_AUTHOR("Clément Léger <clement.leger@bootlin.com>");
 362 MODULE_DESCRIPTION("OP-TEE based RTC driver");