drivers/ptp/ptp_sysfs.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * PTP 1588 clock support - sysfs interface.
0004  *
0005  * Copyright (C) 2010 OMICRON electronics GmbH
0006  * Copyright 2021 NXP
0007  */
0008 #include <linux/capability.h>
0009 #include <linux/slab.h>
0010
0011 #include "ptp_private.h"
0012
0013 static ssize_t clock_name_show(struct device *dev,
0014                    struct device_attribute *attr, char *page)
0015 {
0016     struct ptp_clock *ptp = dev_get_drvdata(dev);
0017     return sysfs_emit(page, "%s\n", ptp->info->name);
0018 }
0019 static DEVICE_ATTR_RO(clock_name);
0020
0021 #define PTP_SHOW_INT(name, var)                     \
0022 static ssize_t var##_show(struct device *dev,               \
0023                struct device_attribute *attr, char *page)   \
0024 {                                   \
0025     struct ptp_clock *ptp = dev_get_drvdata(dev);           \
0026     return snprintf(page, PAGE_SIZE-1, "%d\n", ptp->info->var); \
0027 }                                   \
0028 static DEVICE_ATTR(name, 0444, var##_show, NULL);
0029
0030 PTP_SHOW_INT(max_adjustment, max_adj);
0031 PTP_SHOW_INT(n_alarms, n_alarm);
0032 PTP_SHOW_INT(n_external_timestamps, n_ext_ts);
0033 PTP_SHOW_INT(n_periodic_outputs, n_per_out);
0034 PTP_SHOW_INT(n_programmable_pins, n_pins);
0035 PTP_SHOW_INT(pps_available, pps);
0036
0037 static ssize_t extts_enable_store(struct device *dev,
0038                   struct device_attribute *attr,
0039                   const char *buf, size_t count)
0040 {
0041     struct ptp_clock *ptp = dev_get_drvdata(dev);
0042     struct ptp_clock_info *ops = ptp->info;
0043     struct ptp_clock_request req = { .type = PTP_CLK_REQ_EXTTS };
0044     int cnt, enable;
0045     int err = -EINVAL;
0046
0047     cnt = sscanf(buf, "%u %d", &req.extts.index, &enable);
0048     if (cnt != 2)
0049         goto out;
0050     if (req.extts.index >= ops->n_ext_ts)
0051         goto out;
0052
0053     err = ops->enable(ops, &req, enable ? 1 : 0);
0054     if (err)
0055         goto out;
0056
0057     return count;
0058 out:
0059     return err;
0060 }
0061 static DEVICE_ATTR(extts_enable, 0220, NULL, extts_enable_store);
0062
0063 static ssize_t extts_fifo_show(struct device *dev,
0064                    struct device_attribute *attr, char *page)
0065 {
0066     struct ptp_clock *ptp = dev_get_drvdata(dev);
0067     struct timestamp_event_queue *queue = &ptp->tsevq;
0068     struct ptp_extts_event event;
0069     unsigned long flags;
0070     size_t qcnt;
0071     int cnt = 0;
0072
0073     memset(&event, 0, sizeof(event));
0074
0075     if (mutex_lock_interruptible(&ptp->tsevq_mux))
0076         return -ERESTARTSYS;
0077
0078     spin_lock_irqsave(&queue->lock, flags);
0079     qcnt = queue_cnt(queue);
0080     if (qcnt) {
0081         event = queue->buf[queue->head];
0082         queue->head = (queue->head + 1) % PTP_MAX_TIMESTAMPS;
0083     }
0084     spin_unlock_irqrestore(&queue->lock, flags);
0085
0086     if (!qcnt)
0087         goto out;
0088
0089     cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n",
0090                event.index, event.t.sec, event.t.nsec);
0091 out:
0092     mutex_unlock(&ptp->tsevq_mux);
0093     return cnt;
0094 }
0095 static DEVICE_ATTR(fifo, 0444, extts_fifo_show, NULL);
0096
0097 static ssize_t period_store(struct device *dev,
0098                 struct device_attribute *attr,
0099                 const char *buf, size_t count)
0100 {
0101     struct ptp_clock *ptp = dev_get_drvdata(dev);
0102     struct ptp_clock_info *ops = ptp->info;
0103     struct ptp_clock_request req = { .type = PTP_CLK_REQ_PEROUT };
0104     int cnt, enable, err = -EINVAL;
0105
0106     cnt = sscanf(buf, "%u %lld %u %lld %u", &req.perout.index,
0107              &req.perout.start.sec, &req.perout.start.nsec,
0108              &req.perout.period.sec, &req.perout.period.nsec);
0109     if (cnt != 5)
0110         goto out;
0111     if (req.perout.index >= ops->n_per_out)
0112         goto out;
0113
0114     enable = req.perout.period.sec || req.perout.period.nsec;
0115     err = ops->enable(ops, &req, enable);
0116     if (err)
0117         goto out;
0118
0119     return count;
0120 out:
0121     return err;
0122 }
0123 static DEVICE_ATTR(period, 0220, NULL, period_store);
0124
0125 static ssize_t pps_enable_store(struct device *dev,
0126                 struct device_attribute *attr,
0127                 const char *buf, size_t count)
0128 {
0129     struct ptp_clock *ptp = dev_get_drvdata(dev);
0130     struct ptp_clock_info *ops = ptp->info;
0131     struct ptp_clock_request req = { .type = PTP_CLK_REQ_PPS };
0132     int cnt, enable;
0133     int err = -EINVAL;
0134
0135     if (!capable(CAP_SYS_TIME))
0136         return -EPERM;
0137
0138     cnt = sscanf(buf, "%d", &enable);
0139     if (cnt != 1)
0140         goto out;
0141
0142     err = ops->enable(ops, &req, enable ? 1 : 0);
0143     if (err)
0144         goto out;
0145
0146     return count;
0147 out:
0148     return err;
0149 }
0150 static DEVICE_ATTR(pps_enable, 0220, NULL, pps_enable_store);
0151
0152 static int unregister_vclock(struct device *dev, void *data)
0153 {
0154     struct ptp_clock *ptp = dev_get_drvdata(dev);
0155     struct ptp_clock_info *info = ptp->info;
0156     struct ptp_vclock *vclock;
0157     u32 *num = data;
0158
0159     vclock = info_to_vclock(info);
0160     dev_info(dev->parent, "delete virtual clock ptp%d\n",
0161          vclock->clock->index);
0162
0163     ptp_vclock_unregister(vclock);
0164     (*num)--;
0165
0166     /* For break. Not error. */
0167     if (*num == 0)
0168         return -EINVAL;
0169
0170     return 0;
0171 }
0172
0173 static ssize_t n_vclocks_show(struct device *dev,
0174                   struct device_attribute *attr, char *page)
0175 {
0176     struct ptp_clock *ptp = dev_get_drvdata(dev);
0177     ssize_t size;
0178
0179     if (mutex_lock_interruptible(&ptp->n_vclocks_mux))
0180         return -ERESTARTSYS;
0181
0182     size = snprintf(page, PAGE_SIZE - 1, "%u\n", ptp->n_vclocks);
0183
0184     mutex_unlock(&ptp->n_vclocks_mux);
0185
0186     return size;
0187 }
0188
0189 static ssize_t n_vclocks_store(struct device *dev,
0190                    struct device_attribute *attr,
0191                    const char *buf, size_t count)
0192 {
0193     struct ptp_clock *ptp = dev_get_drvdata(dev);
0194     struct ptp_vclock *vclock;
0195     int err = -EINVAL;
0196     u32 num, i;
0197
0198     if (kstrtou32(buf, 0, &num))
0199         return err;
0200
0201     if (mutex_lock_interruptible(&ptp->n_vclocks_mux))
0202         return -ERESTARTSYS;
0203
0204     if (num > ptp->max_vclocks) {
0205         dev_err(dev, "max value is %d\n", ptp->max_vclocks);
0206         goto out;
0207     }
0208
0209     /* Need to create more vclocks */
0210     if (num > ptp->n_vclocks) {
0211         for (i = 0; i < num - ptp->n_vclocks; i++) {
0212             vclock = ptp_vclock_register(ptp);
0213             if (!vclock)
0214                 goto out;
0215
0216             *(ptp->vclock_index + ptp->n_vclocks + i) =
0217                 vclock->clock->index;
0218
0219             dev_info(dev, "new virtual clock ptp%d\n",
0220                  vclock->clock->index);
0221         }
0222     }
0223
0224     /* Need to delete vclocks */
0225     if (num < ptp->n_vclocks) {
0226         i = ptp->n_vclocks - num;
0227         device_for_each_child_reverse(dev, &i,
0228                           unregister_vclock);
0229
0230         for (i = 1; i <= ptp->n_vclocks - num; i++)
0231             *(ptp->vclock_index + ptp->n_vclocks - i) = -1;
0232     }
0233
0234     /* Need to inform about changed physical clock behavior */
0235     if (!ptp->has_cycles) {
0236         if (num == 0)
0237             dev_info(dev, "only physical clock in use now\n");
0238         else
0239             dev_info(dev, "guarantee physical clock free running\n");
0240     }
0241
0242     ptp->n_vclocks = num;
0243     mutex_unlock(&ptp->n_vclocks_mux);
0244
0245     return count;
0246 out:
0247     mutex_unlock(&ptp->n_vclocks_mux);
0248     return err;
0249 }
0250 static DEVICE_ATTR_RW(n_vclocks);
0251
0252 static ssize_t max_vclocks_show(struct device *dev,
0253                 struct device_attribute *attr, char *page)
0254 {
0255     struct ptp_clock *ptp = dev_get_drvdata(dev);
0256     ssize_t size;
0257
0258     size = snprintf(page, PAGE_SIZE - 1, "%u\n", ptp->max_vclocks);
0259
0260     return size;
0261 }
0262
0263 static ssize_t max_vclocks_store(struct device *dev,
0264                  struct device_attribute *attr,
0265                  const char *buf, size_t count)
0266 {
0267     struct ptp_clock *ptp = dev_get_drvdata(dev);
0268     unsigned int *vclock_index;
0269     int err = -EINVAL;
0270     size_t size;
0271     u32 max;
0272
0273     if (kstrtou32(buf, 0, &max) || max == 0)
0274         return -EINVAL;
0275
0276     if (max == ptp->max_vclocks)
0277         return count;
0278
0279     if (mutex_lock_interruptible(&ptp->n_vclocks_mux))
0280         return -ERESTARTSYS;
0281
0282     if (max < ptp->n_vclocks)
0283         goto out;
0284
0285     size = sizeof(int) * max;
0286     vclock_index = kzalloc(size, GFP_KERNEL);
0287     if (!vclock_index) {
0288         err = -ENOMEM;
0289         goto out;
0290     }
0291
0292     size = sizeof(int) * ptp->n_vclocks;
0293     memcpy(vclock_index, ptp->vclock_index, size);
0294
0295     kfree(ptp->vclock_index);
0296     ptp->vclock_index = vclock_index;
0297     ptp->max_vclocks = max;
0298
0299     mutex_unlock(&ptp->n_vclocks_mux);
0300
0301     return count;
0302 out:
0303     mutex_unlock(&ptp->n_vclocks_mux);
0304     return err;
0305 }
0306 static DEVICE_ATTR_RW(max_vclocks);
0307
0308 static struct attribute *ptp_attrs[] = {
0309     &dev_attr_clock_name.attr,
0310
0311     &dev_attr_max_adjustment.attr,
0312     &dev_attr_n_alarms.attr,
0313     &dev_attr_n_external_timestamps.attr,
0314     &dev_attr_n_periodic_outputs.attr,
0315     &dev_attr_n_programmable_pins.attr,
0316     &dev_attr_pps_available.attr,
0317
0318     &dev_attr_extts_enable.attr,
0319     &dev_attr_fifo.attr,
0320     &dev_attr_period.attr,
0321     &dev_attr_pps_enable.attr,
0322     &dev_attr_n_vclocks.attr,
0323     &dev_attr_max_vclocks.attr,
0324     NULL
0325 };
0326
0327 static umode_t ptp_is_attribute_visible(struct kobject *kobj,
0328                     struct attribute *attr, int n)
0329 {
0330     struct device *dev = kobj_to_dev(kobj);
0331     struct ptp_clock *ptp = dev_get_drvdata(dev);
0332     struct ptp_clock_info *info = ptp->info;
0333     umode_t mode = attr->mode;
0334
0335     if (attr == &dev_attr_extts_enable.attr ||
0336         attr == &dev_attr_fifo.attr) {
0337         if (!info->n_ext_ts)
0338             mode = 0;
0339     } else if (attr == &dev_attr_period.attr) {
0340         if (!info->n_per_out)
0341             mode = 0;
0342     } else if (attr == &dev_attr_pps_enable.attr) {
0343         if (!info->pps)
0344             mode = 0;
0345     } else if (attr == &dev_attr_n_vclocks.attr ||
0346            attr == &dev_attr_max_vclocks.attr) {
0347         if (ptp->is_virtual_clock)
0348             mode = 0;
0349     }
0350
0351     return mode;
0352 }
0353
0354 static const struct attribute_group ptp_group = {
0355     .is_visible = ptp_is_attribute_visible,
0356     .attrs      = ptp_attrs,
0357 };
0358
0359 const struct attribute_group *ptp_groups[] = {
0360     &ptp_group,
0361     NULL
0362 };
0363
0364 static int ptp_pin_name2index(struct ptp_clock *ptp, const char *name)
0365 {
0366     int i;
0367     for (i = 0; i < ptp->info->n_pins; i++) {
0368         if (!strcmp(ptp->info->pin_config[i].name, name))
0369             return i;
0370     }
0371     return -1;
0372 }
0373
0374 static ssize_t ptp_pin_show(struct device *dev, struct device_attribute *attr,
0375                 char *page)
0376 {
0377     struct ptp_clock *ptp = dev_get_drvdata(dev);
0378     unsigned int func, chan;
0379     int index;
0380
0381     index = ptp_pin_name2index(ptp, attr->attr.name);
0382     if (index < 0)
0383         return -EINVAL;
0384
0385     if (mutex_lock_interruptible(&ptp->pincfg_mux))
0386         return -ERESTARTSYS;
0387
0388     func = ptp->info->pin_config[index].func;
0389     chan = ptp->info->pin_config[index].chan;
0390
0391     mutex_unlock(&ptp->pincfg_mux);
0392
0393     return sysfs_emit(page, "%u %u\n", func, chan);
0394 }
0395
0396 static ssize_t ptp_pin_store(struct device *dev, struct device_attribute *attr,
0397                  const char *buf, size_t count)
0398 {
0399     struct ptp_clock *ptp = dev_get_drvdata(dev);
0400     unsigned int func, chan;
0401     int cnt, err, index;
0402
0403     cnt = sscanf(buf, "%u %u", &func, &chan);
0404     if (cnt != 2)
0405         return -EINVAL;
0406
0407     index = ptp_pin_name2index(ptp, attr->attr.name);
0408     if (index < 0)
0409         return -EINVAL;
0410
0411     if (mutex_lock_interruptible(&ptp->pincfg_mux))
0412         return -ERESTARTSYS;
0413     err = ptp_set_pinfunc(ptp, index, func, chan);
0414     mutex_unlock(&ptp->pincfg_mux);
0415     if (err)
0416         return err;
0417
0418     return count;
0419 }
0420
0421 int ptp_populate_pin_groups(struct ptp_clock *ptp)
0422 {
0423     struct ptp_clock_info *info = ptp->info;
0424     int err = -ENOMEM, i, n_pins = info->n_pins;
0425
0426     if (!n_pins)
0427         return 0;
0428
0429     ptp->pin_dev_attr = kcalloc(n_pins, sizeof(*ptp->pin_dev_attr),
0430                     GFP_KERNEL);
0431     if (!ptp->pin_dev_attr)
0432         goto no_dev_attr;
0433
0434     ptp->pin_attr = kcalloc(1 + n_pins, sizeof(*ptp->pin_attr), GFP_KERNEL);
0435     if (!ptp->pin_attr)
0436         goto no_pin_attr;
0437
0438     for (i = 0; i < n_pins; i++) {
0439         struct device_attribute *da = &ptp->pin_dev_attr[i];
0440         sysfs_attr_init(&da->attr);
0441         da->attr.name = info->pin_config[i].name;
0442         da->attr.mode = 0644;
0443         da->show = ptp_pin_show;
0444         da->store = ptp_pin_store;
0445         ptp->pin_attr[i] = &da->attr;
0446     }
0447
0448     ptp->pin_attr_group.name = "pins";
0449     ptp->pin_attr_group.attrs = ptp->pin_attr;
0450
0451     ptp->pin_attr_groups[0] = &ptp->pin_attr_group;
0452
0453     return 0;
0454
0455 no_pin_attr:
0456     kfree(ptp->pin_dev_attr);
0457 no_dev_attr:
0458     return err;
0459 }
0460
0461 void ptp_cleanup_pin_groups(struct ptp_clock *ptp)
0462 {
0463     kfree(ptp->pin_attr);
0464     kfree(ptp->pin_dev_attr);
0465 }