Merge tag 'trace-v6.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[platform/kernel/linux-starfive.git] / drivers / mailbox / mailbox-test.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2015 ST Microelectronics
4  *
5  * Author: Lee Jones <lee.jones@linaro.org>
6  */
7
8 #include <linux/debugfs.h>
9 #include <linux/err.h>
10 #include <linux/fs.h>
11 #include <linux/io.h>
12 #include <linux/kernel.h>
13 #include <linux/mailbox_client.h>
14 #include <linux/module.h>
15 #include <linux/mutex.h>
16 #include <linux/of.h>
17 #include <linux/platform_device.h>
18 #include <linux/poll.h>
19 #include <linux/slab.h>
20 #include <linux/spinlock.h>
21 #include <linux/uaccess.h>
22 #include <linux/sched/signal.h>
23
24 #define MBOX_MAX_SIG_LEN        8
25 #define MBOX_MAX_MSG_LEN        128
26 #define MBOX_BYTES_PER_LINE     16
27 #define MBOX_HEXDUMP_LINE_LEN   ((MBOX_BYTES_PER_LINE * 4) + 2)
28 #define MBOX_HEXDUMP_MAX_LEN    (MBOX_HEXDUMP_LINE_LEN *                \
29                                  (MBOX_MAX_MSG_LEN / MBOX_BYTES_PER_LINE))
30
31 static bool mbox_data_ready;
32
33 struct mbox_test_device {
34         struct device           *dev;
35         void __iomem            *tx_mmio;
36         void __iomem            *rx_mmio;
37         struct mbox_chan        *tx_channel;
38         struct mbox_chan        *rx_channel;
39         char                    *rx_buffer;
40         char                    *signal;
41         char                    *message;
42         spinlock_t              lock;
43         struct mutex            mutex;
44         wait_queue_head_t       waitq;
45         struct fasync_struct    *async_queue;
46         struct dentry           *root_debugfs_dir;
47 };
48
49 static ssize_t mbox_test_signal_write(struct file *filp,
50                                        const char __user *userbuf,
51                                        size_t count, loff_t *ppos)
52 {
53         struct mbox_test_device *tdev = filp->private_data;
54
55         if (!tdev->tx_channel) {
56                 dev_err(tdev->dev, "Channel cannot do Tx\n");
57                 return -EINVAL;
58         }
59
60         if (count > MBOX_MAX_SIG_LEN) {
61                 dev_err(tdev->dev,
62                         "Signal length %zd greater than max allowed %d\n",
63                         count, MBOX_MAX_SIG_LEN);
64                 return -EINVAL;
65         }
66
67         /* Only allocate memory if we need to */
68         if (!tdev->signal) {
69                 tdev->signal = kzalloc(MBOX_MAX_SIG_LEN, GFP_KERNEL);
70                 if (!tdev->signal)
71                         return -ENOMEM;
72         }
73
74         if (copy_from_user(tdev->signal, userbuf, count)) {
75                 kfree(tdev->signal);
76                 tdev->signal = NULL;
77                 return -EFAULT;
78         }
79
80         return count;
81 }
82
83 static const struct file_operations mbox_test_signal_ops = {
84         .write  = mbox_test_signal_write,
85         .open   = simple_open,
86         .llseek = generic_file_llseek,
87 };
88
89 static int mbox_test_message_fasync(int fd, struct file *filp, int on)
90 {
91         struct mbox_test_device *tdev = filp->private_data;
92
93         return fasync_helper(fd, filp, on, &tdev->async_queue);
94 }
95
96 static ssize_t mbox_test_message_write(struct file *filp,
97                                        const char __user *userbuf,
98                                        size_t count, loff_t *ppos)
99 {
100         struct mbox_test_device *tdev = filp->private_data;
101         char *message;
102         void *data;
103         int ret;
104
105         if (!tdev->tx_channel) {
106                 dev_err(tdev->dev, "Channel cannot do Tx\n");
107                 return -EINVAL;
108         }
109
110         if (count > MBOX_MAX_MSG_LEN) {
111                 dev_err(tdev->dev,
112                         "Message length %zd greater than max allowed %d\n",
113                         count, MBOX_MAX_MSG_LEN);
114                 return -EINVAL;
115         }
116
117         message = kzalloc(MBOX_MAX_MSG_LEN, GFP_KERNEL);
118         if (!message)
119                 return -ENOMEM;
120
121         mutex_lock(&tdev->mutex);
122
123         tdev->message = message;
124         ret = copy_from_user(tdev->message, userbuf, count);
125         if (ret) {
126                 ret = -EFAULT;
127                 goto out;
128         }
129
130         /*
131          * A separate signal is only of use if there is
132          * MMIO to subsequently pass the message through
133          */
134         if (tdev->tx_mmio && tdev->signal) {
135                 print_hex_dump_bytes("Client: Sending: Signal: ", DUMP_PREFIX_ADDRESS,
136                                      tdev->signal, MBOX_MAX_SIG_LEN);
137
138                 data = tdev->signal;
139         } else
140                 data = tdev->message;
141
142         print_hex_dump_bytes("Client: Sending: Message: ", DUMP_PREFIX_ADDRESS,
143                              tdev->message, MBOX_MAX_MSG_LEN);
144
145         ret = mbox_send_message(tdev->tx_channel, data);
146         if (ret < 0)
147                 dev_err(tdev->dev, "Failed to send message via mailbox\n");
148
149 out:
150         kfree(tdev->signal);
151         kfree(tdev->message);
152         tdev->signal = NULL;
153
154         mutex_unlock(&tdev->mutex);
155
156         return ret < 0 ? ret : count;
157 }
158
159 static bool mbox_test_message_data_ready(struct mbox_test_device *tdev)
160 {
161         bool data_ready;
162         unsigned long flags;
163
164         spin_lock_irqsave(&tdev->lock, flags);
165         data_ready = mbox_data_ready;
166         spin_unlock_irqrestore(&tdev->lock, flags);
167
168         return data_ready;
169 }
170
171 static ssize_t mbox_test_message_read(struct file *filp, char __user *userbuf,
172                                       size_t count, loff_t *ppos)
173 {
174         struct mbox_test_device *tdev = filp->private_data;
175         unsigned long flags;
176         char *touser, *ptr;
177         int l = 0;
178         int ret;
179
180         DECLARE_WAITQUEUE(wait, current);
181
182         touser = kzalloc(MBOX_HEXDUMP_MAX_LEN + 1, GFP_KERNEL);
183         if (!touser)
184                 return -ENOMEM;
185
186         if (!tdev->rx_channel) {
187                 ret = snprintf(touser, 20, "<NO RX CAPABILITY>\n");
188                 ret = simple_read_from_buffer(userbuf, count, ppos,
189                                               touser, ret);
190                 goto kfree_err;
191         }
192
193         add_wait_queue(&tdev->waitq, &wait);
194
195         do {
196                 __set_current_state(TASK_INTERRUPTIBLE);
197
198                 if (mbox_test_message_data_ready(tdev))
199                         break;
200
201                 if (filp->f_flags & O_NONBLOCK) {
202                         ret = -EAGAIN;
203                         goto waitq_err;
204                 }
205
206                 if (signal_pending(current)) {
207                         ret = -ERESTARTSYS;
208                         goto waitq_err;
209                 }
210                 schedule();
211
212         } while (1);
213
214         spin_lock_irqsave(&tdev->lock, flags);
215
216         ptr = tdev->rx_buffer;
217         while (l < MBOX_HEXDUMP_MAX_LEN) {
218                 hex_dump_to_buffer(ptr,
219                                    MBOX_BYTES_PER_LINE,
220                                    MBOX_BYTES_PER_LINE, 1, touser + l,
221                                    MBOX_HEXDUMP_LINE_LEN, true);
222
223                 ptr += MBOX_BYTES_PER_LINE;
224                 l += MBOX_HEXDUMP_LINE_LEN;
225                 *(touser + (l - 1)) = '\n';
226         }
227         *(touser + l) = '\0';
228
229         memset(tdev->rx_buffer, 0, MBOX_MAX_MSG_LEN);
230         mbox_data_ready = false;
231
232         spin_unlock_irqrestore(&tdev->lock, flags);
233
234         ret = simple_read_from_buffer(userbuf, count, ppos, touser, MBOX_HEXDUMP_MAX_LEN);
235 waitq_err:
236         __set_current_state(TASK_RUNNING);
237         remove_wait_queue(&tdev->waitq, &wait);
238 kfree_err:
239         kfree(touser);
240         return ret;
241 }
242
243 static __poll_t
244 mbox_test_message_poll(struct file *filp, struct poll_table_struct *wait)
245 {
246         struct mbox_test_device *tdev = filp->private_data;
247
248         poll_wait(filp, &tdev->waitq, wait);
249
250         if (mbox_test_message_data_ready(tdev))
251                 return EPOLLIN | EPOLLRDNORM;
252         return 0;
253 }
254
255 static const struct file_operations mbox_test_message_ops = {
256         .write  = mbox_test_message_write,
257         .read   = mbox_test_message_read,
258         .fasync = mbox_test_message_fasync,
259         .poll   = mbox_test_message_poll,
260         .open   = simple_open,
261         .llseek = generic_file_llseek,
262 };
263
264 static int mbox_test_add_debugfs(struct platform_device *pdev,
265                                  struct mbox_test_device *tdev)
266 {
267         if (!debugfs_initialized())
268                 return 0;
269
270         tdev->root_debugfs_dir = debugfs_create_dir(dev_name(&pdev->dev), NULL);
271         if (!tdev->root_debugfs_dir) {
272                 dev_err(&pdev->dev, "Failed to create Mailbox debugfs\n");
273                 return -EINVAL;
274         }
275
276         debugfs_create_file("message", 0600, tdev->root_debugfs_dir,
277                             tdev, &mbox_test_message_ops);
278
279         debugfs_create_file("signal", 0200, tdev->root_debugfs_dir,
280                             tdev, &mbox_test_signal_ops);
281
282         return 0;
283 }
284
285 static void mbox_test_receive_message(struct mbox_client *client, void *message)
286 {
287         struct mbox_test_device *tdev = dev_get_drvdata(client->dev);
288         unsigned long flags;
289
290         spin_lock_irqsave(&tdev->lock, flags);
291         if (tdev->rx_mmio) {
292                 memcpy_fromio(tdev->rx_buffer, tdev->rx_mmio, MBOX_MAX_MSG_LEN);
293                 print_hex_dump_bytes("Client: Received [MMIO]: ", DUMP_PREFIX_ADDRESS,
294                                      tdev->rx_buffer, MBOX_MAX_MSG_LEN);
295         } else if (message) {
296                 print_hex_dump_bytes("Client: Received [API]: ", DUMP_PREFIX_ADDRESS,
297                                      message, MBOX_MAX_MSG_LEN);
298                 memcpy(tdev->rx_buffer, message, MBOX_MAX_MSG_LEN);
299         }
300         mbox_data_ready = true;
301         spin_unlock_irqrestore(&tdev->lock, flags);
302
303         wake_up_interruptible(&tdev->waitq);
304
305         kill_fasync(&tdev->async_queue, SIGIO, POLL_IN);
306 }
307
308 static void mbox_test_prepare_message(struct mbox_client *client, void *message)
309 {
310         struct mbox_test_device *tdev = dev_get_drvdata(client->dev);
311
312         if (tdev->tx_mmio) {
313                 if (tdev->signal)
314                         memcpy_toio(tdev->tx_mmio, tdev->message, MBOX_MAX_MSG_LEN);
315                 else
316                         memcpy_toio(tdev->tx_mmio, message, MBOX_MAX_MSG_LEN);
317         }
318 }
319
320 static void mbox_test_message_sent(struct mbox_client *client,
321                                    void *message, int r)
322 {
323         if (r)
324                 dev_warn(client->dev,
325                          "Client: Message could not be sent: %d\n", r);
326         else
327                 dev_info(client->dev,
328                          "Client: Message sent\n");
329 }
330
331 static struct mbox_chan *
332 mbox_test_request_channel(struct platform_device *pdev, const char *name)
333 {
334         struct mbox_client *client;
335         struct mbox_chan *channel;
336
337         client = devm_kzalloc(&pdev->dev, sizeof(*client), GFP_KERNEL);
338         if (!client)
339                 return ERR_PTR(-ENOMEM);
340
341         client->dev             = &pdev->dev;
342         client->rx_callback     = mbox_test_receive_message;
343         client->tx_prepare      = mbox_test_prepare_message;
344         client->tx_done         = mbox_test_message_sent;
345         client->tx_block        = true;
346         client->knows_txdone    = false;
347         client->tx_tout         = 500;
348
349         channel = mbox_request_channel_byname(client, name);
350         if (IS_ERR(channel)) {
351                 dev_warn(&pdev->dev, "Failed to request %s channel\n", name);
352                 return NULL;
353         }
354
355         return channel;
356 }
357
358 static int mbox_test_probe(struct platform_device *pdev)
359 {
360         struct mbox_test_device *tdev;
361         struct resource *res;
362         resource_size_t size;
363         int ret;
364
365         tdev = devm_kzalloc(&pdev->dev, sizeof(*tdev), GFP_KERNEL);
366         if (!tdev)
367                 return -ENOMEM;
368
369         /* It's okay for MMIO to be NULL */
370         tdev->tx_mmio = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
371         if (PTR_ERR(tdev->tx_mmio) == -EBUSY) {
372                 /* if reserved area in SRAM, try just ioremap */
373                 size = resource_size(res);
374                 tdev->tx_mmio = devm_ioremap(&pdev->dev, res->start, size);
375         } else if (IS_ERR(tdev->tx_mmio)) {
376                 tdev->tx_mmio = NULL;
377         }
378
379         /* If specified, second reg entry is Rx MMIO */
380         tdev->rx_mmio = devm_platform_get_and_ioremap_resource(pdev, 1, &res);
381         if (PTR_ERR(tdev->rx_mmio) == -EBUSY) {
382                 size = resource_size(res);
383                 tdev->rx_mmio = devm_ioremap(&pdev->dev, res->start, size);
384         } else if (IS_ERR(tdev->rx_mmio)) {
385                 tdev->rx_mmio = tdev->tx_mmio;
386         }
387
388         tdev->tx_channel = mbox_test_request_channel(pdev, "tx");
389         tdev->rx_channel = mbox_test_request_channel(pdev, "rx");
390
391         if (IS_ERR_OR_NULL(tdev->tx_channel) && IS_ERR_OR_NULL(tdev->rx_channel))
392                 return -EPROBE_DEFER;
393
394         /* If Rx is not specified but has Rx MMIO, then Rx = Tx */
395         if (!tdev->rx_channel && (tdev->rx_mmio != tdev->tx_mmio))
396                 tdev->rx_channel = tdev->tx_channel;
397
398         tdev->dev = &pdev->dev;
399         platform_set_drvdata(pdev, tdev);
400
401         spin_lock_init(&tdev->lock);
402         mutex_init(&tdev->mutex);
403
404         if (tdev->rx_channel) {
405                 tdev->rx_buffer = devm_kzalloc(&pdev->dev,
406                                                MBOX_MAX_MSG_LEN, GFP_KERNEL);
407                 if (!tdev->rx_buffer)
408                         return -ENOMEM;
409         }
410
411         ret = mbox_test_add_debugfs(pdev, tdev);
412         if (ret)
413                 return ret;
414
415         init_waitqueue_head(&tdev->waitq);
416         dev_info(&pdev->dev, "Successfully registered\n");
417
418         return 0;
419 }
420
421 static int mbox_test_remove(struct platform_device *pdev)
422 {
423         struct mbox_test_device *tdev = platform_get_drvdata(pdev);
424
425         debugfs_remove_recursive(tdev->root_debugfs_dir);
426
427         if (tdev->tx_channel)
428                 mbox_free_channel(tdev->tx_channel);
429         if (tdev->rx_channel)
430                 mbox_free_channel(tdev->rx_channel);
431
432         return 0;
433 }
434
435 static const struct of_device_id mbox_test_match[] = {
436         { .compatible = "mailbox-test" },
437         {},
438 };
439 MODULE_DEVICE_TABLE(of, mbox_test_match);
440
441 static struct platform_driver mbox_test_driver = {
442         .driver = {
443                 .name = "mailbox_test",
444                 .of_match_table = mbox_test_match,
445         },
446         .probe  = mbox_test_probe,
447         .remove = mbox_test_remove,
448 };
449 module_platform_driver(mbox_test_driver);
450
451 MODULE_DESCRIPTION("Generic Mailbox Testing Facility");
452 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org");
453 MODULE_LICENSE("GPL v2");