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