return 0 on exit
[aversive.git] / modules / comm / i2c / i2c.c
1 /*
2  *  Copyright Droids Corporation (2007)
3  *
4  *  This program is free software; you can redistribute it and/or modify
5  *  it under the terms of the GNU General Public License as published by
6  *  the Free Software Foundation; either version 2 of the License, or
7  *  (at your option) any later version.
8  *
9  *  This program is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU General Public License for more details.
13  *
14  *  You should have received a copy of the GNU General Public License
15  *  along with this program; if not, write to the Free Software
16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  *
18  *  Revision : $Id: i2c.c,v 1.1.2.12 2009-04-24 19:26:54 zer0 Exp $
19  *
20  */
21
22 /*
23  * Author : Olivier MATZ zer0@droids-corp.org
24  *
25  * Thanks to Tof for the old i2c module and to Serpilliere for
26  * testing.
27  */
28
29 #include <stdlib.h>
30 #include <string.h>
31 #include <util/twi.h>
32
33 #include <autoconf.h>
34 #include <aversive/errno.h>
35 #include <i2c.h>
36
37 #if I2C_SEND_BUFFER_SIZE < 1
38 #error "I2C_SEND_BUFFER_SIZE must be at least 1"
39 #endif
40
41 #if I2C_RECV_BUFFER_SIZE < 1
42 #error "I2C_RECV_BUFFER_SIZE must be at least 1"
43 #endif
44
45 /** recv event, called when we receive a frame
46  *  params are : data buffer and size */
47 static void (*g_recv_event)(uint8_t *, int8_t) = NULL;
48
49 /** recv event, called when we receive a byte
50  *  params are : hwstatus, index of byte in frame, byte value */
51 static void (*g_recv_byte_event)(uint8_t, uint8_t, uint8_t) = NULL;
52
53 /** send event, called when transmit is complete
54  * param is error code : 0 if success */
55 static void (*g_send_event)(int8_t) = NULL;
56
57 static volatile i2c_mode_t g_mode = I2C_MODE_UNINIT;
58 static volatile uint8_t g_status = I2C_STATUS_READY;
59
60 static volatile uint8_t g_ctrl = 0; /* ctrl flags */
61 static volatile uint8_t g_sync_res = 0; /* result of sync send */
62 static uint8_t g_send_buf[I2C_SEND_BUFFER_SIZE];
63 static uint8_t g_recv_buf[I2C_RECV_BUFFER_SIZE];
64 static volatile uint8_t g_dest = 0; /* destination slave in master mode */
65
66
67 static volatile uint8_t g_send_nbytes = 0; /* number of transmitted bytes */
68 static volatile uint8_t g_send_size = 0; /* size of buffer to be transmitted */
69 static volatile uint8_t g_recv_nbytes = 0; /* number of received bytes */
70 static volatile uint8_t g_recv_size = 0; /* size of buffer to be received */
71
72 #if I2C_DEBUG == 1
73 #include <stdio.h>
74 #include <aversive/pgmspace.h>
75 static volatile uint8_t g_prev_twstatus = 0;
76 static volatile uint8_t g_intr_cpt = 0;
77 static volatile uint8_t g_prev_status = 0;
78 static volatile uint8_t g_command = 0;
79 #endif
80
81 /**
82  * mode is I2C_MODE_UNINIT, I2C_MODE_MASTER, I2C_MODE_MULTIMASTER or
83  * I2C_MODE_SLAVE. Parameter add is the address in slave mode, it is
84  * composed from:
85  *   b7  : true if the uC can be addressed with GENCALL
86  *   b0-6: slave address
87  */
88 void
89 i2c_init(i2c_mode_t mode, uint8_t add)
90 {
91         uint8_t flags;
92
93         IRQ_LOCK(flags);
94
95         if (mode == I2C_MODE_UNINIT) {
96                 /* disable all */
97                 TWCR = 0;
98                 IRQ_UNLOCK(flags);
99                 return;
100         }
101 #ifdef CONFIG_MODULE_I2C_MASTER
102         else if (mode == I2C_MODE_MASTER) {
103                 /* enable, enable int */
104                 TWCR = (1<<TWEN) | (1<<TWIE) ;
105         }
106 #endif
107         else {
108                 /* enable, enable int, answer to own adress */
109                 TWCR = (1<<TWEN) | (1<<TWIE) | (1<<TWEA) ;
110         }
111
112         TWBR = I2C_BITRATE;
113
114         /* prescaler */
115         if (I2C_PRESCALER & 1)
116                 sbi(TWSR, TWPS0);
117         if (I2C_PRESCALER & 2)
118                 sbi(TWSR, TWPS1);
119
120         /* change for TWAR format */
121         TWAR = add << 1 ;
122
123         /* general call */
124         if (add & 0x80)
125                 sbi(TWAR, TWGCE);
126
127         /* init vars */
128         g_mode = mode;
129         g_status = I2C_STATUS_READY;
130         g_dest = 0;
131         g_ctrl = 0;
132         g_recv_nbytes = 0;
133         g_recv_size = 0;
134         g_send_nbytes = 0;
135         g_send_size = 0;
136
137         IRQ_UNLOCK(flags);
138 }
139
140
141 /**
142  * Register a function that is called when a buffer is received. The
143  * user application is always notified when data frame is received.
144  * Arguments of the callback are:
145  *   - (recv_buf, n>0) if transmission succedded. The first parameter
146  *                     contains the address of the reception buffer and
147  *                     the second contains the number of received bytes.
148  *   - (NULL, err<0)   if the transmission failed (slave not answering
149  *                     or arbiteration lost). The first parameter is
150  *                     NULL and the second contains the error code.
151  */
152 void
153 i2c_register_recv_event(void (*event)(uint8_t *, int8_t))
154 {
155         uint8_t flags;
156         IRQ_LOCK(flags);
157         g_recv_event = event ;
158         IRQ_UNLOCK(flags);
159 }
160
161 /**
162  * Register a function that is called when a byte is received.
163  * Arguments of the callback are: (hwstatus, numbyte, byte).  The user
164  * app can modify the g_recv_size value, which is the number of bytes
165  * to be received in the frame: this can be done by calling
166  * i2c_set_recv_size().
167  */
168 void
169 i2c_register_recv_byte_event(void (*event)(uint8_t, uint8_t, uint8_t))
170 {
171         uint8_t flags;
172         IRQ_LOCK(flags);
173         g_recv_byte_event = event ;
174         IRQ_UNLOCK(flags);
175 }
176
177 /**
178  * register a function that is called when a buffer is sent (or an
179  * error occured while sending) on the i2c bus. The event function is
180  * always called by software if the i2c_send() function returned 0.
181  * The parameter of the event function is the error code:
182  *   -  <0 if 0 byte has been transmitted (arbiteration lost)
183  *   -  Else, the number of transmitted bytes is given, including the
184  *      one that was not acked.
185  */
186 void
187 i2c_register_send_event(void (*event)(int8_t))
188 {
189         uint8_t flags;
190         IRQ_LOCK(flags);
191         g_send_event = event ;
192         IRQ_UNLOCK(flags);
193 }
194
195 /**
196  * Send a buffer. Return 0 if xmit starts correctly.
197  * On error, return < 0.
198  * - If mode is slave, dest_add should be I2C_ADD_MASTER, and transmission
199  *   starts when the master transmits a clk.
200  * - If mode is master and if dest_add != I2C_ADD_MASTER, it will transmit
201  *   a START condition if bus is available (the uc will act as a
202  *   master)
203  * - If mode is master and if dest_add == I2C_ADD_MASTER, the uC will
204  *   act as a slave, and data will be sent when the uC will be
205  *   addressed.
206  * The transmission will be processed with these params until a
207  * i2c_flush() is called.
208  * The 'ctrl' parameter is composed by the flags I2C_CTRL_SYNC and
209  * I2C_CTRL_DONT_RELEASE_BUS
210  */
211 int8_t
212 i2c_send(uint8_t dest_add, uint8_t *buf, uint8_t size, uint8_t ctrl)
213 {
214         uint8_t flags;
215
216         IRQ_LOCK(flags);
217         if (g_mode == I2C_MODE_UNINIT) {
218                 IRQ_UNLOCK(flags);
219                 return -ENXIO;
220         }
221
222         if (g_status & (I2C_STATUS_MASTER_XMIT |
223                         I2C_STATUS_MASTER_RECV |
224                         I2C_STATUS_SLAVE_XMIT_WAIT |
225                         I2C_STATUS_SLAVE_XMIT)) {
226                 IRQ_UNLOCK(flags);
227                 return -EBUSY;
228         }
229
230         if (size > I2C_SEND_BUFFER_SIZE) { /* XXX is size==0 ok ? */
231                 IRQ_UNLOCK(flags);
232                 return -EINVAL;
233         }
234
235         /* bad dest_address */
236         if (g_mode == I2C_MODE_SLAVE) {
237                 if (dest_add != I2C_ADD_MASTER) {
238                         IRQ_UNLOCK(flags);
239                         return -EINVAL;
240                 }
241         }
242         else {
243                 if (dest_add >= I2C_ADD_MASTER) {
244                         IRQ_UNLOCK(flags);
245                         return -EINVAL;
246                 }
247         }
248
249         /* if g_send_buf == buf, it is a resend, so don't update
250          * parameters */
251         if ( g_send_buf != buf ) {
252                 g_dest = dest_add;
253                 g_send_size = size;
254                 g_ctrl = ctrl;
255                 memcpy(g_send_buf, buf, size);
256         }
257
258         /* if destination is not the master, IT MEANS THAT WE ARE THE
259          * MASTER, so we should initiate the transmission */
260         if (dest_add != I2C_ADD_MASTER) {
261                 g_status |= I2C_STATUS_MASTER_XMIT;
262                 TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWSTA);
263         }
264         else {
265                 /* else we are a slave */
266                 g_status |= I2C_STATUS_SLAVE_XMIT_WAIT;
267         }
268
269         IRQ_UNLOCK(flags);
270
271         /* If it is sync mode, wait op_finished. Here we will reset
272          * the status flag to ready */
273         if (ctrl & I2C_CTRL_SYNC) {
274                 while ( 1 ) {
275                         IRQ_LOCK(flags);
276                         if (g_status & I2C_STATUS_OP_FINISHED) {
277                                 g_status &= ~(I2C_STATUS_MASTER_XMIT |
278                                               I2C_STATUS_MASTER_RECV |
279                                               I2C_STATUS_SLAVE_XMIT |
280                                               I2C_STATUS_SLAVE_RECV |
281                                               I2C_STATUS_OP_FINISHED);
282                                 break;
283                         }
284                         IRQ_UNLOCK(flags);
285                 }
286                 IRQ_UNLOCK(flags);
287                 if (g_sync_res == size)
288                         return 0;
289                 return g_sync_res;
290         }
291
292         return -ESUCCESS;
293 }
294
295
296 /**
297  * Resend the same buffer. This call is equivalent to i2c_send() with
298  * the same parameters as the last call. It safe to call it from the
299  * send_event, but else the send buffer may have been overwritten.
300  */
301 int8_t
302 i2c_resend(void)
303 {
304         return i2c_send(g_dest, g_send_buf, g_send_size, g_ctrl);
305 }
306
307 /**
308  * same but for recv
309  */
310 int8_t
311 i2c_rerecv(void)
312 {
313         return i2c_recv(g_dest, g_recv_size, g_ctrl);
314 }
315
316 /**
317  * release the bus
318  */
319 void
320 i2c_release_bus(void)
321 {
322         TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWSTO);
323 }
324
325 /**
326  * recover from error state
327  */
328 void
329 i2c_reset(void)
330 {
331         uint8_t flags;
332
333         IRQ_LOCK(flags);
334         TWCR = 0;
335         g_status = I2C_STATUS_READY;
336 #ifdef CONFIG_MODULE_I2C_MASTER
337         if (g_mode == I2C_MODE_MASTER)
338                 TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
339         else
340 #endif
341                 TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) |
342                         (1<<TWSTO) | (1<<TWEA);
343         IRQ_UNLOCK(flags);
344 }
345
346 /**
347  * In slave mode, it returns error and is useless (all data is
348  * received trough the callback).  In master mode, if dest_add is
349  * between 0 and 127, it will start to read the addressed slave. The
350  * size of the buffer to read must be specified. Return 0 on success.
351  */
352 int8_t i2c_recv(uint8_t dest_add, uint8_t size, uint8_t ctrl)
353 {
354 #ifndef CONFIG_MODULE_I2C_MASTER
355         return -EINVAL;
356 #else
357         uint8_t flags;
358
359         IRQ_LOCK(flags);
360         if (g_mode == I2C_MODE_UNINIT) {
361                 IRQ_UNLOCK(flags);
362                 return -ENXIO;
363         }
364
365         if (g_status != I2C_STATUS_READY) {
366                 IRQ_UNLOCK(flags);
367                 return -EBUSY;
368         }
369
370         if (size > I2C_SEND_BUFFER_SIZE) { /* XXX is size=0 ok ? */
371                 IRQ_UNLOCK(flags);
372                 return -EINVAL;
373         }
374
375         if (g_mode == I2C_MODE_SLAVE || dest_add >= I2C_ADD_MASTER) {
376                 IRQ_UNLOCK(flags);
377                 return -EINVAL;
378         }
379
380         g_ctrl = ctrl;
381         g_recv_size = size;
382         g_status |= I2C_STATUS_MASTER_RECV;
383         g_dest = dest_add ;
384         TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWSTA);
385
386         IRQ_UNLOCK(flags);
387
388         /* If it is sync mode, wait op_finished. Here we will reset
389          * the status flag to ready */
390         if (ctrl & I2C_CTRL_SYNC) {
391                 while ( 1 ) {
392                         IRQ_LOCK(flags);
393                         if (g_status & I2C_STATUS_OP_FINISHED) {
394                                 g_status &= ~(I2C_STATUS_MASTER_XMIT |
395                                               I2C_STATUS_MASTER_RECV |
396                                               I2C_STATUS_SLAVE_XMIT |
397                                               I2C_STATUS_SLAVE_RECV |
398                                               I2C_STATUS_OP_FINISHED);
399                                 break;
400                         }
401                         IRQ_UNLOCK(flags);
402                 }
403                 IRQ_UNLOCK(flags);
404                 if (g_sync_res == size)
405                         return 0;
406                 return g_sync_res;
407         }
408
409         return -ESUCCESS;
410 #endif
411 }
412
413
414 /**
415  * Try to flush the current operation, before it is started. The
416  * i2c module is then tagged as ready. If it returns 0, the flush was
417  * a success, and i2c_send() can be called. Else, it means that
418  * a transmission was running.
419  */
420 int8_t i2c_flush(void)
421 {
422         uint8_t flags;
423         IRQ_LOCK(flags);
424         if ( ! (g_status & I2C_STATUS_SLAVE_XMIT_WAIT) ) {
425                 IRQ_UNLOCK(flags);
426                 return -EBUSY;
427         }
428
429         g_status &= ~(I2C_STATUS_SLAVE_XMIT_WAIT);
430         IRQ_UNLOCK(flags);
431
432         return -ESUCCESS;
433 }
434
435
436 /**
437  * In MASTER RECEIVER mode, it is possible that the user application
438  * does not know the size of the buffer. You can adjust this size
439  * during transmission (generally the size can be specified at the
440  * beginning of received data, so the user app can be notified thanks
441  * to recv_byte_event(). Note that i2c_set_recv_size() function has to
442  * be used with careful, making sure you understand i2c protocol and
443  * this code. Return 0 on success. Note than in SLAVE RECEIVER mode,
444  * you don't have to use this function, because the master can end the
445  * transmission by sending a stop condition on the bus.
446  */
447 uint8_t i2c_set_recv_size(uint8_t size)
448 {
449         uint8_t flags;
450
451         IRQ_LOCK(flags);
452
453         /* check that we are in reveiver mode */
454         if (! (g_status & I2C_STATUS_MASTER_RECV)) {
455                 IRQ_UNLOCK(flags);
456                 return -EBUSY;
457         }
458
459         /* check that specified size is not greater than
460          * I2C_SEND_BUFFER_SIZE. But it must be greater than current
461          * number of received bytes. */
462         /* XXX ? +1 ? */
463         if (size > I2C_SEND_BUFFER_SIZE || size <= g_recv_nbytes) {
464                 IRQ_UNLOCK(flags);
465                 return -EINVAL;
466         }
467
468         g_recv_size = size;
469
470         IRQ_UNLOCK(flags);
471         return -ESUCCESS;
472 }
473
474
475 /**
476  * return the current mode of the i2c module.
477  */
478 i2c_mode_t i2c_mode(void)
479 {
480         return g_mode;
481 }
482
483 /**
484  * return the status of the i2c module.
485  */
486 uint8_t i2c_status(void)
487 {
488         return g_status;
489 }
490
491 /**
492  * Copy the received buffer in the buffer given as parameter. Return
493  * number of copied bytes or < 0 on error.
494  */
495 uint8_t i2c_get_recv_buffer(uint8_t *buf, uint8_t size)
496 {
497         uint8_t flags;
498
499         IRQ_LOCK(flags);
500         /* check that reception is finished */
501         if ( g_status & (I2C_STATUS_MASTER_RECV |
502                           I2C_STATUS_SLAVE_RECV) ) {
503                 IRQ_UNLOCK(flags);
504                 return -EBUSY;
505         }
506
507         if (size > g_recv_nbytes)
508                 size = g_recv_nbytes;
509         memcpy(buf, g_recv_buf, size);
510
511         IRQ_UNLOCK(flags);
512
513         return size;
514 }
515
516 #if I2C_DEBUG == 1
517 void i2c_debug(void)
518 {
519         printf_P(PSTR("mode=0x%x\r\n"), g_mode);
520         printf_P(PSTR("status=0x%x\r\n"), g_status);
521         printf_P(PSTR("ctrl=0x%x\r\n"), g_ctrl);
522         printf_P(PSTR("dst=%d\r\n"), g_dest);
523         printf_P(PSTR("send_nbytes=%d, send_size=%d\r\n"), g_send_nbytes, g_send_size);
524         printf_P(PSTR("recv_nbytes=%d, recv_size=%d\r\n"), g_recv_nbytes, g_recv_size);
525         printf_P(PSTR("prev_twstatus=0x%x\r\n"), g_prev_twstatus);
526         printf_P(PSTR("intr_cpt=%d\r\n"), g_intr_cpt);
527         printf_P(PSTR("prev_status=0x%x\r\n"), g_prev_status);
528         printf_P(PSTR("prev_command=0x%x\r\n"), g_command);
529 }
530 #endif
531
532 /** interrupt ********************************************************/
533
534 /**
535  * Interrupt routing for I2C. Refer to datasheets for more
536  * informations.
537  */
538 SIGNAL(SIG_2WIRE_SERIAL)
539 {
540         uint8_t hard_status;
541         uint8_t command = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
542
543         hard_status = TW_STATUS;
544
545 #if I2C_DEBUG == 1
546         g_prev_twstatus = hard_status;
547         g_intr_cpt++;
548 #endif
549         switch(hard_status) {
550
551 #ifdef CONFIG_MODULE_I2C_MASTER
552         case TW_START:
553         case TW_REP_START:
554                 /* a start has been transmitted, transmit SLA+W which is :
555                  * b7-1: slave address
556                  * b0  : 0 (write operation) or 1 (read) */
557                 if (g_status & I2C_STATUS_MASTER_RECV) {
558                         TWDR = (g_dest << 1) | (0x01);
559                         g_recv_nbytes = 0;
560                 }
561                 else {
562                         TWDR = (g_dest << 1);
563                         g_send_nbytes = 0;
564                 }
565                 break;
566
567
568                 /* MASTER TRANSMITTER */
569
570         case TW_MT_SLA_ACK:
571                 /* the slave is there. start sending data */
572                 TWDR = g_send_buf[g_send_nbytes++];
573                 break;
574
575         case TW_MT_SLA_NACK:
576                 /* the slave does not answer, send a stop condition */
577                 g_send_nbytes = -ENOENT;
578                 g_status |= (I2C_STATUS_OP_FINISHED | I2C_STATUS_NEED_XMIT_EVT);
579                 break;
580
581         case TW_MT_DATA_ACK: /* 0x28 */
582                 /* we transmitted data with success, send next one or
583                  * stop condition if there is no more data */
584                 if (g_send_nbytes >= g_send_size) {
585                         g_status |= (I2C_STATUS_OP_FINISHED | I2C_STATUS_NEED_XMIT_EVT);
586                 }
587                 else {
588                         TWDR = g_send_buf[g_send_nbytes++];
589                 }
590                 break;
591
592         case TW_MT_DATA_NACK:
593                 /* we transmitted data but slave sent us a NACK.
594                  * Notify the number of bytes sent, including the one
595                  * that were not acked, and send a stop condition */
596                 g_status |= (I2C_STATUS_OP_FINISHED | I2C_STATUS_NEED_XMIT_EVT);
597                 break;
598
599
600                 /* MASTER RECEIVER */
601
602         case TW_MR_SLA_ACK:
603                 /* the slave is there, we know that we have enough
604                  * room in buffer because it is the 1st byte. If
605                  * there's only 1 byte to receive, don't set TWEA */
606                 if (g_recv_size > 1)
607                         command |= (1<<TWEA);
608                 break;
609
610         case TW_MR_SLA_NACK:
611                 /* the slave does not answer, send a stop condition */
612                 g_recv_nbytes = -ENOENT;
613                 g_status |= (I2C_STATUS_OP_FINISHED | I2C_STATUS_NEED_RECV_EVT);
614                 break;
615
616         case TW_MR_DATA_ACK:
617                 /* receive data */
618                 if (g_recv_nbytes < g_recv_size) {
619                         g_recv_buf[g_recv_nbytes] = TWDR;
620
621                         if(g_recv_byte_event)
622                                 g_recv_byte_event(hard_status, g_recv_nbytes, g_recv_buf[g_recv_nbytes]);
623
624                         g_recv_nbytes++;
625                 }
626                 /* More than one byte remaining -> set TWEA */
627                 if (g_recv_nbytes < g_recv_size) {
628                         command |= (1<<TWEA);
629                 }
630                 break;
631
632         case TW_MR_DATA_NACK:
633                 /* we received the last byte */
634                 if (g_recv_nbytes < g_recv_size) {
635                         g_recv_buf[g_recv_nbytes] = TWDR;
636
637                         if(g_recv_byte_event)
638                                 g_recv_byte_event(hard_status, g_recv_nbytes, g_recv_buf[g_recv_nbytes]);
639                         g_recv_nbytes ++;
640                 }
641                 g_status |= (I2C_STATUS_OP_FINISHED | I2C_STATUS_NEED_RECV_EVT);
642                 break;
643
644
645                 /* MASTER TRANSMITTER or MASTER RECEIVER */
646
647         case TW_MT_ARB_LOST:
648                 /* arbitration lost, notify application */
649                 /* XXX here we may have to change status flags ? */
650                 if (g_status & I2C_STATUS_MASTER_XMIT) {
651                         g_recv_nbytes = -EAGAIN;
652                         g_status |= I2C_STATUS_NEED_RECV_EVT;
653                 }
654                 else if (g_status & I2C_STATUS_MASTER_RECV) {
655                         g_send_nbytes = -EAGAIN;
656                         g_status |= I2C_STATUS_NEED_XMIT_EVT;
657                 }
658                 /* g_status |= I2C_STATUS_OP_FINISHED; */ /* ?? or not ? */
659                 break;
660
661 #endif
662
663
664                 /* SLAVE RECEIVER */
665
666         case TW_SR_ARB_LOST_SLA_ACK:
667         case TW_SR_ARB_LOST_GCALL_ACK:
668         case TW_SR_GCALL_ACK:
669         case TW_SR_SLA_ACK:
670                 /* slave is addressed (in general call or not, and
671                  * after arbiteration lost or not) */
672                 g_recv_nbytes = 0;
673                 g_recv_size = I2C_RECV_BUFFER_SIZE;
674                 g_status |= I2C_STATUS_SLAVE_RECV;
675                 command |= (1<<TWEA);
676                 break;
677
678         case TW_SR_DATA_ACK:
679         case TW_SR_GCALL_DATA_ACK:
680                 /* receive data, the following test should always be
681                  * true */
682                 if (g_recv_nbytes < g_recv_size) {
683                         g_recv_buf[g_recv_nbytes] = TWDR;
684                         if(g_recv_byte_event)
685                                 g_recv_byte_event(hard_status, g_recv_nbytes, g_recv_buf[g_recv_nbytes]);
686                         g_recv_nbytes++;
687                 }
688                 /* if there's more than one byte left in buffer, send
689                  * TWEA */
690                 if (g_recv_nbytes < g_recv_size) {
691                         command |= (1<<TWEA);
692                 }
693                 break;
694
695         case TW_SR_GCALL_DATA_NACK:
696         case TW_SR_DATA_NACK:
697                 /* receive last data byte (our buffer is full) */
698                 if (g_recv_nbytes < g_recv_size) {
699                         g_recv_buf[g_recv_nbytes] = TWDR;
700
701                         if(g_recv_byte_event)
702                                 g_recv_byte_event(hard_status, g_recv_nbytes, g_recv_buf[g_recv_nbytes]);
703                         g_recv_nbytes++;
704                 }
705                 break;
706
707         case TW_SR_STOP:
708                 /* the master sent a stop condition, notify app */
709                 g_status |= (I2C_STATUS_OP_FINISHED | I2C_STATUS_NEED_RECV_EVT);
710                 break;
711
712
713                 /* SLAVE TRANSMITTER */
714
715         case TW_ST_ARB_LOST_SLA_ACK:
716         case TW_ST_SLA_ACK:
717                 /* slave is addressed. If it is not ready, send a 0 as
718                  * last byte. */
719                 g_send_nbytes = 0;
720                 if (! (g_status & I2C_STATUS_SLAVE_XMIT_WAIT)) {
721                         TWDR = 0;
722                         g_send_size=0;
723                 }
724                 /* else:
725                  * if there is only 1 byte to transmit, we don't
726                  * need to send ack, else set TWEA. */
727                 else {
728                         if (g_send_size > 1) {
729                                 command |= (1<<TWEA);
730                         }
731                         TWDR = g_send_buf[g_send_nbytes++];
732                 }
733                 g_status &= ~(I2C_STATUS_SLAVE_XMIT_WAIT);
734                 g_status |= I2C_STATUS_SLAVE_XMIT;
735                 break;
736
737         case TW_ST_DATA_ACK:
738                 /* transmitting data, if there is more than one byte
739                  * to send, send ack */
740                 if (g_send_size > g_send_nbytes + 1)
741                         command |= (1<<TWEA);
742                 TWDR = g_send_buf[g_send_nbytes++];
743                 break;
744
745         case TW_ST_DATA_NACK:
746                 /* notify app that we send the frame */
747                 g_status |= (I2C_STATUS_OP_FINISHED | I2C_STATUS_NEED_XMIT_EVT);
748                 break;
749
750
751         case TW_ST_LAST_DATA:
752                 /* last data transmitted, notify app XXX (not very sure) */
753                 g_status |= (I2C_STATUS_OP_FINISHED | I2C_STATUS_NEED_XMIT_EVT);
754                 break;
755
756
757                 /* COMMON */
758
759         case TW_BUS_ERROR:
760                 command |= (1<<TWSTO);
761                 g_status |= I2C_STATUS_OP_FINISHED;
762                 break;
763
764         default :
765                 /* default ... what can we do ? */
766                 g_status |= I2C_STATUS_OP_FINISHED;
767                 break;
768
769         }
770
771 #if I2C_DEBUG == 1
772         g_prev_status = g_status;
773 #endif
774
775         /* transmission finished */
776         if (g_status & I2C_STATUS_OP_FINISHED) {
777                 /* if it is not a synchronous op, we should be aware
778                  * of next SLA+RW if we are a slave or multimaster */
779 #ifdef CONFIG_MODULE_I2C_MASTER
780                 if (g_mode != I2C_MODE_MASTER) {
781                         command |= (1<<TWEA);
782                 }
783                 else if ( ! (g_ctrl & I2C_CTRL_DONT_RELEASE_BUS) ) {
784                         /* do it only if we want to release bus */
785                         command |= (1<<TWSTO);
786                 }
787 #else /* CONFIG_MODULE_I2C_MASTER */
788                 command |= (1<<TWEA);
789 #endif
790                 /* Remove current op if !sync, else it is done in the
791                  * i2c_send/recv func */
792                 if ( ! (g_ctrl & I2C_CTRL_SYNC) ) {
793                         g_status &= ~(I2C_STATUS_MASTER_XMIT |
794                                       I2C_STATUS_MASTER_RECV |
795                                       I2C_STATUS_SLAVE_XMIT |
796                                       I2C_STATUS_SLAVE_RECV |
797                                       I2C_STATUS_OP_FINISHED);
798                 }
799         }
800
801         /* Callback events if necessary (if not sync) */
802         if ( ! (g_ctrl & I2C_CTRL_SYNC) ) {
803                 if ( (g_status & I2C_STATUS_NEED_XMIT_EVT) && g_send_event) {
804                         g_send_event(g_send_nbytes);
805                 }
806                 if ( (g_status & I2C_STATUS_NEED_RECV_EVT) && g_recv_event) {
807                         g_recv_event(g_recv_buf, g_recv_nbytes);
808                 }
809         }
810         else {
811                 if ( g_status & (I2C_STATUS_MASTER_XMIT | I2C_STATUS_SLAVE_XMIT) )
812                         g_sync_res = g_send_nbytes;
813                 else
814                         g_sync_res = g_recv_nbytes;
815         }
816         g_status &= ~(I2C_STATUS_NEED_XMIT_EVT | I2C_STATUS_NEED_RECV_EVT);
817
818 #if I2C_DEBUG == 1
819         g_command = command;
820 #endif
821
822         /* if a command (repeated start) has been sent in the callback
823          * (by calling i2c_send() or i2c_recv(), we don't need to
824          * send it (we are back in MASTER_SEND or MASTER_RECV mode) */
825         if (TWCR & (1<<TWINT))
826                 TWCR = command;
827 }