blob: 98d062fd353edcf16ec88e2adecb553b183b41bf [file] [log] [blame]
Christopher Bostic680ca6d2017-06-06 16:08:56 -05001/*
2 * SCOM FSI Client device driver
3 *
4 * Copyright (C) IBM Corporation 2016
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERGCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15
16#include <linux/fsi.h>
17#include <linux/module.h>
18#include <linux/cdev.h>
19#include <linux/delay.h>
20#include <linux/fs.h>
21#include <linux/uaccess.h>
22#include <linux/slab.h>
23#include <linux/miscdevice.h>
24#include <linux/list.h>
25#include <linux/idr.h>
26
27#define FSI_ENGID_SCOM 0x5
28
29#define SCOM_FSI2PIB_DELAY 50
30
31/* SCOM engine register set */
32#define SCOM_DATA0_REG 0x00
33#define SCOM_DATA1_REG 0x04
34#define SCOM_CMD_REG 0x08
35#define SCOM_RESET_REG 0x1C
36
37#define SCOM_RESET_CMD 0x80000000
38#define SCOM_WRITE_CMD 0x80000000
39
40struct scom_device {
41 struct list_head link;
42 struct fsi_device *fsi_dev;
43 struct miscdevice mdev;
44 char name[32];
45 int idx;
46};
47
48#define to_scom_dev(x) container_of((x), struct scom_device, mdev)
49
50static struct list_head scom_devices;
51
52static DEFINE_IDA(scom_ida);
53
54static int put_scom(struct scom_device *scom_dev, uint64_t value,
55 uint32_t addr)
56{
57 int rc;
58 uint32_t data;
59
60 data = cpu_to_be32(SCOM_RESET_CMD);
61 rc = fsi_device_write(scom_dev->fsi_dev, SCOM_RESET_REG, &data,
62 sizeof(uint32_t));
63 if (rc)
64 return rc;
65
66 data = cpu_to_be32((value >> 32) & 0xffffffff);
67 rc = fsi_device_write(scom_dev->fsi_dev, SCOM_DATA0_REG, &data,
68 sizeof(uint32_t));
69 if (rc)
70 return rc;
71
72 data = cpu_to_be32(value & 0xffffffff);
73 rc = fsi_device_write(scom_dev->fsi_dev, SCOM_DATA1_REG, &data,
74 sizeof(uint32_t));
75 if (rc)
76 return rc;
77
78 data = cpu_to_be32(SCOM_WRITE_CMD | addr);
79 return fsi_device_write(scom_dev->fsi_dev, SCOM_CMD_REG, &data,
80 sizeof(uint32_t));
81}
82
83static int get_scom(struct scom_device *scom_dev, uint64_t *value,
84 uint32_t addr)
85{
86 uint32_t result, data;
87 int rc;
88
89 *value = 0ULL;
90 data = cpu_to_be32(addr);
91 rc = fsi_device_write(scom_dev->fsi_dev, SCOM_CMD_REG, &data,
92 sizeof(uint32_t));
93 if (rc)
94 return rc;
95
96 rc = fsi_device_read(scom_dev->fsi_dev, SCOM_DATA0_REG, &result,
97 sizeof(uint32_t));
98 if (rc)
99 return rc;
100
101 *value |= (uint64_t)cpu_to_be32(result) << 32;
102 rc = fsi_device_read(scom_dev->fsi_dev, SCOM_DATA1_REG, &result,
103 sizeof(uint32_t));
104 if (rc)
105 return rc;
106
107 *value |= cpu_to_be32(result);
108
109 return 0;
110}
111
112static ssize_t scom_read(struct file *filep, char __user *buf, size_t len,
113 loff_t *offset)
114{
115 int rc;
116 struct miscdevice *mdev =
117 (struct miscdevice *)filep->private_data;
118 struct scom_device *scom = to_scom_dev(mdev);
119 struct device *dev = &scom->fsi_dev->dev;
120 uint64_t val;
121
122 if (len != sizeof(uint64_t))
123 return -EINVAL;
124
125 rc = get_scom(scom, &val, *offset);
126 if (rc) {
127 dev_dbg(dev, "get_scom fail:%d\n", rc);
128 return rc;
129 }
130
131 rc = copy_to_user(buf, &val, len);
132 if (rc)
133 dev_dbg(dev, "copy to user failed:%d\n", rc);
134
135 return rc ? rc : len;
136}
137
138static ssize_t scom_write(struct file *filep, const char __user *buf,
139 size_t len, loff_t *offset)
140{
141 int rc;
142 struct miscdevice *mdev = filep->private_data;
143 struct scom_device *scom = to_scom_dev(mdev);
144 struct device *dev = &scom->fsi_dev->dev;
145 uint64_t val;
146
147 if (len != sizeof(uint64_t))
148 return -EINVAL;
149
150 rc = copy_from_user(&val, buf, len);
151 if (rc) {
152 dev_dbg(dev, "copy from user failed:%d\n", rc);
153 return -EINVAL;
154 }
155
156 rc = put_scom(scom, val, *offset);
157 if (rc) {
158 dev_dbg(dev, "put_scom failed with:%d\n", rc);
159 return rc;
160 }
161
162 return len;
163}
164
165static loff_t scom_llseek(struct file *file, loff_t offset, int whence)
166{
167 switch (whence) {
168 case SEEK_CUR:
169 break;
170 case SEEK_SET:
171 file->f_pos = offset;
172 break;
173 default:
174 return -EINVAL;
175 }
176
177 return offset;
178}
179
180static const struct file_operations scom_fops = {
181 .owner = THIS_MODULE,
182 .llseek = scom_llseek,
183 .read = scom_read,
184 .write = scom_write,
185};
186
187static int scom_probe(struct device *dev)
188{
189 struct fsi_device *fsi_dev = to_fsi_dev(dev);
190 struct scom_device *scom;
191
192 scom = devm_kzalloc(dev, sizeof(*scom), GFP_KERNEL);
193 if (!scom)
194 return -ENOMEM;
195
196 scom->idx = ida_simple_get(&scom_ida, 1, INT_MAX, GFP_KERNEL);
197 snprintf(scom->name, sizeof(scom->name), "scom%d", scom->idx);
198 scom->fsi_dev = fsi_dev;
199 scom->mdev.minor = MISC_DYNAMIC_MINOR;
200 scom->mdev.fops = &scom_fops;
201 scom->mdev.name = scom->name;
202 scom->mdev.parent = dev;
203 list_add(&scom->link, &scom_devices);
204
205 return misc_register(&scom->mdev);
206}
207
208static int scom_remove(struct device *dev)
209{
210 struct scom_device *scom, *scom_tmp;
211 struct fsi_device *fsi_dev = to_fsi_dev(dev);
212
213 list_for_each_entry_safe(scom, scom_tmp, &scom_devices, link) {
214 if (scom->fsi_dev == fsi_dev) {
215 list_del(&scom->link);
216 ida_simple_remove(&scom_ida, scom->idx);
217 misc_deregister(&scom->mdev);
218 }
219 }
220
221 return 0;
222}
223
224static struct fsi_device_id scom_ids[] = {
225 {
226 .engine_type = FSI_ENGID_SCOM,
227 .version = FSI_VERSION_ANY,
228 },
229 { 0 }
230};
231
232static struct fsi_driver scom_drv = {
233 .id_table = scom_ids,
234 .drv = {
235 .name = "scom",
236 .bus = &fsi_bus_type,
237 .probe = scom_probe,
238 .remove = scom_remove,
239 }
240};
241
242static int scom_init(void)
243{
244 INIT_LIST_HEAD(&scom_devices);
245 return fsi_driver_register(&scom_drv);
246}
247
248static void scom_exit(void)
249{
250 struct list_head *pos;
251 struct scom_device *scom;
252
253 list_for_each(pos, &scom_devices) {
254 scom = list_entry(pos, struct scom_device, link);
255 misc_deregister(&scom->mdev);
256 devm_kfree(&scom->fsi_dev->dev, scom);
257 }
258 fsi_driver_unregister(&scom_drv);
259}
260
261module_init(scom_init);
262module_exit(scom_exit);
263MODULE_LICENSE("GPL");