Context Navigation

source: rtems/c/src/lib/libbsp/powerpc/gen5200/i2c/mpc5200mbus.c @ efdfd48

4.104.115

Last change on this file since efdfd48 was efdfd48, checked in by Ralf Corsepius <ralf.corsepius@…>, on 11/29/09 at 15:27:07
Whitespace removal.
Property mode set to `100644`
File size: 21.3 KB

Line
1	/===============================================================\
2	\| Project: RTEMS generic MPC5200 BSP \|
3	+-----------------------------------------------------------------+
4	\| Copyright (c) 2005 \|
5	\| Embedded Brains GmbH \|
6	\| Obere Lagerstr. 30 \|
7	\| D-82178 Puchheim \|
8	\| Germany \|
9	\| rtems@embedded-brains.de \|
10	+-----------------------------------------------------------------+
11	\| The license and distribution terms for this file may be \|
12	\| found in the file LICENSE in this distribution or at \|
13	\| \|
14	\| http://www.rtems.com/license/LICENSE. \|
15	\| \|
16	+-----------------------------------------------------------------+
17	\| MBUS module (I2C bus) driver \|
18	+-----------------------------------------------------------------+
19	\| This file has been adapted from an existing source code file, \|
20	\| see the original file header below for reference \|
21	\===============================================================/
22
23	/* MCF5206e MBUS module (I2C bus) driver
24	*
25	* Copyright (C) 2000 OKTET Ltd., St.-Petersburg, Russia
26	* Author: Victor V. Vengerov <vvv@oktet.ru>
27	*
28	* The license and distribution terms for this file may be
29	* found in the file LICENSE in this distribution or at
30	*
31	* http://www.rtems.com/license/LICENSE.
32	*
33	* @(#) mcfmbus.c,v 1.4 2004/03/31 01:59:32 ralf Exp
34	*/
35	#include "mpc5200mbus.h"
36	#include "../include/mpc5200.h"
37	#include <bsp/irq.h>
38	#include "../include/i2c.h"
39
40	/* Events of I2C machine */
41	typedef enum i2c_event {
42	EVENT_NONE, /* Spurious event */
43	EVENT_TRANSFER, /* Start new transfer */
44	EVENT_NEXTMSG, /* Start processing of next message in transfer */
45	EVENT_ACK, /* Sending finished with ACK */
46	EVENT_NACK, /* Sending finished with NACK */
47	EVENT_TIMEOUT, /* Timeout occured */
48	EVENT_DATA_RECV, /* Data received */
49	EVENT_ARB_LOST, /* Arbitration lost */
50	EVENT_SLAVE /* Addressed as a slave */
51	} i2c_event;
52
53	/* Auxillary primitives */
54
55	/* Change state of finite state machine */
56	#define next_state(bus,new_state) \
57	do { \
58	(bus)->state = (new_state); \
59	} while (0)
60
61	/* Initiate start condition on the I2C bus */
62	#define mpc5200mbus_start(bus) \
63	do { \
64	mpc5200.i2c_regs[bus->bus_idx].mcr \|= MPC5200_I2C_MCR_MSTA; \
65	} while (0)
66
67	/* Initiate stop condition on the I2C bus */
68	#define mpc5200mbus_stop(bus) \
69	do { \
70	mpc5200.i2c_regs[bus->bus_idx].mcr &= ~MPC5200_I2C_MCR_MSTA; \
71	} while (0)
72
73	/* Initiate repeat start condition on the I2C bus */
74	#define mpc5200mbus_rstart(bus) \
75	do { \
76	mpc5200.i2c_regs[bus->bus_idx].mcr \|= MPC5200_I2C_MCR_RSTA; \
77	} while (0)
78
79	/* Send byte to the bus */
80	#define mpc5200mbus_send(bus,byte) \
81	do { \
82	mpc5200.i2c_regs[bus->bus_idx].mdr = (byte); \
83	} while (0)
84
85	/* Set transmit mode */
86	#define mpc5200mbus_tx_mode(bus) \
87	do { \
88	mpc5200.i2c_regs[bus->bus_idx].mcr \|= MPC5200_I2C_MCR_MTX; \
89	} while (0)
90
91	/* Set receive mode */
92	#define mpc5200mbus_rx_mode(bus) \
93	do { \
94	mpc5200.i2c_regs[bus->bus_idx].mcr &= ~MPC5200_I2C_MCR_MTX; \
95	(void)mpc5200.i2c_regs[bus->bus_idx].mdr; \
96	} while (0)
97
98
99	/* Transmit acknowledge when byte received */
100	#define mpc5200mbus_send_ack(bus) \
101	do { \
102	mpc5200.i2c_regs[bus->bus_idx].mcr &= ~MPC5200_I2C_MCR_TXAK; \
103	} while (0)
104
105	/* DO NOT transmit acknowledge when byte received */
106	#define mpc5200mbus_send_nack(bus) \
107	do { \
108	mpc5200.i2c_regs[bus->bus_idx].mcr \|= MPC5200_I2C_MCR_TXAK; \
109	} while (0)
110
111	#define mpc5200mbus_error(bus,err_status) \
112	do { \
113	do { \
114	(bus)->cmsg->status = (err_status); \
115	(bus)->cmsg++; \
116	} while (((bus)->cmsg - (bus)->msg < (bus)->nmsg) && \
117	((bus)->cmsg->flags & I2C_MSG_ERRSKIP)); \
118	bus->cmsg--; \
119	} while (0)
120
121	/* mpc5200mbus_get_event --
122	* Read MBUS module status register, determine interrupt reason and
123	* return appropriate event.
124	*
125	* PARAMETERS:
126	* bus - pointer to MBUS module descriptor structure
127	*
128	* RETURNS:
129	* event code
130	*/
131	static i2c_event
132	mpc5200mbus_get_event(mpc5200mbus *bus)
133	{
134	i2c_event event;
135	uint8_t status, control;
136	rtems_interrupt_level level;
137	rtems_interrupt_disable(level);
138	status = mpc5200.i2c_regs[bus->bus_idx].msr;
139	control = mpc5200.i2c_regs[bus->bus_idx].mcr;
140	if (status & MPC5200_I2C_MSR_MIF) /* Interrupt occured */
141	{
142	if (status & MPC5200_I2C_MSR_MAAS)
143	{
144	event = EVENT_SLAVE;
145	mpc5200.i2c_regs[bus->bus_idx].mcr = control; /* To clear Addressed As Slave
146	condition */
147	}
148	else if (status & MPC5200_I2C_MSR_MAL) /* Arbitration lost */
149	{
150	mpc5200.i2c_regs[bus->bus_idx].msr = status & ~MPC5200_I2C_MSR_MAL;
151	event = EVENT_ARB_LOST;
152	}
153	else if (control & MPC5200_I2C_MCR_MTX) /* Trasmit mode */
154	{
155	if (status & MPC5200_I2C_MSR_RXAK)
156	event = EVENT_NACK;
157	else
158	event = EVENT_ACK;
159	}
160	else /* Received */
161	{
162	event = EVENT_DATA_RECV;
163	}
164
165	/* Clear interrupt condition */
166	mpc5200.i2c_regs[bus->bus_idx].msr &= ~MPC5200_I2C_MSR_MIF;
167	}
168	else
169	{
170	event = EVENT_NONE;
171	}
172	rtems_interrupt_enable(level);
173	return event;
174	}
175
176	static void
177	mpc5200mbus_machine_error(mpc5200mbus *bus, i2c_event event)
178	{
179	return;
180	}
181
182	/* mpc5200mbus_machine --
183	* finite state machine for I2C bus protocol
184	*
185	* PARAMETERS:
186	* bus - pointer to ColdFire MBUS descriptor structure
187	* event - I2C event
188	*
189	* RETURNS:
190	* none
191	*/
192	static void
193	mpc5200mbus_machine(mpc5200mbus *bus, i2c_event event)
194	{
195	uint8_t b;
196	switch (bus->state)
197	{
198
199	case STATE_UNINITIALIZED:
200	/* this should never happen. */
201	mpc5200mbus_machine_error(bus, event);
202	break;
203	case STATE_IDLE:
204	switch (event)
205	{
206	case EVENT_NEXTMSG: /* Start new message processing */
207	bus->cmsg++;
208	/* FALLTHRU */
209
210	case EVENT_TRANSFER: /* Initiate new transfer */
211	if (bus->cmsg - bus->msg >= bus->nmsg)
212	{
213	mpc5200mbus_stop(bus);
214	next_state(bus, STATE_IDLE);
215	bus->msg = bus->cmsg = NULL;
216	bus->nmsg = bus->byte = 0;
217	bus->done(bus->done_arg_ptr);
218	break;
219	}
220
221	/* Initiate START or REPEATED START condition on the bus */
222	if (event == EVENT_TRANSFER)
223	{
224	mpc5200mbus_start(bus);
225	}
226	else /* (event == EVENT_NEXTMSG) */
227	{
228	mpc5200mbus_rstart(bus);
229	}
230
231	bus->byte = 0;
232	mpc5200mbus_tx_mode(bus);
233
234	/* Initiate slave address sending */
235	if (bus->cmsg->flags & I2C_MSG_ADDR_10)
236	{
237	i2c_address a = bus->cmsg->addr;
238	b = 0xf0 \| (((a >> 8) & 0x03) << 1);
239	if (bus->cmsg->flags & I2C_MSG_WR)
240	{
241	mpc5200mbus_send(bus, b);
242	next_state(bus, STATE_ADDR_1_W);
243	}
244	else
245	{
246	mpc5200mbus_send(bus, b \| 1);
247	next_state(bus, STATE_ADDR_1_R);
248	}
249	}
250	else
251	{
252	b = (bus->cmsg->addr & ~0x01);
253
254	if (bus->cmsg->flags & I2C_MSG_WR)
255	{
256	next_state(bus, STATE_SENDING);
257	}
258	else
259	{
260	next_state(bus, STATE_ADDR_7);
261	b \|= 1;
262	}
263
264	mpc5200mbus_send(bus, b);
265	}
266	break;
267
268	default:
269	mpc5200mbus_machine_error(bus, event);
270	break;
271	}
272	break;
273
274	case STATE_ADDR_7:
275	switch (event)
276	{
277	case EVENT_ACK:
278	mpc5200mbus_rx_mode(bus);
279	if (bus->cmsg->len <= 1)
280	mpc5200mbus_send_nack(bus);
281	else
282	mpc5200mbus_send_ack(bus);
283	next_state(bus, STATE_RECEIVING);
284	break;
285
286	case EVENT_NACK:
287	mpc5200mbus_error(bus, I2C_NO_DEVICE);
288	next_state(bus, STATE_IDLE);
289	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
290	break;
291
292	case EVENT_ARB_LOST:
293	mpc5200mbus_error(bus, I2C_ARBITRATION_LOST);
294	next_state(bus, STATE_IDLE);
295	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
296	break;
297
298	default:
299	mpc5200mbus_machine_error(bus, event);
300	break;
301	}
302	break;
303
304	case STATE_ADDR_1_R:
305	case STATE_ADDR_1_W:
306	switch (event)
307	{
308	case EVENT_ACK:
309	{
310	uint8_t b = (bus->cmsg->addr & 0xff);
311	mpc5200mbus_send(bus, b);
312	if (bus->state == STATE_ADDR_1_W)
313	{
314	next_state(bus, STATE_SENDING);
315	}
316	else
317	{
318	i2c_address a;
319	mpc5200mbus_rstart(bus);
320	mpc5200mbus_tx_mode(bus);
321	a = bus->cmsg->addr;
322	b = 0xf0 \| (((a >> 8) & 0x03) << 1) \| 1;
323	mpc5200mbus_send(bus, b);
324	next_state(bus, STATE_ADDR_7);
325	}
326	break;
327	}
328
329	case EVENT_NACK:
330	mpc5200mbus_error(bus, I2C_NO_DEVICE);
331	next_state(bus, STATE_IDLE);
332	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
333	break;
334
335	case EVENT_ARB_LOST:
336	mpc5200mbus_error(bus, I2C_ARBITRATION_LOST);
337	next_state(bus, STATE_IDLE);
338	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
339	break;
340
341	default:
342	mpc5200mbus_machine_error(bus, event);
343	break;
344	}
345	break;
346
347	case STATE_SENDING:
348	switch (event)
349	{
350	case EVENT_ACK:
351	if (bus->byte == bus->cmsg->len)
352	{
353	next_state(bus, STATE_IDLE);
354	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
355	}
356	else
357	{
358	mpc5200mbus_send(bus, bus->cmsg->buf[bus->byte++]);
359	next_state(bus, STATE_SENDING);
360	}
361	break;
362
363	case EVENT_NACK:
364	if (bus->byte == 0)
365	{
366	mpc5200mbus_error(bus, I2C_NO_DEVICE);
367	}
368	else
369	{
370	mpc5200mbus_error(bus, I2C_NO_ACKNOWLEDGE);
371	}
372	next_state(bus, STATE_IDLE);
373	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
374	break;
375
376	case EVENT_ARB_LOST:
377	mpc5200mbus_error(bus, I2C_ARBITRATION_LOST);
378	next_state(bus, STATE_IDLE);
379	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
380	break;
381
382	default:
383	mpc5200mbus_machine_error(bus, event);
384	break;
385
386	}
387	break;
388
389	case STATE_RECEIVING:
390	switch (event)
391	{
392	case EVENT_DATA_RECV:
393	if (bus->cmsg->len - bus->byte <= 2)
394	{
395	mpc5200mbus_send_nack(bus);
396	if (bus->cmsg->len - bus->byte <= 1)
397	{
398	if (bus->cmsg - bus->msg + 1 == bus->nmsg)
399	mpc5200mbus_stop(bus);
400	else
401	mpc5200mbus_rstart(bus);
402	}
403	}
404	else
405	{
406	mpc5200mbus_send_ack(bus);
407	}
408	bus->cmsg->buf[bus->byte++] = mpc5200.i2c_regs[bus->bus_idx].mdr;
409	if (bus->cmsg->len == bus->byte)
410	{
411	next_state(bus,STATE_IDLE);
412	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
413	}
414	else
415	{
416	next_state(bus,STATE_RECEIVING);
417	}
418	break;
419
420	case EVENT_ARB_LOST:
421	mpc5200mbus_error(bus, I2C_ARBITRATION_LOST);
422	next_state(bus, STATE_IDLE);
423	mpc5200mbus_machine(bus, EVENT_NEXTMSG);
424	break;
425
426	default:
427	mpc5200mbus_machine_error(bus, event);
428	break;
429	}
430	break;
431	}
432	}
433
434	/* mpc5200mbus_interrupt_handler --
435	* MBUS module interrupt handler routine
436	*
437	* PARAMETERS:
438	* handle: pointer to mbus structure
439	*
440	* RETURNS:
441	* none
442	*/
443	void mpc5200mbus_interrupt_handler(rtems_irq_hdl_param handle)
444	{
445	i2c_event event;
446	mpc5200mbus *bus = handle;
447
448	event = mpc5200mbus_get_event(bus);
449	/*
450	* clear interrupt bit
451	*/
452	mpc5200.i2c_regs[bus->bus_idx].msr &= ~MPC5200_I2C_MSR_MIF;
453
454	mpc5200mbus_machine(bus, event);
455	}
456
457	/*
458	* mpc5200_mbus_irq_enable
459	* enable irq for mbus
460	*/
461	void mpc5200mbus_irq_enable(const rtems_irq_connect_data* ptr)
462	{
463	int minor = ((mpc5200mbus*)(ptr->handle))->bus_idx;
464
465	mpc5200.i2c_regs[minor].mcr \|= MPC5200_I2C_MCR_MIEN;
466	}
467
468	/*
469	* mpc5200_mbus_irq_disable
470	* enable irq for mbus
471	*/
472	void mpc5200mbus_irq_disable(const rtems_irq_connect_data* ptr)
473	{
474	int minor = ((mpc5200mbus*)(ptr->handle))->bus_idx;
475
476	mpc5200.i2c_regs[minor].mcr &= ~MPC5200_I2C_MCR_MIEN;
477	}
478
479	/*
480	* mpc5200_mbus_isOn
481	* check, whether irq is enabled
482	*/
483	int mpc5200mbus_irq_isOn(const rtems_irq_connect_data* ptr)
484	{
485	int minor = ((mpc5200mbus*)(ptr->handle))->bus_idx;
486
487	return (0 != (mpc5200.i2c_regs[minor].mcr & MPC5200_I2C_MCR_MIEN));
488	}
489
490	/* mpc5200mbus_poll --
491	* MBUS module poll routine; used to poll events when I2C driver
492	* operates in poll-driven mode.
493	*
494	* PARAMETERS:
495	* none
496	*
497	* RETURNS:
498	* none
499	*/
500	void
501	mpc5200mbus_poll(mpc5200mbus *bus)
502	{
503	i2c_event event;
504	event = mpc5200mbus_get_event(bus);
505	if (event != EVENT_NONE)
506	mpc5200mbus_machine(bus, event);
507	}
508
509	/* mpc5200mbus_select_clock_divider --
510	* Select divider for system clock which is used for I2C bus clock
511	* generation. Not each divider can be selected for I2C bus; this
512	* function select nearest larger or equal divider.
513	*
514	* PARAMETERS:
515	* i2c_bus - pointer to the bus descriptor structure
516	* divider - system frequency divider for I2C serial clock.
517	* RETURNS:
518	* RTEMS_SUCCESSFUL, if operation performed successfully, or
519	* RTEMS error code when failed.
520	*/
521	rtems_status_code
522	mpc5200mbus_select_clock_divider(mpc5200mbus *bus, int divider)
523	{
524	int i;
525	int mbc;
526	struct {
527	int divider;
528	int mbc;
529	} dividers[] ={
530	{ 20, 0x20 }, { 22, 0x21 }, { 24, 0x22 }, { 26, 0x23 },
531	{ 28, 0x00 }, { 30, 0x01 }, { 32, 0x25 }, { 34, 0x02 },
532	{ 36, 0x26 }, { 40, 0x03 }, { 44, 0x04 }, { 48, 0x05 },
533	{ 56, 0x06 }, { 64, 0x2a }, { 68, 0x07 }, { 72, 0x2B },
534	{ 80, 0x08 }, { 88, 0x09 }, { 96, 0x2D }, { 104, 0x0A },
535	{ 112, 0x2E }, { 128, 0x0B }, { 144, 0x0C }, { 160, 0x0D },
536	{ 192, 0x0E }, { 224, 0x32 }, { 240, 0x0F }, { 256, 0x33 },
537	{ 288, 0x10 }, { 320, 0x11 }, { 384, 0x12 }, { 448, 0x36 },
538	{ 480, 0x13 }, { 512, 0x37 }, { 576, 0x14 }, { 640, 0x15 },
539	{ 768, 0x16 }, { 896, 0x3A }, { 960, 0x17 }, { 1024, 0x3B },
540	{ 1152, 0x18 }, { 1280, 0x19 }, { 1536, 0x1A }, { 1792, 0x3E },
541	{ 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D },
542	{ 3072, 0x1E }, { 3840, 0x1F }
543	};
544
545	if (bus == NULL)
546	return RTEMS_INVALID_ADDRESS;
547
548	for (i = 0, mbc = -1; i < sizeof(dividers)/sizeof(dividers[0]); i++)
549	{
550	mbc = dividers[i].mbc;
551	if (dividers[i].divider >= divider)
552	{
553	break;
554	}
555	}
556	mpc5200.i2c_regs[bus->bus_idx].mfdr = mbc;
557	return RTEMS_SUCCESSFUL;
558	}
559
560	/* mpc5200mbus_initialize --
561	* Initialize MPC5200 MBUS I2C bus controller.
562	*
563	* PARAMETERS:
564	* i2c_bus - pointer to the bus descriptor structure
565	*
566	* RETURNS:
567	* RTEMS_SUCCESSFUL, or RTEMS error code when initialization failed.
568	*/
569	rtems_status_code
570	mpc5200mbus_initialize(mpc5200mbus *i2c_bus)
571	{
572	rtems_interrupt_level level;
573	rtems_status_code sc;
574	rtems_irq_connect_data mbusIrqData;
575
576	if (i2c_bus == NULL)
577	return RTEMS_INVALID_ADDRESS;
578
579	if (i2c_bus->state != STATE_UNINITIALIZED) /* Check if already initialized */
580	return RTEMS_RESOURCE_IN_USE;
581
582	i2c_bus->state = STATE_IDLE;
583	i2c_bus->msg = NULL;
584	i2c_bus->cmsg = NULL;
585	i2c_bus->nmsg = 0;
586	i2c_bus->byte = 0;
587
588	/*
589	* install interrupt handler
590	*/
591	mbusIrqData.on = mpc5200mbus_irq_enable;
592	mbusIrqData.off = mpc5200mbus_irq_disable;
593	mbusIrqData.isOn = mpc5200mbus_irq_isOn;
594	mbusIrqData.handle = (rtems_irq_hdl_param)i2c_bus;
595	mbusIrqData.hdl = mpc5200mbus_interrupt_handler;
596	switch(i2c_bus->bus_idx) {
597	case 0:
598	mbusIrqData.name = BSP_SIU_IRQ_I2C1;
599	break;
600	case 1:
601	mbusIrqData.name = BSP_SIU_IRQ_I2C2;
602	break;
603	}
604	if (!BSP_install_rtems_irq_handler (&mbusIrqData)) {
605	sc = RTEMS_UNSATISFIED;
606	return sc;
607	}
608
609	rtems_interrupt_disable(level);
610
611	mpc5200.i2c_regs[i2c_bus->bus_idx].mcr &= ~MPC5200_I2C_MCR_MEN;
612	mpc5200.i2c_regs[i2c_bus->bus_idx].msr = 0;
613	mpc5200.i2c_regs[i2c_bus->bus_idx].mdr = 0x1F; /* Maximum possible divider is 3840 */
614	mpc5200.i2c_regs[i2c_bus->bus_idx].mcr \|= MPC5200_I2C_MCR_MEN;
615
616	rtems_interrupt_enable(level);
617
618	return RTEMS_SUCCESSFUL;
619	}
620
621	/* mpc5200mbus_i2c_transfer --
622	* Initiate multiple-messages transfer over I2C bus via ColdFire MBUS
623	* controller.
624	*
625	* PARAMETERS:
626	* bus - pointer to MBUS controller descriptor
627	* nmsg - number of messages
628	* msg - pointer to messages array
629	* done - function which is called when transfer is finished
630	* done_arg_ptr - arbitrary argument pointer passed to done funciton
631	*
632	* RETURNS:
633	* RTEMS_SUCCESSFUL if transfer initiated successfully, or error
634	* code when failed.
635	*/
636	rtems_status_code
637	mpc5200mbus_i2c_transfer(mpc5200mbus bus, int nmsg, i2c_message msg,
638	i2c_transfer_done done, void *done_arg_ptr)
639	{
640	if (bus->state == STATE_UNINITIALIZED)
641	return RTEMS_NOT_CONFIGURED;
642
643	bus->done = done;
644	bus->done_arg_ptr = done_arg_ptr;
645	bus->cmsg = bus->msg = msg;
646	bus->nmsg = nmsg;
647	bus->byte = 0;
648	bus->state = STATE_IDLE;
649	mpc5200mbus_machine(bus, EVENT_TRANSFER);
650	return RTEMS_SUCCESSFUL;
651	}
652
653
654	/* mpc5200mbus_i2c_done --
655	* Close ColdFire MBUS I2C bus controller and release all resources.
656	*
657	* PARAMETERS:
658	* bus - pointer to MBUS controller descriptor
659	*
660	* RETURNS:
661	* RTEMS_SUCCESSFUL, if transfer initiated successfully, or error
662	* code when failed.
663	*/
664	rtems_status_code
665	mpc5200mbus_i2c_done(mpc5200mbus *i2c_bus)
666	{
667	rtems_status_code sc = RTEMS_SUCCESSFUL;
668
669	if (i2c_bus->state == STATE_UNINITIALIZED)
670	return RTEMS_NOT_CONFIGURED;
671
672	mpc5200.i2c_regs[i2c_bus->bus_idx].mcr = 0;
673
674	return sc;
675	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: