[PATCH] CRIS update: drivers
[linux-2.6.git] / arch / cris / arch-v10 / drivers / i2c.c
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 *! $Log: i2c.c,v $
15 *! Revision 1.13  2005/03/07 13:13:07  starvik
16 *! Added spinlocks to protect states etc
17 *!
18 *! Revision 1.12  2005/01/05 06:11:22  starvik
19 *! No need to do local_irq_disable after local_irq_save.
20 *!
21 *! Revision 1.11  2004/12/13 12:21:52  starvik
22 *! Added I/O and DMA allocators from Linux 2.4
23 *!
24 *! Revision 1.9  2004/08/24 06:49:14  starvik
25 *! Whitespace cleanup
26 *!
27 *! Revision 1.8  2004/06/08 08:48:26  starvik
28 *! Removed unused code
29 *!
30 *! Revision 1.7  2004/05/28 09:26:59  starvik
31 *! Modified I2C initialization to work in 2.6.
32 *!
33 *! Revision 1.6  2004/05/14 07:58:03  starvik
34 *! Merge of changes from 2.4
35 *!
36 *! Revision 1.4  2002/12/11 13:13:57  starvik
37 *! Added arch/ to v10 specific includes
38 *! Added fix from Linux 2.4 in serial.c (flush_to_flip_buffer)
39 *!
40 *! Revision 1.3  2002/11/20 11:56:11  starvik
41 *! Merge of Linux 2.5.48
42 *!
43 *! Revision 1.2  2002/11/18 13:16:06  starvik
44 *! Linux 2.5 port of latest 2.4 drivers
45 *!
46 *! Revision 1.9  2002/10/31 15:32:26  starvik
47 *! Update Port B register and shadow even when running with hardware support
48 *!   to avoid glitches when reading bits
49 *! Never set direction to out in i2c_inbyte
50 *! Removed incorrect clock togling at end of i2c_inbyte
51 *!
52 *! Revision 1.8  2002/08/13 06:31:53  starvik
53 *! Made SDA and SCL line configurable
54 *! Modified i2c_inbyte to work with PCF8563
55 *!
56 *! Revision 1.7  2001/04/04 13:11:36  markusl
57 *! Updated according to review remarks
58 *!
59 *! Revision 1.6  2001/03/19 12:43:00  markusl
60 *! Made some symbols unstatic (used by the eeprom driver)
61 *!
62 *! Revision 1.5  2001/02/27 13:52:48  bjornw
63 *! malloc.h -> slab.h
64 *!
65 *! Revision 1.4  2001/02/15 07:17:40  starvik
66 *! Corrected usage if port_pb_i2c_shadow
67 *!
68 *! Revision 1.3  2001/01/26 17:55:13  bjornw
69 *! * Made I2C_USES_PB_NOT_PB_I2C a CONFIG option instead of assigning it
70 *!   magically. Config.in needs to set it for the options that need it, like
71 *!   Dallas 1302 support. Actually, it should be default since it screws up
72 *!   the PB bits even if you don't use I2C..
73 *! * Include linux/config.h to get the above
74 *!
75 *! Revision 1.2  2001/01/18 15:49:30  bjornw
76 *! 2.4 port of I2C including some cleanups (untested of course)
77 *!
78 *! Revision 1.1  2001/01/18 15:35:25  bjornw
79 *! Verbatim copy of the Etrax i2c driver, 2.0 elinux version
80 *!
81 *!
82 *! ---------------------------------------------------------------------------
83 *!
84 *! (C) Copyright 1999-2002 Axis Communications AB, LUND, SWEDEN
85 *!
86 *!***************************************************************************/
87 /* $Id: i2c.c,v 1.13 2005/03/07 13:13:07 starvik Exp $ */
88
89 /****************** INCLUDE FILES SECTION ***********************************/
90
91 #include <linux/module.h>
92 #include <linux/sched.h>
93 #include <linux/slab.h>
94 #include <linux/errno.h>
95 #include <linux/kernel.h>
96 #include <linux/fs.h>
97 #include <linux/string.h>
98 #include <linux/init.h>
99 #include <linux/config.h>
100
101 #include <asm/etraxi2c.h>
102
103 #include <asm/system.h>
104 #include <asm/arch/svinto.h>
105 #include <asm/io.h>
106 #include <asm/delay.h>
107 #include <asm/arch/io_interface_mux.h>
108
109 #include "i2c.h"
110
111 /****************** I2C DEFINITION SECTION *************************/
112
113 #define D(x)
114
115 #define I2C_MAJOR 123  /* LOCAL/EXPERIMENTAL */
116 static const char i2c_name[] = "i2c";
117
118 #define CLOCK_LOW_TIME            8
119 #define CLOCK_HIGH_TIME           8
120 #define START_CONDITION_HOLD_TIME 8
121 #define STOP_CONDITION_HOLD_TIME  8
122 #define ENABLE_OUTPUT 0x01
123 #define ENABLE_INPUT 0x00
124 #define I2C_CLOCK_HIGH 1
125 #define I2C_CLOCK_LOW 0
126 #define I2C_DATA_HIGH 1
127 #define I2C_DATA_LOW 0
128
129 #ifdef CONFIG_ETRAX_I2C_USES_PB_NOT_PB_I2C
130 /* Use PB and not PB_I2C */
131 #ifndef CONFIG_ETRAX_I2C_DATA_PORT
132 #define CONFIG_ETRAX_I2C_DATA_PORT 0
133 #endif
134 #ifndef CONFIG_ETRAX_I2C_CLK_PORT
135 #define CONFIG_ETRAX_I2C_CLK_PORT 1
136 #endif
137
138 #define SDABIT CONFIG_ETRAX_I2C_DATA_PORT
139 #define SCLBIT CONFIG_ETRAX_I2C_CLK_PORT
140 #define i2c_enable() 
141 #define i2c_disable() 
142
143 /* enable or disable output-enable, to select output or input on the i2c bus */
144
145 #define i2c_dir_out() \
146   REG_SHADOW_SET(R_PORT_PB_DIR, port_pb_dir_shadow, SDABIT, 1)
147 #define i2c_dir_in()  \
148   REG_SHADOW_SET(R_PORT_PB_DIR, port_pb_dir_shadow, SDABIT, 0)
149
150 /* control the i2c clock and data signals */
151
152 #define i2c_clk(x) \
153   REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, SCLBIT, x)
154 #define i2c_data(x) \
155   REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, SDABIT, x)
156
157 /* read a bit from the i2c interface */
158
159 #define i2c_getbit() (((*R_PORT_PB_READ & (1 << SDABIT))) >> SDABIT)
160
161 #else
162 /* enable or disable the i2c interface */
163
164 #define i2c_enable() *R_PORT_PB_I2C = (port_pb_i2c_shadow |= IO_MASK(R_PORT_PB_I2C, i2c_en))
165 #define i2c_disable() *R_PORT_PB_I2C = (port_pb_i2c_shadow &= ~IO_MASK(R_PORT_PB_I2C, i2c_en))
166
167 /* enable or disable output-enable, to select output or input on the i2c bus */
168
169 #define i2c_dir_out() \
170         *R_PORT_PB_I2C = (port_pb_i2c_shadow &= ~IO_MASK(R_PORT_PB_I2C, i2c_oe_)); \
171         REG_SHADOW_SET(R_PORT_PB_DIR, port_pb_dir_shadow, 0, 1); 
172 #define i2c_dir_in() \
173         *R_PORT_PB_I2C = (port_pb_i2c_shadow |= IO_MASK(R_PORT_PB_I2C, i2c_oe_)); \
174         REG_SHADOW_SET(R_PORT_PB_DIR, port_pb_dir_shadow, 0, 0);
175
176 /* control the i2c clock and data signals */
177
178 #define i2c_clk(x) \
179         *R_PORT_PB_I2C = (port_pb_i2c_shadow = (port_pb_i2c_shadow & \
180        ~IO_MASK(R_PORT_PB_I2C, i2c_clk)) | IO_FIELD(R_PORT_PB_I2C, i2c_clk, (x))); \
181        REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, 1, x);
182
183 #define i2c_data(x) \
184         *R_PORT_PB_I2C = (port_pb_i2c_shadow = (port_pb_i2c_shadow & \
185            ~IO_MASK(R_PORT_PB_I2C, i2c_d)) | IO_FIELD(R_PORT_PB_I2C, i2c_d, (x))); \
186         REG_SHADOW_SET(R_PORT_PB_DATA, port_pb_data_shadow, 0, x);
187
188 /* read a bit from the i2c interface */
189
190 #define i2c_getbit() (*R_PORT_PB_READ & 0x1)
191 #endif
192
193 /* use the kernels delay routine */
194
195 #define i2c_delay(usecs) udelay(usecs)
196
197 static DEFINE_SPINLOCK(i2c_lock); /* Protect directions etc */
198
199 /****************** FUNCTION DEFINITION SECTION *************************/
200
201
202 /* generate i2c start condition */
203
204 void
205 i2c_start(void)
206 {
207         /*
208          * SCL=1 SDA=1
209          */
210         i2c_dir_out();
211         i2c_delay(CLOCK_HIGH_TIME/6);
212         i2c_data(I2C_DATA_HIGH);
213         i2c_clk(I2C_CLOCK_HIGH);
214         i2c_delay(CLOCK_HIGH_TIME);
215         /*
216          * SCL=1 SDA=0
217          */
218         i2c_data(I2C_DATA_LOW);
219         i2c_delay(START_CONDITION_HOLD_TIME);
220         /*
221          * SCL=0 SDA=0
222          */
223         i2c_clk(I2C_CLOCK_LOW);
224         i2c_delay(CLOCK_LOW_TIME);
225 }
226
227 /* generate i2c stop condition */
228
229 void
230 i2c_stop(void)
231 {
232         i2c_dir_out();
233
234         /*
235          * SCL=0 SDA=0
236          */
237         i2c_clk(I2C_CLOCK_LOW);
238         i2c_data(I2C_DATA_LOW);
239         i2c_delay(CLOCK_LOW_TIME*2);
240         /*
241          * SCL=1 SDA=0
242          */
243         i2c_clk(I2C_CLOCK_HIGH);
244         i2c_delay(CLOCK_HIGH_TIME*2);
245         /*
246          * SCL=1 SDA=1
247          */
248         i2c_data(I2C_DATA_HIGH);
249         i2c_delay(STOP_CONDITION_HOLD_TIME);
250
251         i2c_dir_in();
252 }
253
254 /* write a byte to the i2c interface */
255
256 void
257 i2c_outbyte(unsigned char x)
258 {
259         int i;
260
261         i2c_dir_out();
262
263         for (i = 0; i < 8; i++) {
264                 if (x & 0x80) {
265                         i2c_data(I2C_DATA_HIGH);
266                 } else {
267                         i2c_data(I2C_DATA_LOW);
268                 }
269                 
270                 i2c_delay(CLOCK_LOW_TIME/2);
271                 i2c_clk(I2C_CLOCK_HIGH);
272                 i2c_delay(CLOCK_HIGH_TIME);
273                 i2c_clk(I2C_CLOCK_LOW);
274                 i2c_delay(CLOCK_LOW_TIME/2);
275                 x <<= 1;
276         }
277         i2c_data(I2C_DATA_LOW);
278         i2c_delay(CLOCK_LOW_TIME/2);
279
280         /*
281          * enable input
282          */
283         i2c_dir_in();
284 }
285
286 /* read a byte from the i2c interface */
287
288 unsigned char
289 i2c_inbyte(void)
290 {
291         unsigned char aBitByte = 0;
292         int i;
293
294         /* Switch off I2C to get bit */
295         i2c_disable();
296         i2c_dir_in();
297         i2c_delay(CLOCK_HIGH_TIME/2);
298
299         /* Get bit */
300         aBitByte |= i2c_getbit();
301
302         /* Enable I2C */
303         i2c_enable();
304         i2c_delay(CLOCK_LOW_TIME/2);
305
306         for (i = 1; i < 8; i++) {
307                 aBitByte <<= 1;
308                 /* Clock pulse */
309                 i2c_clk(I2C_CLOCK_HIGH);
310                 i2c_delay(CLOCK_HIGH_TIME);
311                 i2c_clk(I2C_CLOCK_LOW);
312                 i2c_delay(CLOCK_LOW_TIME);
313
314                 /* Switch off I2C to get bit */
315                 i2c_disable();
316                 i2c_dir_in();
317                 i2c_delay(CLOCK_HIGH_TIME/2);
318
319                 /* Get bit */
320                 aBitByte |= i2c_getbit();
321
322                 /* Enable I2C */
323                 i2c_enable();
324                 i2c_delay(CLOCK_LOW_TIME/2);
325         }
326         i2c_clk(I2C_CLOCK_HIGH);
327         i2c_delay(CLOCK_HIGH_TIME);
328
329         /*
330          * we leave the clock low, getbyte is usually followed
331          * by sendack/nack, they assume the clock to be low
332          */
333         i2c_clk(I2C_CLOCK_LOW);
334         return aBitByte;
335 }
336
337 /*#---------------------------------------------------------------------------
338 *#
339 *# FUNCTION NAME: i2c_getack
340 *#
341 *# DESCRIPTION  : checks if ack was received from ic2
342 *#
343 *#--------------------------------------------------------------------------*/
344
345 int
346 i2c_getack(void)
347 {
348         int ack = 1;
349         /*
350          * enable output
351          */
352         i2c_dir_out();
353         /*
354          * Release data bus by setting
355          * data high
356          */
357         i2c_data(I2C_DATA_HIGH);
358         /*
359          * enable input
360          */
361         i2c_dir_in();
362         i2c_delay(CLOCK_HIGH_TIME/4);
363         /*
364          * generate ACK clock pulse
365          */
366         i2c_clk(I2C_CLOCK_HIGH);
367         /*
368          * Use PORT PB instead of I2C
369          * for input. (I2C not working)
370          */
371         i2c_clk(1);
372         i2c_data(1);
373         /*
374          * switch off I2C
375          */
376         i2c_data(1);
377         i2c_disable();
378         i2c_dir_in();
379         /*
380          * now wait for ack
381          */
382         i2c_delay(CLOCK_HIGH_TIME/2);
383         /*
384          * check for ack
385          */
386         if(i2c_getbit())
387                 ack = 0;
388         i2c_delay(CLOCK_HIGH_TIME/2);
389         if(!ack){
390                 if(!i2c_getbit()) /* receiver pulld SDA low */
391                         ack = 1;
392                 i2c_delay(CLOCK_HIGH_TIME/2);
393         }
394
395         /*
396          * our clock is high now, make sure data is low
397          * before we enable our output. If we keep data high
398          * and enable output, we would generate a stop condition.
399          */
400         i2c_data(I2C_DATA_LOW);
401
402         /*
403          * end clock pulse
404          */
405         i2c_enable();
406         i2c_dir_out();
407         i2c_clk(I2C_CLOCK_LOW);
408         i2c_delay(CLOCK_HIGH_TIME/4);
409         /*
410          * enable output
411          */
412         i2c_dir_out();
413         /*
414          * remove ACK clock pulse
415          */
416         i2c_data(I2C_DATA_HIGH);
417         i2c_delay(CLOCK_LOW_TIME/2);
418         return ack;
419 }
420
421 /*#---------------------------------------------------------------------------
422 *#
423 *# FUNCTION NAME: I2C::sendAck
424 *#
425 *# DESCRIPTION  : Send ACK on received data
426 *#
427 *#--------------------------------------------------------------------------*/
428 void
429 i2c_sendack(void)
430 {
431         /*
432          * enable output
433          */
434         i2c_delay(CLOCK_LOW_TIME);
435         i2c_dir_out();
436         /*
437          * set ack pulse high
438          */
439         i2c_data(I2C_DATA_LOW);
440         /*
441          * generate clock pulse
442          */
443         i2c_delay(CLOCK_HIGH_TIME/6);
444         i2c_clk(I2C_CLOCK_HIGH);
445         i2c_delay(CLOCK_HIGH_TIME);
446         i2c_clk(I2C_CLOCK_LOW);
447         i2c_delay(CLOCK_LOW_TIME/6);
448         /*
449          * reset data out
450          */
451         i2c_data(I2C_DATA_HIGH);
452         i2c_delay(CLOCK_LOW_TIME);
453
454         i2c_dir_in();
455 }
456
457 /*#---------------------------------------------------------------------------
458 *#
459 *# FUNCTION NAME: i2c_sendnack
460 *#
461 *# DESCRIPTION  : Sends NACK on received data
462 *#
463 *#--------------------------------------------------------------------------*/
464 void
465 i2c_sendnack(void)
466 {
467         /*
468          * enable output
469          */
470         i2c_delay(CLOCK_LOW_TIME);
471         i2c_dir_out();
472         /*
473          * set data high
474          */
475         i2c_data(I2C_DATA_HIGH);
476         /*
477          * generate clock pulse
478          */
479         i2c_delay(CLOCK_HIGH_TIME/6);
480         i2c_clk(I2C_CLOCK_HIGH);
481         i2c_delay(CLOCK_HIGH_TIME);
482         i2c_clk(I2C_CLOCK_LOW);
483         i2c_delay(CLOCK_LOW_TIME);
484
485         i2c_dir_in();
486 }
487
488 /*#---------------------------------------------------------------------------
489 *#
490 *# FUNCTION NAME: i2c_writereg
491 *#
492 *# DESCRIPTION  : Writes a value to an I2C device
493 *#
494 *#--------------------------------------------------------------------------*/
495 int
496 i2c_writereg(unsigned char theSlave, unsigned char theReg, 
497              unsigned char theValue)
498 {
499         int error, cntr = 3;
500         unsigned long flags;
501
502         spin_lock(&i2c_lock);
503
504         do {
505                 error = 0;
506                 /*
507                  * we don't like to be interrupted
508                  */
509                 local_irq_save(flags);
510
511                 i2c_start();
512                 /*
513                  * send slave address
514                  */
515                 i2c_outbyte((theSlave & 0xfe));
516                 /*
517                  * wait for ack
518                  */
519                 if(!i2c_getack())
520                         error = 1;
521                 /*
522                  * now select register
523                  */
524                 i2c_dir_out();
525                 i2c_outbyte(theReg);
526                 /*
527                  * now it's time to wait for ack
528                  */
529                 if(!i2c_getack())
530                         error |= 2;
531                 /*
532                  * send register register data
533                  */
534                 i2c_outbyte(theValue);
535                 /*
536                  * now it's time to wait for ack
537                  */
538                 if(!i2c_getack())
539                         error |= 4;
540                 /*
541                  * end byte stream
542                  */
543                 i2c_stop();
544                 /*
545                  * enable interrupt again
546                  */
547                 local_irq_restore(flags);
548                 
549         } while(error && cntr--);
550
551         i2c_delay(CLOCK_LOW_TIME);
552
553         spin_unlock(&i2c_lock);
554
555         return -error;
556 }
557
558 /*#---------------------------------------------------------------------------
559 *#
560 *# FUNCTION NAME: i2c_readreg
561 *#
562 *# DESCRIPTION  : Reads a value from the decoder registers.
563 *#
564 *#--------------------------------------------------------------------------*/
565 unsigned char
566 i2c_readreg(unsigned char theSlave, unsigned char theReg)
567 {
568         unsigned char b = 0;
569         int error, cntr = 3;
570         unsigned long flags;
571
572         spin_lock(&i2c_lock);
573
574         do {
575                 error = 0;
576                 /*
577                  * we don't like to be interrupted
578                  */
579                 local_irq_save(flags);
580                 /*
581                  * generate start condition
582                  */
583                 i2c_start();
584     
585                 /*
586                  * send slave address
587                  */
588                 i2c_outbyte((theSlave & 0xfe));
589                 /*
590                  * wait for ack
591                  */
592                 if(!i2c_getack())
593                         error = 1;
594                 /*
595                  * now select register
596                  */
597                 i2c_dir_out();
598                 i2c_outbyte(theReg);
599                 /*
600                  * now it's time to wait for ack
601                  */
602                 if(!i2c_getack())
603                         error = 1;
604                 /*
605                  * repeat start condition
606                  */
607                 i2c_delay(CLOCK_LOW_TIME);
608                 i2c_start();
609                 /*
610                  * send slave address
611                  */
612                 i2c_outbyte(theSlave | 0x01);
613                 /*
614                  * wait for ack
615                  */
616                 if(!i2c_getack())
617                         error = 1;
618                 /*
619                  * fetch register
620                  */
621                 b = i2c_inbyte();
622                 /*
623                  * last received byte needs to be nacked
624                  * instead of acked
625                  */
626                 i2c_sendack();
627                 /*
628                  * end sequence
629                  */
630                 i2c_stop();
631                 /*
632                  * enable interrupt again
633                  */
634                 local_irq_restore(flags);
635                 
636         } while(error && cntr--);
637
638         spin_unlock(&i2c_lock);
639
640         return b;
641 }
642
643 static int
644 i2c_open(struct inode *inode, struct file *filp)
645 {
646         return 0;
647 }
648
649 static int
650 i2c_release(struct inode *inode, struct file *filp)
651 {
652         return 0;
653 }
654
655 /* Main device API. ioctl's to write or read to/from i2c registers.
656  */
657
658 static int
659 i2c_ioctl(struct inode *inode, struct file *file,
660           unsigned int cmd, unsigned long arg)
661 {
662         if(_IOC_TYPE(cmd) != ETRAXI2C_IOCTYPE) {
663                 return -EINVAL;
664         }
665
666         switch (_IOC_NR(cmd)) {
667                 case I2C_WRITEREG:
668                         /* write to an i2c slave */
669                         D(printk("i2cw %d %d %d\n", 
670                                  I2C_ARGSLAVE(arg),
671                                  I2C_ARGREG(arg),
672                                  I2C_ARGVALUE(arg)));
673
674                         return i2c_writereg(I2C_ARGSLAVE(arg),
675                                             I2C_ARGREG(arg),
676                                             I2C_ARGVALUE(arg));
677                 case I2C_READREG:
678                 {
679                         unsigned char val;
680                         /* read from an i2c slave */
681                         D(printk("i2cr %d %d ", 
682                                 I2C_ARGSLAVE(arg),
683                                 I2C_ARGREG(arg)));
684                         val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg));
685                         D(printk("= %d\n", val));
686                         return val;
687                 }                                           
688                 default:
689                         return -EINVAL;
690
691         }
692         
693         return 0;
694 }
695
696 static struct file_operations i2c_fops = {
697         .owner    = THIS_MODULE,
698         .ioctl    = i2c_ioctl,
699         .open     = i2c_open,
700         .release  = i2c_release,
701 };
702
703 int __init
704 i2c_init(void)
705 {
706         static int res = 0;
707         static int first = 1;
708
709         if (!first) {
710                 return res;
711         }
712
713         /* Setup and enable the Port B I2C interface */
714
715 #ifndef CONFIG_ETRAX_I2C_USES_PB_NOT_PB_I2C
716         if ((res = cris_request_io_interface(if_i2c, "I2C"))) {
717                 printk(KERN_CRIT "i2c_init: Failed to get IO interface\n");
718                 return res;
719         }
720
721         *R_PORT_PB_I2C = port_pb_i2c_shadow |= 
722                 IO_STATE(R_PORT_PB_I2C, i2c_en,  on) |
723                 IO_FIELD(R_PORT_PB_I2C, i2c_d,   1)  |
724                 IO_FIELD(R_PORT_PB_I2C, i2c_clk, 1)  |
725                 IO_STATE(R_PORT_PB_I2C, i2c_oe_, enable);
726
727         port_pb_dir_shadow &= ~IO_MASK(R_PORT_PB_DIR, dir0);
728         port_pb_dir_shadow &= ~IO_MASK(R_PORT_PB_DIR, dir1);
729
730         *R_PORT_PB_DIR = (port_pb_dir_shadow |=
731                           IO_STATE(R_PORT_PB_DIR, dir0, input)  |
732                           IO_STATE(R_PORT_PB_DIR, dir1, output));
733 #else
734         if ((res = cris_io_interface_allocate_pins(if_i2c,
735                                                    'b',
736                                                    CONFIG_ETRAX_I2C_DATA_PORT,
737                                                    CONFIG_ETRAX_I2C_DATA_PORT))) {
738                 printk(KERN_WARNING "i2c_init: Failed to get IO pin for I2C data port\n");
739                 return res;
740         } else if ((res = cris_io_interface_allocate_pins(if_i2c,
741                                                           'b',
742                                                           CONFIG_ETRAX_I2C_CLK_PORT,
743                                                           CONFIG_ETRAX_I2C_CLK_PORT))) {
744                 cris_io_interface_free_pins(if_i2c,
745                                             'b',
746                                             CONFIG_ETRAX_I2C_DATA_PORT,
747                                             CONFIG_ETRAX_I2C_DATA_PORT);
748                 printk(KERN_WARNING "i2c_init: Failed to get IO pin for I2C clk port\n");
749         }
750 #endif
751
752         return res;
753 }
754
755 static int __init
756 i2c_register(void)
757 {
758         int res;
759
760         res = i2c_init();
761         if (res < 0)
762                 return res;
763         res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops);
764         if(res < 0) {
765                 printk(KERN_ERR "i2c: couldn't get a major number.\n");
766                 return res;
767         }
768
769         printk(KERN_INFO "I2C driver v2.2, (c) 1999-2004 Axis Communications AB\n");
770         
771         return 0;
772 }
773
774 /* this makes sure that i2c_register is called during boot */
775
776 module_init(i2c_register);
777
778 /****************** END OF FILE i2c.c ********************************/