Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) 2022 Microchip.
0004  */
0005 
0006 #include <linux/device.h>
0007 #include <linux/kernel.h>
0008 #include <linux/module.h>
0009 #include <linux/rtc.h>
0010 #include <linux/tee_drv.h>
0011 
0012 #define RTC_INFO_VERSION    0x1
0013 
0014 #define TA_CMD_RTC_GET_INFO     0x0
0015 #define TA_CMD_RTC_GET_TIME     0x1
0016 #define TA_CMD_RTC_SET_TIME     0x2
0017 #define TA_CMD_RTC_GET_OFFSET       0x3
0018 #define TA_CMD_RTC_SET_OFFSET       0x4
0019 
0020 #define TA_RTC_FEATURE_CORRECTION   BIT(0)
0021 
0022 struct optee_rtc_time {
0023     u32 tm_sec;
0024     u32 tm_min;
0025     u32 tm_hour;
0026     u32 tm_mday;
0027     u32 tm_mon;
0028     u32 tm_year;
0029     u32 tm_wday;
0030 };
0031 
0032 struct optee_rtc_info {
0033     u64 version;
0034     u64 features;
0035     struct optee_rtc_time range_min;
0036     struct optee_rtc_time range_max;
0037 };
0038 
0039 /**
0040  * struct optee_rtc - OP-TEE RTC private data
0041  * @dev:        OP-TEE based RTC device.
0042  * @ctx:        OP-TEE context handler.
0043  * @session_id:     RTC TA session identifier.
0044  * @shm:        Memory pool shared with RTC device.
0045  * @features:       Bitfield of RTC features
0046  */
0047 struct optee_rtc {
0048     struct device *dev;
0049     struct tee_context *ctx;
0050     u32 session_id;
0051     struct tee_shm *shm;
0052     u64 features;
0053 };
0054 
0055 static int optee_rtc_readtime(struct device *dev, struct rtc_time *tm)
0056 {
0057     struct optee_rtc *priv = dev_get_drvdata(dev);
0058     struct tee_ioctl_invoke_arg inv_arg = {0};
0059     struct optee_rtc_time *optee_tm;
0060     struct tee_param param[4] = {0};
0061     int ret;
0062 
0063     inv_arg.func = TA_CMD_RTC_GET_TIME;
0064     inv_arg.session = priv->session_id;
0065     inv_arg.num_params = 4;
0066 
0067     /* Fill invoke cmd params */
0068     param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT;
0069     param[0].u.memref.shm = priv->shm;
0070     param[0].u.memref.size = sizeof(struct optee_rtc_time);
0071 
0072     ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
0073     if (ret < 0 || inv_arg.ret != 0)
0074         return ret ? ret : -EPROTO;
0075 
0076     optee_tm = tee_shm_get_va(priv->shm, 0);
0077     if (IS_ERR(optee_tm))
0078         return PTR_ERR(optee_tm);
0079 
0080     if (param[0].u.memref.size != sizeof(*optee_tm))
0081         return -EPROTO;
0082 
0083     tm->tm_sec = optee_tm->tm_sec;
0084     tm->tm_min = optee_tm->tm_min;
0085     tm->tm_hour = optee_tm->tm_hour;
0086     tm->tm_mday = optee_tm->tm_mday;
0087     tm->tm_mon = optee_tm->tm_mon;
0088     tm->tm_year = optee_tm->tm_year - 1900;
0089     tm->tm_wday = optee_tm->tm_wday;
0090     tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
0091 
0092     return 0;
0093 }
0094 
0095 static int optee_rtc_settime(struct device *dev, struct rtc_time *tm)
0096 {
0097     struct optee_rtc *priv = dev_get_drvdata(dev);
0098     struct tee_ioctl_invoke_arg inv_arg = {0};
0099     struct tee_param param[4] = {0};
0100     struct optee_rtc_time optee_tm;
0101     void *rtc_data;
0102     int ret;
0103 
0104     optee_tm.tm_sec = tm->tm_sec;
0105     optee_tm.tm_min = tm->tm_min;
0106     optee_tm.tm_hour = tm->tm_hour;
0107     optee_tm.tm_mday = tm->tm_mday;
0108     optee_tm.tm_mon = tm->tm_mon;
0109     optee_tm.tm_year = tm->tm_year + 1900;
0110     optee_tm.tm_wday = tm->tm_wday;
0111 
0112     inv_arg.func = TA_CMD_RTC_SET_TIME;
0113     inv_arg.session = priv->session_id;
0114     inv_arg.num_params = 4;
0115 
0116     param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
0117     param[0].u.memref.shm = priv->shm;
0118     param[0].u.memref.size = sizeof(struct optee_rtc_time);
0119 
0120     rtc_data = tee_shm_get_va(priv->shm, 0);
0121     if (IS_ERR(rtc_data))
0122         return PTR_ERR(rtc_data);
0123 
0124     memcpy(rtc_data, &optee_tm, sizeof(struct optee_rtc_time));
0125 
0126     ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
0127     if (ret < 0 || inv_arg.ret != 0)
0128         return ret ? ret : -EPROTO;
0129 
0130     return 0;
0131 }
0132 
0133 static int optee_rtc_readoffset(struct device *dev, long *offset)
0134 {
0135     struct optee_rtc *priv = dev_get_drvdata(dev);
0136     struct tee_ioctl_invoke_arg inv_arg = {0};
0137     struct tee_param param[4] = {0};
0138     int ret;
0139 
0140     if (!(priv->features & TA_RTC_FEATURE_CORRECTION))
0141         return -EOPNOTSUPP;
0142 
0143     inv_arg.func = TA_CMD_RTC_GET_OFFSET;
0144     inv_arg.session = priv->session_id;
0145     inv_arg.num_params = 4;
0146 
0147     param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT;
0148 
0149     ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
0150     if (ret < 0 || inv_arg.ret != 0)
0151         return ret ? ret : -EPROTO;
0152 
0153     *offset = param[0].u.value.a;
0154 
0155     return 0;
0156 }
0157 
0158 static int optee_rtc_setoffset(struct device *dev, long offset)
0159 {
0160     struct optee_rtc *priv = dev_get_drvdata(dev);
0161     struct tee_ioctl_invoke_arg inv_arg = {0};
0162     struct tee_param param[4] = {0};
0163     int ret;
0164 
0165     if (!(priv->features & TA_RTC_FEATURE_CORRECTION))
0166         return -EOPNOTSUPP;
0167 
0168     inv_arg.func = TA_CMD_RTC_SET_OFFSET;
0169     inv_arg.session = priv->session_id;
0170     inv_arg.num_params = 4;
0171 
0172     param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT;
0173     param[0].u.value.a = offset;
0174 
0175     ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
0176     if (ret < 0 || inv_arg.ret != 0)
0177         return ret ? ret : -EPROTO;
0178 
0179     return 0;
0180 }
0181 
0182 static const struct rtc_class_ops optee_rtc_ops = {
0183     .read_time  = optee_rtc_readtime,
0184     .set_time   = optee_rtc_settime,
0185     .set_offset = optee_rtc_setoffset,
0186     .read_offset    = optee_rtc_readoffset,
0187 };
0188 
0189 static int optee_rtc_read_info(struct device *dev, struct rtc_device *rtc,
0190                    u64 *features)
0191 {
0192     struct optee_rtc *priv = dev_get_drvdata(dev);
0193     struct tee_ioctl_invoke_arg inv_arg = {0};
0194     struct tee_param param[4] = {0};
0195     struct optee_rtc_info *info;
0196     struct optee_rtc_time *tm;
0197     int ret;
0198 
0199     inv_arg.func = TA_CMD_RTC_GET_INFO;
0200     inv_arg.session = priv->session_id;
0201     inv_arg.num_params = 4;
0202 
0203     param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT;
0204     param[0].u.memref.shm = priv->shm;
0205     param[0].u.memref.size = sizeof(*info);
0206 
0207     ret = tee_client_invoke_func(priv->ctx, &inv_arg, param);
0208     if (ret < 0 || inv_arg.ret != 0)
0209         return ret ? ret : -EPROTO;
0210 
0211     info = tee_shm_get_va(priv->shm, 0);
0212     if (IS_ERR(info))
0213         return PTR_ERR(info);
0214 
0215     if (param[0].u.memref.size != sizeof(*info))
0216         return -EPROTO;
0217 
0218     if (info->version != RTC_INFO_VERSION)
0219         return -EPROTO;
0220 
0221     *features = info->features;
0222 
0223     tm = &info->range_min;
0224     rtc->range_min = mktime64(tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min,
0225                   tm->tm_sec);
0226     tm = &info->range_max;
0227     rtc->range_max = mktime64(tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min,
0228                   tm->tm_sec);
0229 
0230     return 0;
0231 }
0232 
0233 static int optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data)
0234 {
0235     if (ver->impl_id == TEE_IMPL_ID_OPTEE)
0236         return 1;
0237     else
0238         return 0;
0239 }
0240 
0241 static int optee_rtc_probe(struct device *dev)
0242 {
0243     struct tee_client_device *rtc_device = to_tee_client_device(dev);
0244     struct tee_ioctl_open_session_arg sess_arg;
0245     struct optee_rtc *priv;
0246     struct rtc_device *rtc;
0247     struct tee_shm *shm;
0248     int ret, err;
0249 
0250     memset(&sess_arg, 0, sizeof(sess_arg));
0251 
0252     priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
0253     if (!priv)
0254         return -ENOMEM;
0255 
0256     rtc = devm_rtc_allocate_device(dev);
0257     if (IS_ERR(rtc))
0258         return PTR_ERR(rtc);
0259 
0260     /* Open context with TEE driver */
0261     priv->ctx = tee_client_open_context(NULL, optee_ctx_match, NULL, NULL);
0262     if (IS_ERR(priv->ctx))
0263         return -ENODEV;
0264 
0265     /* Open session with rtc Trusted App */
0266     export_uuid(sess_arg.uuid, &rtc_device->id.uuid);
0267     sess_arg.clnt_login = TEE_IOCTL_LOGIN_REE_KERNEL;
0268 
0269     ret = tee_client_open_session(priv->ctx, &sess_arg, NULL);
0270     if (ret < 0 || sess_arg.ret != 0) {
0271         dev_err(dev, "tee_client_open_session failed, err: %x\n", sess_arg.ret);
0272         err = -EINVAL;
0273         goto out_ctx;
0274     }
0275     priv->session_id = sess_arg.session;
0276 
0277     shm = tee_shm_alloc_kernel_buf(priv->ctx, sizeof(struct optee_rtc_info));
0278     if (IS_ERR(shm)) {
0279         dev_err(priv->dev, "tee_shm_alloc_kernel_buf failed\n");
0280         err = PTR_ERR(shm);
0281         goto out_sess;
0282     }
0283 
0284     priv->shm = shm;
0285     priv->dev = dev;
0286     dev_set_drvdata(dev, priv);
0287 
0288     rtc->ops = &optee_rtc_ops;
0289 
0290     err = optee_rtc_read_info(dev, rtc, &priv->features);
0291     if (err) {
0292         dev_err(dev, "Failed to get RTC features from OP-TEE\n");
0293         goto out_shm;
0294     }
0295 
0296     err = devm_rtc_register_device(rtc);
0297     if (err)
0298         goto out_shm;
0299 
0300     /*
0301      * We must clear this bit after registering because rtc_register_device
0302      * will set it if it sees that .set_offset is provided.
0303      */
0304     if (!(priv->features & TA_RTC_FEATURE_CORRECTION))
0305         clear_bit(RTC_FEATURE_CORRECTION, rtc->features);
0306 
0307     return 0;
0308 
0309 out_shm:
0310     tee_shm_free(priv->shm);
0311 out_sess:
0312     tee_client_close_session(priv->ctx, priv->session_id);
0313 out_ctx:
0314     tee_client_close_context(priv->ctx);
0315 
0316     return err;
0317 }
0318 
0319 static int optee_rtc_remove(struct device *dev)
0320 {
0321     struct optee_rtc *priv = dev_get_drvdata(dev);
0322 
0323     tee_client_close_session(priv->ctx, priv->session_id);
0324     tee_client_close_context(priv->ctx);
0325 
0326     return 0;
0327 }
0328 
0329 static const struct tee_client_device_id optee_rtc_id_table[] = {
0330     {UUID_INIT(0xf389f8c8, 0x845f, 0x496c,
0331            0x8b, 0xbe, 0xd6, 0x4b, 0xd2, 0x4c, 0x92, 0xfd)},
0332     {}
0333 };
0334 
0335 MODULE_DEVICE_TABLE(tee, optee_rtc_id_table);
0336 
0337 static struct tee_client_driver optee_rtc_driver = {
0338     .id_table   = optee_rtc_id_table,
0339     .driver     = {
0340         .name       = "optee_rtc",
0341         .bus        = &tee_bus_type,
0342         .probe      = optee_rtc_probe,
0343         .remove     = optee_rtc_remove,
0344     },
0345 };
0346 
0347 static int __init optee_rtc_mod_init(void)
0348 {
0349     return driver_register(&optee_rtc_driver.driver);
0350 }
0351 
0352 static void __exit optee_rtc_mod_exit(void)
0353 {
0354     driver_unregister(&optee_rtc_driver.driver);
0355 }
0356 
0357 module_init(optee_rtc_mod_init);
0358 module_exit(optee_rtc_mod_exit);
0359 
0360 MODULE_LICENSE("GPL v2");
0361 MODULE_AUTHOR("Clément Léger <clement.leger@bootlin.com>");
0362 MODULE_DESCRIPTION("OP-TEE based RTC driver");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!