| 1 |
// SPDX-License-Identifier: GPL-2.0 |
| 2 |
|
| 3 |
/* Copyright (C) 2021-2024 Linaro Ltd. */ |
| 4 |
|
| 5 |
#include <linux/device.h> |
| 6 |
#include <linux/sysfs.h> |
| 7 |
#include <linux/types.h> |
| 8 |
|
| 9 |
#include "ipa.h" |
| 10 |
#include "ipa_sysfs.h" |
| 11 |
#include "ipa_version.h" |
| 12 |
|
| 13 |
static const char *ipa_version_string(struct ipa *ipa) |
| 14 |
{ |
| 15 |
switch (ipa->version) { |
| 16 |
case IPA_VERSION_3_0: |
| 17 |
return "3.0"; |
| 18 |
case IPA_VERSION_3_1: |
| 19 |
return "3.1"; |
| 20 |
case IPA_VERSION_3_5: |
| 21 |
return "3.5"; |
| 22 |
case IPA_VERSION_3_5_1: |
| 23 |
return "3.5.1"; |
| 24 |
case IPA_VERSION_4_0: |
| 25 |
return "4.0"; |
| 26 |
case IPA_VERSION_4_1: |
| 27 |
return "4.1"; |
| 28 |
case IPA_VERSION_4_2: |
| 29 |
return "4.2"; |
| 30 |
case IPA_VERSION_4_5: |
| 31 |
return "4.5"; |
| 32 |
case IPA_VERSION_4_7: |
| 33 |
return "4.7"; |
| 34 |
case IPA_VERSION_4_9: |
| 35 |
return "4.9"; |
| 36 |
case IPA_VERSION_4_11: |
| 37 |
return "4.11"; |
| 38 |
case IPA_VERSION_5_0: |
| 39 |
return "5.0"; |
| 40 |
case IPA_VERSION_5_1: |
| 41 |
return "5.1"; |
| 42 |
case IPA_VERSION_5_5: |
| 43 |
return "5.5"; |
| 44 |
default: |
| 45 |
return "0.0"; /* Should not happen */ |
| 46 |
} |
| 47 |
} |
| 48 |
|
| 49 |
static ssize_t |
| 50 |
version_show(struct device *dev, struct device_attribute *attr, char *buf) |
| 51 |
{ |
| 52 |
struct ipa *ipa = dev_get_drvdata(dev); |
| 53 |
|
| 54 |
return sysfs_emit(buf, "%s\n", ipa_version_string(ipa)); |
| 55 |
} |
| 56 |
|
| 57 |
static DEVICE_ATTR_RO(version); |
| 58 |
|
| 59 |
static struct attribute *ipa_attrs[] = { |
| 60 |
&dev_attr_version.attr, |
| 61 |
NULL |
| 62 |
}; |
| 63 |
|
| 64 |
const struct attribute_group ipa_attribute_group = { |
| 65 |
.attrs = ipa_attrs, |
| 66 |
}; |
| 67 |
|
| 68 |
static const char *ipa_offload_string(struct ipa *ipa) |
| 69 |
{ |
| 70 |
return ipa->version < IPA_VERSION_4_5 ? "MAPv4" : "MAPv5"; |
| 71 |
} |
| 72 |
|
| 73 |
static ssize_t rx_offload_show(struct device *dev, |
| 74 |
struct device_attribute *attr, char *buf) |
| 75 |
{ |
| 76 |
struct ipa *ipa = dev_get_drvdata(dev); |
| 77 |
|
| 78 |
return sysfs_emit(buf, "%s\n", ipa_offload_string(ipa)); |
| 79 |
} |
| 80 |
|
| 81 |
static DEVICE_ATTR_RO(rx_offload); |
| 82 |
|
| 83 |
static ssize_t tx_offload_show(struct device *dev, |
| 84 |
struct device_attribute *attr, char *buf) |
| 85 |
{ |
| 86 |
struct ipa *ipa = dev_get_drvdata(dev); |
| 87 |
|
| 88 |
return sysfs_emit(buf, "%s\n", ipa_offload_string(ipa)); |
| 89 |
} |
| 90 |
|
| 91 |
static DEVICE_ATTR_RO(tx_offload); |
| 92 |
|
| 93 |
static struct attribute *ipa_feature_attrs[] = { |
| 94 |
&dev_attr_rx_offload.attr, |
| 95 |
&dev_attr_tx_offload.attr, |
| 96 |
NULL |
| 97 |
}; |
| 98 |
|
| 99 |
const struct attribute_group ipa_feature_attribute_group = { |
| 100 |
.name = "feature", |
| 101 |
.attrs = ipa_feature_attrs, |
| 102 |
}; |
| 103 |
|
| 104 |
static umode_t ipa_endpoint_id_is_visible(struct kobject *kobj, |
| 105 |
struct attribute *attr, int n) |
| 106 |
{ |
| 107 |
struct ipa *ipa = dev_get_drvdata(kobj_to_dev(kobj)); |
| 108 |
struct device_attribute *dev_attr; |
| 109 |
struct dev_ext_attribute *ea; |
| 110 |
bool visible; |
| 111 |
|
| 112 |
/* An endpoint id attribute is only visible if it's defined */ |
| 113 |
dev_attr = container_of(attr, struct device_attribute, attr); |
| 114 |
ea = container_of(dev_attr, struct dev_ext_attribute, attr); |
| 115 |
|
| 116 |
visible = !!ipa->name_map[(enum ipa_endpoint_name)(uintptr_t)ea->var]; |
| 117 |
|
| 118 |
return visible ? attr->mode : 0; |
| 119 |
} |
| 120 |
|
| 121 |
static ssize_t endpoint_id_attr_show(struct device *dev, |
| 122 |
struct device_attribute *attr, char *buf) |
| 123 |
{ |
| 124 |
struct ipa *ipa = dev_get_drvdata(dev); |
| 125 |
struct ipa_endpoint *endpoint; |
| 126 |
struct dev_ext_attribute *ea; |
| 127 |
|
| 128 |
ea = container_of(attr, struct dev_ext_attribute, attr); |
| 129 |
endpoint = ipa->name_map[(enum ipa_endpoint_name)(uintptr_t)ea->var]; |
| 130 |
|
| 131 |
return sysfs_emit(buf, "%u\n", endpoint->endpoint_id); |
| 132 |
} |
| 133 |
|
| 134 |
#define ENDPOINT_ID_ATTR(_n, _endpoint_name) \ |
| 135 |
static struct dev_ext_attribute dev_attr_endpoint_id_ ## _n = { \ |
| 136 |
.attr = __ATTR(_n, 0444, endpoint_id_attr_show, NULL), \ |
| 137 |
.var = (void *)(_endpoint_name), \ |
| 138 |
} |
| 139 |
|
| 140 |
ENDPOINT_ID_ATTR(modem_rx, IPA_ENDPOINT_AP_MODEM_RX); |
| 141 |
ENDPOINT_ID_ATTR(modem_tx, IPA_ENDPOINT_AP_MODEM_TX); |
| 142 |
|
| 143 |
static struct attribute *ipa_endpoint_id_attrs[] = { |
| 144 |
&dev_attr_endpoint_id_modem_rx.attr.attr, |
| 145 |
&dev_attr_endpoint_id_modem_tx.attr.attr, |
| 146 |
NULL |
| 147 |
}; |
| 148 |
|
| 149 |
const struct attribute_group ipa_endpoint_id_attribute_group = { |
| 150 |
.name = "endpoint_id", |
| 151 |
.is_visible = ipa_endpoint_id_is_visible, |
| 152 |
.attrs = ipa_endpoint_id_attrs, |
| 153 |
}; |
| 154 |
|
| 155 |
/* Reuse endpoint ID attributes for the legacy modem endpoint IDs */ |
| 156 |
#define MODEM_ATTR(_n, _endpoint_name) \ |
| 157 |
static struct dev_ext_attribute dev_attr_modem_ ## _n = { \ |
| 158 |
.attr = __ATTR(_n, 0444, endpoint_id_attr_show, NULL), \ |
| 159 |
.var = (void *)(_endpoint_name), \ |
| 160 |
} |
| 161 |
|
| 162 |
MODEM_ATTR(rx_endpoint_id, IPA_ENDPOINT_AP_MODEM_RX); |
| 163 |
MODEM_ATTR(tx_endpoint_id, IPA_ENDPOINT_AP_MODEM_TX); |
| 164 |
|
| 165 |
static struct attribute *ipa_modem_attrs[] = { |
| 166 |
&dev_attr_modem_rx_endpoint_id.attr.attr, |
| 167 |
&dev_attr_modem_tx_endpoint_id.attr.attr, |
| 168 |
NULL, |
| 169 |
}; |
| 170 |
|
| 171 |
const struct attribute_group ipa_modem_attribute_group = { |
| 172 |
.name = "modem", |
| 173 |
.attrs = ipa_modem_attrs, |
| 174 |
}; |