1 /*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 2005 MIPS Technologies, Inc. All rights reserved.
7 * Copyright (C) 2005, 06 Ralf Baechle (ralf@linux-mips.org)
8 * Copyright (C) 2013 Imagination Technologies Ltd.
9 */
10 #include <linux/kernel.h>
11 #include <linux/fs.h>
12 #include <linux/syscalls.h>
13 #include <linux/moduleloader.h>
14 #include <linux/atomic.h>
15 #include <linux/sched/signal.h>
16
17 #include <asm/mipsmtregs.h>
18 #include <asm/mips_mt.h>
19 #include <asm/processor.h>
20 #include <asm/rtlx.h>
21 #include <asm/setup.h>
22 #include <asm/vpe.h>
23
24 static int sp_stopping;
25 struct rtlx_info *rtlx;
26 struct chan_waitqueues channel_wqs[RTLX_CHANNELS];
27 struct vpe_notifications rtlx_notify;
28 void (*aprp_hook)(void) = NULL;
29 EXPORT_SYMBOL(aprp_hook);
30
31 static void __used dump_rtlx(void)
32 {
33 int i;
34
35 pr_info("id 0x%lx state %d\n", rtlx->id, rtlx->state);
36
37 for (i = 0; i < RTLX_CHANNELS; i++) {
38 struct rtlx_channel *chan = &rtlx->channel[i];
39
40 pr_info(" rt_state %d lx_state %d buffer_size %d\n",
41 chan->rt_state, chan->lx_state, chan->buffer_size);
42
43 pr_info(" rt_read %d rt_write %d\n",
44 chan->rt_read, chan->rt_write);
45
46 pr_info(" lx_read %d lx_write %d\n",
47 chan->lx_read, chan->lx_write);
48
49 pr_info(" rt_buffer <%s>\n", chan->rt_buffer);
50 pr_info(" lx_buffer <%s>\n", chan->lx_buffer);
51 }
52 }
53
54 /* call when we have the address of the shared structure from the SP side. */
55 static int rtlx_init(struct rtlx_info *rtlxi)
56 {
57 if (rtlxi->id != RTLX_ID) {
58 pr_err("no valid RTLX id at 0x%p 0x%lx\n", rtlxi, rtlxi->id);
59 return -ENOEXEC;
60 }
61
62 rtlx = rtlxi;
63
64 return 0;
65 }
66
67 /* notifications */
68 void rtlx_starting(int vpe)
69 {
70 int i;
71 sp_stopping = 0;
72
73 /* force a reload of rtlx */
74 rtlx = NULL;
75
76 /* wake up any sleeping rtlx_open's */
77 for (i = 0; i < RTLX_CHANNELS; i++)
78 wake_up_interruptible(&channel_wqs[i].lx_queue);
79 }
80
81 void rtlx_stopping(int vpe)
82 {
83 int i;
84
85 sp_stopping = 1;
86 for (i = 0; i < RTLX_CHANNELS; i++)
87 wake_up_interruptible(&channel_wqs[i].lx_queue);
88 }
89
90
91 int rtlx_open(int index, int can_sleep)
92 {
93 struct rtlx_info **p;
94 struct rtlx_channel *chan;
95 enum rtlx_state state;
96 int ret = 0;
97
98 if (index >= RTLX_CHANNELS) {
99 pr_debug("rtlx_open index out of range\n");
100 return -ENOSYS;
101 }
102
103 if (atomic_inc_return(&channel_wqs[index].in_open) > 1) {
104 pr_debug("rtlx_open channel %d already opened\n", index);
105 ret = -EBUSY;
106 goto out_fail;
107 }
108
109 if (rtlx == NULL) {
110 p = vpe_get_shared(aprp_cpu_index());
111 if (p == NULL) {
112 if (can_sleep) {
113 ret = __wait_event_interruptible(
114 channel_wqs[index].lx_queue,
115 (p = vpe_get_shared(aprp_cpu_index())));
116 if (ret)
117 goto out_fail;
118 } else {
119 pr_debug("No SP program loaded, and device opened with O_NONBLOCK\n");
120 ret = -ENOSYS;
121 goto out_fail;
122 }
123 }
124
125 smp_rmb();
126 if (*p == NULL) {
127 if (can_sleep) {
128 DEFINE_WAIT(wait);
129
130 for (;;) {
131 prepare_to_wait(
132 &channel_wqs[index].lx_queue,
133 &wait, TASK_INTERRUPTIBLE);
134 smp_rmb();
135 if (*p != NULL)
136 break;
137 if (!signal_pending(current)) {
138 schedule();
139 continue;
140 }
141 ret = -ERESTARTSYS;
142 goto out_fail;
143 }
144 finish_wait(&channel_wqs[index].lx_queue,
145 &wait);
146 } else {
147 pr_err(" *vpe_get_shared is NULL. Has an SP program been loaded?\n");
148 ret = -ENOSYS;
149 goto out_fail;
150 }
151 }
152
153 if ((unsigned int)*p < KSEG0) {
154 pr_warn("vpe_get_shared returned an invalid pointer maybe an error code %d\n",
155 (int)*p);
156 ret = -ENOSYS;
157 goto out_fail;
158 }
159
160 ret = rtlx_init(*p);
161 if (ret < 0)
162 goto out_ret;
163 }
164
165 chan = &rtlx->channel[index];
166
167 state = xchg(&chan->lx_state, RTLX_STATE_OPENED);
168 if (state == RTLX_STATE_OPENED) {
169 ret = -EBUSY;
170 goto out_fail;
171 }
172
173 out_fail:
174 smp_mb();
175 atomic_dec(&channel_wqs[index].in_open);
176 smp_mb();
177
178 out_ret:
179 return ret;
180 }
181
182 int rtlx_release(int index)
183 {
184 if (rtlx == NULL) {
185 pr_err("rtlx_release() with null rtlx\n");
186 return 0;
187 }
188 rtlx->channel[index].lx_state = RTLX_STATE_UNUSED;
189 return 0;
190 }
191
192 unsigned int rtlx_read_poll(int index, int can_sleep)
193 {
194 struct rtlx_channel *chan;
195
196 if (rtlx == NULL)
197 return 0;
198
199 chan = &rtlx->channel[index];
200
201 /* data available to read? */
202 if (chan->lx_read == chan->lx_write) {
203 if (can_sleep) {
204 int ret = __wait_event_interruptible(
205 channel_wqs[index].lx_queue,
206 (chan->lx_read != chan->lx_write) ||
207 sp_stopping);
208 if (ret)
209 return ret;
210
211 if (sp_stopping)
212 return 0;
213 } else
214 return 0;
215 }
216
217 return (chan->lx_write + chan->buffer_size - chan->lx_read)
218 % chan->buffer_size;
219 }
220
221 static inline int write_spacefree(int read, int write, int size)
222 {
223 if (read == write) {
224 /*
225 * Never fill the buffer completely, so indexes are always
226 * equal if empty and only empty, or !equal if data available
227 */
228 return size - 1;
229 }
230
231 return ((read + size - write) % size) - 1;
232 }
233
234 unsigned int rtlx_write_poll(int index)
235 {
236 struct rtlx_channel *chan = &rtlx->channel[index];
237
238 return write_spacefree(chan->rt_read, chan->rt_write,
239 chan->buffer_size);
240 }
241
242 ssize_t rtlx_read(int index, void __user *buff, size_t count)
243 {
244 size_t lx_write, fl = 0L;
245 struct rtlx_channel *lx;
246 unsigned long failed;
247
248 if (rtlx == NULL)
249 return -ENOSYS;
250
251 lx = &rtlx->channel[index];
252
253 mutex_lock(&channel_wqs[index].mutex);
254 smp_rmb();
255 lx_write = lx->lx_write;
256
257 /* find out how much in total */
258 count = min(count,
259 (size_t)(lx_write + lx->buffer_size - lx->lx_read)
260 % lx->buffer_size);
261
262 /* then how much from the read pointer onwards */
263 fl = min(count, (size_t)lx->buffer_size - lx->lx_read);
264
265 failed = copy_to_user(buff, lx->lx_buffer + lx->lx_read, fl);
266 if (failed)
267 goto out;
268
269 /* and if there is anything left at the beginning of the buffer */
270 if (count - fl)
271 failed = copy_to_user(buff + fl, lx->lx_buffer, count - fl);
272
273 out:
274 count -= failed;
275
276 smp_wmb();
277 lx->lx_read = (lx->lx_read + count) % lx->buffer_size;
278 smp_wmb();
279 mutex_unlock(&channel_wqs[index].mutex);
280
281 return count;
282 }
283
284 ssize_t rtlx_write(int index, const void __user *buffer, size_t count)
285 {
286 struct rtlx_channel *rt;
287 unsigned long failed;
288 size_t rt_read;
289 size_t fl;
290
291 if (rtlx == NULL)
292 return -ENOSYS;
293
294 rt = &rtlx->channel[index];
295
296 mutex_lock(&channel_wqs[index].mutex);
297 smp_rmb();
298 rt_read = rt->rt_read;
299
300 /* total number of bytes to copy */
301 count = min_t(size_t, count, write_spacefree(rt_read, rt->rt_write,
302 rt->buffer_size));
303
304 /* first bit from write pointer to the end of the buffer, or count */
305 fl = min(count, (size_t) rt->buffer_size - rt->rt_write);
306
307 failed = copy_from_user(rt->rt_buffer + rt->rt_write, buffer, fl);
308 if (failed)
309 goto out;
310
311 /* if there's any left copy to the beginning of the buffer */
312 if (count - fl)
313 failed = copy_from_user(rt->rt_buffer, buffer + fl, count - fl);
314
315 out:
316 count -= failed;
317
318 smp_wmb();
319 rt->rt_write = (rt->rt_write + count) % rt->buffer_size;
320 smp_wmb();
321 mutex_unlock(&channel_wqs[index].mutex);
322
323 _interrupt_sp();
324
325 return count;
326 }
327
328
329 static int file_open(struct inode *inode, struct file *filp)
330 {
331 return rtlx_open(iminor(inode), (filp->f_flags & O_NONBLOCK) ? 0 : 1);
332 }
333
334 static int file_release(struct inode *inode, struct file *filp)
335 {
336 return rtlx_release(iminor(inode));
337 }
338
339 static __poll_t file_poll(struct file *file, poll_table *wait)
340 {
341 int minor = iminor(file_inode(file));
342 __poll_t mask = 0;
343
344 poll_wait(file, &channel_wqs[minor].rt_queue, wait);
345 poll_wait(file, &channel_wqs[minor].lx_queue, wait);
346
347 if (rtlx == NULL)
348 return 0;
349
350 /* data available to read? */
351 if (rtlx_read_poll(minor, 0))
352 mask |= EPOLLIN | EPOLLRDNORM;
353
354 /* space to write */
355 if (rtlx_write_poll(minor))
356 mask |= EPOLLOUT | EPOLLWRNORM;
357
358 return mask;
359 }
360
361 static ssize_t file_read(struct file *file, char __user *buffer, size_t count,
362 loff_t *ppos)
363 {
364 int minor = iminor(file_inode(file));
365
366 /* data available? */
367 if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1))
368 return 0; /* -EAGAIN makes 'cat' whine */
369
370 return rtlx_read(minor, buffer, count);
371 }
372
373 static ssize_t file_write(struct file *file, const char __user *buffer,
374 size_t count, loff_t *ppos)
375 {
376 int minor = iminor(file_inode(file));
377
378 /* any space left... */
379 if (!rtlx_write_poll(minor)) {
380 int ret;
381
382 if (file->f_flags & O_NONBLOCK)
383 return -EAGAIN;
384
385 ret = __wait_event_interruptible(channel_wqs[minor].rt_queue,
386 rtlx_write_poll(minor));
387 if (ret)
388 return ret;
389 }
390
391 return rtlx_write(minor, buffer, count);
392 }
393
394 const struct file_operations rtlx_fops = {
395 .owner = THIS_MODULE,
396 .open = file_open,
397 .release = file_release,
398 .write = file_write,
399 .read = file_read,
400 .poll = file_poll,
401 .llseek = noop_llseek,
402 };
403
404 module_init(rtlx_module_init);
405 module_exit(rtlx_module_exit);
406
407 MODULE_DESCRIPTION("MIPS RTLX");
408 MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
409 MODULE_LICENSE("GPL");
410
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.