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

TOMOYO Linux Cross Reference
Linux/arch/cris/arch-v32/drivers/i2c.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 *!
  3 *! FILE NAME  : i2c.c
  4 *!
  5 *! DESCRIPTION: implements an interface for IIC/I2C, both directly from other
  6 *!              kernel modules (i2c_writereg/readreg) and from userspace using
  7 *!              ioctl()'s
  8 *!
  9 *! Nov 30 1998  Torbjorn Eliasson  Initial version.
 10 *!              Bjorn Wesen        Elinux kernel version.
 11 *! Jan 14 2000  Johan Adolfsson    Fixed PB shadow register stuff -
 12 *!                                 don't use PB_I2C if DS1302 uses same bits,
 13 *!                                 use PB.
 14 *| June 23 2003 Pieter Grimmerink  Added 'i2c_sendnack'. i2c_readreg now
 15 *|                                 generates nack on last received byte,
 16 *|                                 instead of ack.
 17 *|                                 i2c_getack changed data level while clock
 18 *|                                 was high, causing DS75 to see  a stop condition
 19 *!
 20 *! ---------------------------------------------------------------------------
 21 *!
 22 *! (C) Copyright 1999-2007 Axis Communications AB, LUND, SWEDEN
 23 *!
 24 *!***************************************************************************/
 25 
 26 /****************** INCLUDE FILES SECTION ***********************************/
 27 
 28 #include <linux/module.h>
 29 #include <linux/sched.h>
 30 #include <linux/errno.h>
 31 #include <linux/kernel.h>
 32 #include <linux/fs.h>
 33 #include <linux/string.h>
 34 #include <linux/init.h>
 35 #include <linux/mutex.h>
 36 
 37 #include <asm/etraxi2c.h>
 38 
 39 #include <asm/io.h>
 40 #include <asm/delay.h>
 41 
 42 #include "i2c.h"
 43 
 44 /****************** I2C DEFINITION SECTION *************************/
 45 
 46 #define D(x)
 47 
 48 #define I2C_MAJOR 123  /* LOCAL/EXPERIMENTAL */
 49 static DEFINE_MUTEX(i2c_mutex);
 50 static const char i2c_name[] = "i2c";
 51 
 52 #define CLOCK_LOW_TIME            8
 53 #define CLOCK_HIGH_TIME           8
 54 #define START_CONDITION_HOLD_TIME 8
 55 #define STOP_CONDITION_HOLD_TIME  8
 56 #define ENABLE_OUTPUT 0x01
 57 #define ENABLE_INPUT 0x00
 58 #define I2C_CLOCK_HIGH 1
 59 #define I2C_CLOCK_LOW 0
 60 #define I2C_DATA_HIGH 1
 61 #define I2C_DATA_LOW 0
 62 
 63 #define i2c_enable()
 64 #define i2c_disable()
 65 
 66 /* enable or disable output-enable, to select output or input on the i2c bus */
 67 
 68 #define i2c_dir_out() crisv32_io_set_dir(&cris_i2c_data, crisv32_io_dir_out)
 69 #define i2c_dir_in() crisv32_io_set_dir(&cris_i2c_data, crisv32_io_dir_in)
 70 
 71 /* control the i2c clock and data signals */
 72 
 73 #define i2c_clk(x) crisv32_io_set(&cris_i2c_clk, x)
 74 #define i2c_data(x) crisv32_io_set(&cris_i2c_data, x)
 75 
 76 /* read a bit from the i2c interface */
 77 
 78 #define i2c_getbit() crisv32_io_rd(&cris_i2c_data)
 79 
 80 #define i2c_delay(usecs) udelay(usecs)
 81 
 82 static DEFINE_SPINLOCK(i2c_lock); /* Protect directions etc */
 83 
 84 /****************** VARIABLE SECTION ************************************/
 85 
 86 static struct crisv32_iopin cris_i2c_clk;
 87 static struct crisv32_iopin cris_i2c_data;
 88 
 89 /****************** FUNCTION DEFINITION SECTION *************************/
 90 
 91 
 92 /* generate i2c start condition */
 93 
 94 void
 95 i2c_start(void)
 96 {
 97         /*
 98          * SCL=1 SDA=1
 99          */
100         i2c_dir_out();
101         i2c_delay(CLOCK_HIGH_TIME/6);
102         i2c_data(I2C_DATA_HIGH);
103         i2c_clk(I2C_CLOCK_HIGH);
104         i2c_delay(CLOCK_HIGH_TIME);
105         /*
106          * SCL=1 SDA=0
107          */
108         i2c_data(I2C_DATA_LOW);
109         i2c_delay(START_CONDITION_HOLD_TIME);
110         /*
111          * SCL=0 SDA=0
112          */
113         i2c_clk(I2C_CLOCK_LOW);
114         i2c_delay(CLOCK_LOW_TIME);
115 }
116 
117 /* generate i2c stop condition */
118 
119 void
120 i2c_stop(void)
121 {
122         i2c_dir_out();
123 
124         /*
125          * SCL=0 SDA=0
126          */
127         i2c_clk(I2C_CLOCK_LOW);
128         i2c_data(I2C_DATA_LOW);
129         i2c_delay(CLOCK_LOW_TIME*2);
130         /*
131          * SCL=1 SDA=0
132          */
133         i2c_clk(I2C_CLOCK_HIGH);
134         i2c_delay(CLOCK_HIGH_TIME*2);
135         /*
136          * SCL=1 SDA=1
137          */
138         i2c_data(I2C_DATA_HIGH);
139         i2c_delay(STOP_CONDITION_HOLD_TIME);
140 
141         i2c_dir_in();
142 }
143 
144 /* write a byte to the i2c interface */
145 
146 void
147 i2c_outbyte(unsigned char x)
148 {
149         int i;
150 
151         i2c_dir_out();
152 
153         for (i = 0; i < 8; i++) {
154                 if (x & 0x80) {
155                         i2c_data(I2C_DATA_HIGH);
156                 } else {
157                         i2c_data(I2C_DATA_LOW);
158                 }
159 
160                 i2c_delay(CLOCK_LOW_TIME/2);
161                 i2c_clk(I2C_CLOCK_HIGH);
162                 i2c_delay(CLOCK_HIGH_TIME);
163                 i2c_clk(I2C_CLOCK_LOW);
164                 i2c_delay(CLOCK_LOW_TIME/2);
165                 x <<= 1;
166         }
167         i2c_data(I2C_DATA_LOW);
168         i2c_delay(CLOCK_LOW_TIME/2);
169 
170         /*
171          * enable input
172          */
173         i2c_dir_in();
174 }
175 
176 /* read a byte from the i2c interface */
177 
178 unsigned char
179 i2c_inbyte(void)
180 {
181         unsigned char aBitByte = 0;
182         int i;
183 
184         /* Switch off I2C to get bit */
185         i2c_disable();
186         i2c_dir_in();
187         i2c_delay(CLOCK_HIGH_TIME/2);
188 
189         /* Get bit */
190         aBitByte |= i2c_getbit();
191 
192         /* Enable I2C */
193         i2c_enable();
194         i2c_delay(CLOCK_LOW_TIME/2);
195 
196         for (i = 1; i < 8; i++) {
197                 aBitByte <<= 1;
198                 /* Clock pulse */
199                 i2c_clk(I2C_CLOCK_HIGH);
200                 i2c_delay(CLOCK_HIGH_TIME);
201                 i2c_clk(I2C_CLOCK_LOW);
202                 i2c_delay(CLOCK_LOW_TIME);
203 
204                 /* Switch off I2C to get bit */
205                 i2c_disable();
206                 i2c_dir_in();
207                 i2c_delay(CLOCK_HIGH_TIME/2);
208 
209                 /* Get bit */
210                 aBitByte |= i2c_getbit();
211 
212                 /* Enable I2C */
213                 i2c_enable();
214                 i2c_delay(CLOCK_LOW_TIME/2);
215         }
216         i2c_clk(I2C_CLOCK_HIGH);
217         i2c_delay(CLOCK_HIGH_TIME);
218 
219         /*
220          * we leave the clock low, getbyte is usually followed
221          * by sendack/nack, they assume the clock to be low
222          */
223         i2c_clk(I2C_CLOCK_LOW);
224         return aBitByte;
225 }
226 
227 /*#---------------------------------------------------------------------------
228 *#
229 *# FUNCTION NAME: i2c_getack
230 *#
231 *# DESCRIPTION  : checks if ack was received from ic2
232 *#
233 *#--------------------------------------------------------------------------*/
234 
235 int
236 i2c_getack(void)
237 {
238         int ack = 1;
239         /*
240          * enable output
241          */
242         i2c_dir_out();
243         /*
244          * Release data bus by setting
245          * data high
246          */
247         i2c_data(I2C_DATA_HIGH);
248         /*
249          * enable input
250          */
251         i2c_dir_in();
252         i2c_delay(CLOCK_HIGH_TIME/4);
253         /*
254          * generate ACK clock pulse
255          */
256         i2c_clk(I2C_CLOCK_HIGH);
257 #if 0
258         /*
259          * Use PORT PB instead of I2C
260          * for input. (I2C not working)
261          */
262         i2c_clk(1);
263         i2c_data(1);
264         /*
265          * switch off I2C
266          */
267         i2c_data(1);
268         i2c_disable();
269         i2c_dir_in();
270 #endif
271 
272         /*
273          * now wait for ack
274          */
275         i2c_delay(CLOCK_HIGH_TIME/2);
276         /*
277          * check for ack
278          */
279         if (i2c_getbit())
280                 ack = 0;
281         i2c_delay(CLOCK_HIGH_TIME/2);
282         if (!ack) {
283                 if (!i2c_getbit()) /* receiver pulld SDA low */
284                         ack = 1;
285                 i2c_delay(CLOCK_HIGH_TIME/2);
286         }
287 
288    /*
289     * our clock is high now, make sure data is low
290     * before we enable our output. If we keep data high
291     * and enable output, we would generate a stop condition.
292     */
293 #if 0
294    i2c_data(I2C_DATA_LOW);
295 
296         /*
297          * end clock pulse
298          */
299         i2c_enable();
300         i2c_dir_out();
301 #endif
302         i2c_clk(I2C_CLOCK_LOW);
303         i2c_delay(CLOCK_HIGH_TIME/4);
304         /*
305          * enable output
306          */
307         i2c_dir_out();
308         /*
309          * remove ACK clock pulse
310          */
311         i2c_data(I2C_DATA_HIGH);
312         i2c_delay(CLOCK_LOW_TIME/2);
313         return ack;
314 }
315 
316 /*#---------------------------------------------------------------------------
317 *#
318 *# FUNCTION NAME: I2C::sendAck
319 *#
320 *# DESCRIPTION  : Send ACK on received data
321 *#
322 *#--------------------------------------------------------------------------*/
323 void
324 i2c_sendack(void)
325 {
326         /*
327          * enable output
328          */
329         i2c_delay(CLOCK_LOW_TIME);
330         i2c_dir_out();
331         /*
332          * set ack pulse high
333          */
334         i2c_data(I2C_DATA_LOW);
335         /*
336          * generate clock pulse
337          */
338         i2c_delay(CLOCK_HIGH_TIME/6);
339         i2c_clk(I2C_CLOCK_HIGH);
340         i2c_delay(CLOCK_HIGH_TIME);
341         i2c_clk(I2C_CLOCK_LOW);
342         i2c_delay(CLOCK_LOW_TIME/6);
343         /*
344          * reset data out
345          */
346         i2c_data(I2C_DATA_HIGH);
347         i2c_delay(CLOCK_LOW_TIME);
348 
349         i2c_dir_in();
350 }
351 
352 /*#---------------------------------------------------------------------------
353 *#
354 *# FUNCTION NAME: i2c_sendnack
355 *#
356 *# DESCRIPTION  : Sends NACK on received data
357 *#
358 *#--------------------------------------------------------------------------*/
359 void
360 i2c_sendnack(void)
361 {
362         /*
363          * enable output
364          */
365         i2c_delay(CLOCK_LOW_TIME);
366         i2c_dir_out();
367         /*
368          * set data high
369          */
370         i2c_data(I2C_DATA_HIGH);
371         /*
372          * generate clock pulse
373          */
374         i2c_delay(CLOCK_HIGH_TIME/6);
375         i2c_clk(I2C_CLOCK_HIGH);
376         i2c_delay(CLOCK_HIGH_TIME);
377         i2c_clk(I2C_CLOCK_LOW);
378         i2c_delay(CLOCK_LOW_TIME);
379 
380         i2c_dir_in();
381 }
382 
383 /*#---------------------------------------------------------------------------
384 *#
385 *# FUNCTION NAME: i2c_write
386 *#
387 *# DESCRIPTION  : Writes a value to an I2C device
388 *#
389 *#--------------------------------------------------------------------------*/
390 int
391 i2c_write(unsigned char theSlave, void *data, size_t nbytes)
392 {
393         int error, cntr = 3;
394         unsigned char bytes_wrote = 0;
395         unsigned char value;
396         unsigned long flags;
397 
398         spin_lock_irqsave(&i2c_lock, flags);
399 
400         do {
401                 error = 0;
402 
403                 i2c_start();
404                 /*
405                  * send slave address
406                  */
407                 i2c_outbyte((theSlave & 0xfe));
408                 /*
409                  * wait for ack
410                  */
411                 if (!i2c_getack())
412                         error = 1;
413                 /*
414                  * send data
415                  */
416                 for (bytes_wrote = 0; bytes_wrote < nbytes; bytes_wrote++) {
417                         memcpy(&value, data + bytes_wrote, sizeof value);
418                         i2c_outbyte(value);
419                         /*
420                          * now it's time to wait for ack
421                          */
422                         if (!i2c_getack())
423                                 error |= 4;
424                 }
425                 /*
426                  * end byte stream
427                  */
428                 i2c_stop();
429 
430         } while (error && cntr--);
431 
432         i2c_delay(CLOCK_LOW_TIME);
433 
434         spin_unlock_irqrestore(&i2c_lock, flags);
435 
436         return -error;
437 }
438 
439 /*#---------------------------------------------------------------------------
440 *#
441 *# FUNCTION NAME: i2c_read
442 *#
443 *# DESCRIPTION  : Reads a value from an I2C device
444 *#
445 *#--------------------------------------------------------------------------*/
446 int
447 i2c_read(unsigned char theSlave, void *data, size_t nbytes)
448 {
449         unsigned char b = 0;
450         unsigned char bytes_read = 0;
451         int error, cntr = 3;
452         unsigned long flags;
453 
454         spin_lock_irqsave(&i2c_lock, flags);
455 
456         do {
457                 error = 0;
458                 memset(data, 0, nbytes);
459                 /*
460                  * generate start condition
461                  */
462                 i2c_start();
463                 /*
464                  * send slave address
465                  */
466                 i2c_outbyte((theSlave | 0x01));
467                 /*
468                  * wait for ack
469                  */
470                 if (!i2c_getack())
471                         error = 1;
472                 /*
473                  * fetch data
474                  */
475                 for (bytes_read = 0; bytes_read < nbytes; bytes_read++) {
476                         b = i2c_inbyte();
477                         memcpy(data + bytes_read, &b, sizeof b);
478 
479                         if (bytes_read < (nbytes - 1))
480                                 i2c_sendack();
481                 }
482                 /*
483                  * last received byte needs to be nacked
484                  * instead of acked
485                  */
486                 i2c_sendnack();
487                 /*
488                  * end sequence
489                  */
490                 i2c_stop();
491         } while (error && cntr--);
492 
493         spin_unlock_irqrestore(&i2c_lock, flags);
494 
495         return -error;
496 }
497 
498 /*#---------------------------------------------------------------------------
499 *#
500 *# FUNCTION NAME: i2c_writereg
501 *#
502 *# DESCRIPTION  : Writes a value to an I2C device
503 *#
504 *#--------------------------------------------------------------------------*/
505 int
506 i2c_writereg(unsigned char theSlave, unsigned char theReg,
507              unsigned char theValue)
508 {
509         int error, cntr = 3;
510         unsigned long flags;
511 
512         spin_lock_irqsave(&i2c_lock, flags);
513 
514         do {
515                 error = 0;
516 
517                 i2c_start();
518                 /*
519                  * send slave address
520                  */
521                 i2c_outbyte((theSlave & 0xfe));
522                 /*
523                  * wait for ack
524                  */
525                 if(!i2c_getack())
526                         error = 1;
527                 /*
528                  * now select register
529                  */
530                 i2c_dir_out();
531                 i2c_outbyte(theReg);
532                 /*
533                  * now it's time to wait for ack
534                  */
535                 if(!i2c_getack())
536                         error |= 2;
537                 /*
538                  * send register register data
539                  */
540                 i2c_outbyte(theValue);
541                 /*
542                  * now it's time to wait for ack
543                  */
544                 if(!i2c_getack())
545                         error |= 4;
546                 /*
547                  * end byte stream
548                  */
549                 i2c_stop();
550         } while(error && cntr--);
551 
552         i2c_delay(CLOCK_LOW_TIME);
553 
554         spin_unlock_irqrestore(&i2c_lock, flags);
555 
556         return -error;
557 }
558 
559 /*#---------------------------------------------------------------------------
560 *#
561 *# FUNCTION NAME: i2c_readreg
562 *#
563 *# DESCRIPTION  : Reads a value from the decoder registers.
564 *#
565 *#--------------------------------------------------------------------------*/
566 unsigned char
567 i2c_readreg(unsigned char theSlave, unsigned char theReg)
568 {
569         unsigned char b = 0;
570         int error, cntr = 3;
571         unsigned long flags;
572 
573         spin_lock_irqsave(&i2c_lock, flags);
574 
575         do {
576                 error = 0;
577                 /*
578                  * generate start condition
579                  */
580                 i2c_start();
581 
582                 /*
583                  * send slave address
584                  */
585                 i2c_outbyte((theSlave & 0xfe));
586                 /*
587                  * wait for ack
588                  */
589                 if(!i2c_getack())
590                         error = 1;
591                 /*
592                  * now select register
593                  */
594                 i2c_dir_out();
595                 i2c_outbyte(theReg);
596                 /*
597                  * now it's time to wait for ack
598                  */
599                 if(!i2c_getack())
600                         error |= 2;
601                 /*
602                  * repeat start condition
603                  */
604                 i2c_delay(CLOCK_LOW_TIME);
605                 i2c_start();
606                 /*
607                  * send slave address
608                  */
609                 i2c_outbyte(theSlave | 0x01);
610                 /*
611                  * wait for ack
612                  */
613                 if(!i2c_getack())
614                         error |= 4;
615                 /*
616                  * fetch register
617                  */
618                 b = i2c_inbyte();
619                 /*
620                  * last received byte needs to be nacked
621                  * instead of acked
622                  */
623                 i2c_sendnack();
624                 /*
625                  * end sequence
626                  */
627                 i2c_stop();
628 
629         } while(error && cntr--);
630 
631         spin_unlock_irqrestore(&i2c_lock, flags);
632 
633         return b;
634 }
635 
636 static int
637 i2c_open(struct inode *inode, struct file *filp)
638 {
639         return 0;
640 }
641 
642 static int
643 i2c_release(struct inode *inode, struct file *filp)
644 {
645         return 0;
646 }
647 
648 /* Main device API. ioctl's to write or read to/from i2c registers.
649  */
650 
651 static long
652 i2c_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
653 {
654         int ret;
655         if(_IOC_TYPE(cmd) != ETRAXI2C_IOCTYPE) {
656                 return -ENOTTY;
657         }
658 
659         switch (_IOC_NR(cmd)) {
660                 case I2C_WRITEREG:
661                         /* write to an i2c slave */
662                         D(printk("i2cw %d %d %d\n",
663                                  I2C_ARGSLAVE(arg),
664                                  I2C_ARGREG(arg),
665                                  I2C_ARGVALUE(arg)));
666 
667                         mutex_lock(&i2c_mutex);
668                         ret = i2c_writereg(I2C_ARGSLAVE(arg),
669                                             I2C_ARGREG(arg),
670                                             I2C_ARGVALUE(arg));
671                         mutex_unlock(&i2c_mutex);
672                         return ret;
673 
674                 case I2C_READREG:
675                 {
676                         unsigned char val;
677                         /* read from an i2c slave */
678                         D(printk("i2cr %d %d ",
679                                 I2C_ARGSLAVE(arg),
680                                 I2C_ARGREG(arg)));
681                         mutex_lock(&i2c_mutex);
682                         val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg));
683                         mutex_unlock(&i2c_mutex);
684                         D(printk("= %d\n", val));
685                         return val;
686                 }
687                 default:
688                         return -EINVAL;
689 
690         }
691 
692         return 0;
693 }
694 
695 static const struct file_operations i2c_fops = {
696         .owner          = THIS_MODULE,
697         .unlocked_ioctl = i2c_ioctl,
698         .open           = i2c_open,
699         .release        = i2c_release,
700         .llseek         = noop_llseek,
701 };
702 
703 static int __init i2c_init(void)
704 {
705         static int res;
706         static int first = 1;
707 
708         if (!first)
709                 return res;
710 
711         first = 0;
712 
713         /* Setup and enable the DATA and CLK pins */
714 
715         res = crisv32_io_get_name(&cris_i2c_data,
716                 CONFIG_ETRAX_V32_I2C_DATA_PORT);
717         if (res < 0)
718                 return res;
719 
720         res = crisv32_io_get_name(&cris_i2c_clk, CONFIG_ETRAX_V32_I2C_CLK_PORT);
721         crisv32_io_set_dir(&cris_i2c_clk, crisv32_io_dir_out);
722 
723         return res;
724 }
725 
726 
727 static int __init i2c_register(void)
728 {
729         int res;
730 
731         res = i2c_init();
732         if (res < 0)
733                 return res;
734 
735         /* register char device */
736 
737         res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops);
738         if (res < 0) {
739                 printk(KERN_ERR "i2c: couldn't get a major number.\n");
740                 return res;
741         }
742 
743         printk(KERN_INFO
744                 "I2C driver v2.2, (c) 1999-2007 Axis Communications AB\n");
745 
746         return 0;
747 }
748 /* this makes sure that i2c_init is called during boot */
749 module_init(i2c_register);
750 
751 /****************** END OF FILE i2c.c ********************************/
752 

~ [ 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