~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mips/kernel/rtlx.c

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp