aboutsummaryrefslogtreecommitdiff
path: root/arch/powerpc/cpu/mpc8220/i2cCore.c
blob: b89ad034f4918248876e42e68cc36a9e846199fd (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
/* I2cCore.c - MPC8220 PPC I2C Library */

/* Copyright 2004      Freescale Semiconductor, Inc. */

/*
modification history
--------------------
01c,29jun04,tcl	 1.3	removed CR. Added two bytes offset support.
01b,19jan04,tcl	 1.2	removed i2cMsDelay and sysDecGet. renamed i2cMsDelay
			back to sysMsDelay
01a,19jan04,tcl	 1.1	created and seperated from i2c.c
*/

/*
DESCRIPTION
This file contain I2C low level handling library functions
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vxWorks.h>
#include <sysLib.h>
#include <iosLib.h>
#include <logLib.h>
#include <tickLib.h>

/* BSP Includes */
#include "config.h"
#include "mpc8220.h"
#include "i2cCore.h"

#ifdef DEBUG_I2CCORE
int I2CCDbg = 0;
#endif

#define ABS(x)	((x < 0)? -x : x)

char *I2CERR[16] = {
	"Transfer in Progress\n",	/* 0 */
	"Transfer complete\n",
	"Not Addressed\n",		/* 2 */
	"Addressed as a slave\n",
	"Bus is Idle\n",		/* 4 */
	"Bus is busy\n",
	"Arbitration Lost\n",		/* 6 */
	"Arbitration on Track\n",
	"Slave receive, master writing to slave\n",	/* 8 */
	"Slave transmit, master reading from slave\n",
	"Interrupt is pending\n",	/* 10 */
	"Interrupt complete\n",
	"Acknowledge received\n",	/* 12 */
	"No acknowledge received\n",
	"Unknown status\n",		/* 14 */
	"\n"
};

/******************************************************************************
 *
 * chk_status - Check I2C status bit
 *
 * RETURNS: OK, or ERROR if the bit encounter
 *
 */

STATUS chk_status (PSI2C pi2c, UINT8 sta_bit, UINT8 truefalse)
{
	int i, status = 0;

	for (i = 0; i < I2C_POLL_COUNT; i++) {
		if ((pi2c->sr & sta_bit) == (truefalse ? sta_bit : 0))
			return (OK);
	}

	I2CCDBG (L2, ("--- sr %x stabit %x truefalse %d\n",
		      pi2c->sr, sta_bit, truefalse, 0, 0, 0));

	if (i == I2C_POLL_COUNT) {
		switch (sta_bit) {
		case I2C_STA_CF:
			status = 0;
			break;
		case I2C_STA_AAS:
			status = 2;
			break;
		case I2C_STA_BB:
			status = 4;
			break;
		case I2C_STA_AL:
			status = 6;
			break;
		case I2C_STA_SRW:
			status = 8;
			break;
		case I2C_STA_IF:
			status = 10;
			break;
		case I2C_STA_RXAK:
			status = 12;
			break;
		default:
			status = 14;
			break;
		}

		if (!truefalse)
			status++;

		I2CCDBG (NO, ("--- status %d\n", status, 0, 0, 0, 0, 0));
		I2CCDBG (NO, (I2CERR[status], 0, 0, 0, 0, 0, 0));
	}

	return (ERROR);
}

/******************************************************************************
 *
 * I2C Enable - Enable the I2C Controller
 *
 */
STATUS i2c_enable (SI2C * pi2c, PI2CSET pi2cSet)
{
	int fdr = pi2cSet->bit_rate;
	UINT8 adr = pi2cSet->i2c_adr;

	I2CCDBG (L2, ("i2c_enable fdr %d adr %x\n", fdr, adr, 0, 0, 0, 0));

	i2c_clear (pi2c);	/* Clear FDR, ADR, SR and CR reg */

	SetI2cFDR (pi2c, fdr);	/* Frequency			*/
	pi2c->adr = adr;

	pi2c->cr = I2C_CTL_EN;	/* Set Enable			*/

	/*
	   The I2C bus should be in Idle state. If the bus is busy,
	   clear the STA bit in control register
	 */
	if (chk_status (pi2c, I2C_STA_BB, 0) != OK) {
		if ((pi2c->cr & I2C_CTL_STA) == I2C_CTL_STA)
			pi2c->cr &= ~I2C_CTL_STA;

		/* Check again if it is still busy, return error if found */
		if (chk_status (pi2c, I2C_STA_BB, 1) == OK)
			return ERROR;
	}

	return (OK);
}

/******************************************************************************
 *
 * I2C Disable - Disable the I2C Controller
 *
 */
STATUS i2c_disable (PSI2C pi2c)
{
	i2c_clear (pi2c);

	pi2c->cr &= I2C_CTL_EN; /* Disable I2c			*/

	if ((pi2c->cr & I2C_CTL_STA) == I2C_CTL_STA)
		pi2c->cr &= ~I2C_CTL_STA;

	if (chk_status (pi2c, I2C_STA_BB, 0) != OK)
		return ERROR;

	return (OK);
}

/******************************************************************************
 *
 * I2C Clear - Clear the I2C Controller
 *
 */
STATUS i2c_clear (PSI2C pi2c)
{
	pi2c->adr = 0;
	pi2c->fdr = 0;
	pi2c->cr = 0;
	pi2c->sr = 0;

	return (OK);
}


STATUS i2c_start (PSI2C pi2c, PI2CSET pi2cSet)
{
#ifdef TWOBYTES
	UINT16 ByteOffset = pi2cSet->str_adr;
#else
	UINT8 ByteOffset = pi2cSet->str_adr;
#endif
#if 1
	UINT8 tmp = 0;
#endif
	UINT8 Addr = pi2cSet->slv_adr;

	pi2c->cr |= I2C_CTL_STA;	/* Generate start signal	*/

	if (chk_status (pi2c, I2C_STA_BB, 1) != OK)
		return ERROR;

	/* Write slave address */
	if (i2c_writebyte (pi2c, &Addr) != OK) {
		i2c_stop (pi2c);	/* Disable I2c			*/
		return ERROR;
	}
#ifdef TWOBYTES
#   if 0
	/* Issue the offset to start */
	if (i2c_write2byte (pi2c, &ByteOffset) != OK) {
		i2c_stop (pi2c);	/* Disable I2c			*/
		return ERROR;
	}
#endif
	tmp = (ByteOffset >> 8) & 0xff;
	if (i2c_writebyte (pi2c, &tmp) != OK) {
		i2c_stop (pi2c);	/* Disable I2c			*/
		return ERROR;
	}
	tmp = ByteOffset & 0xff;
	if (i2c_writebyte (pi2c, &tmp) != OK) {
		i2c_stop (pi2c);	/* Disable I2c			*/
		return ERROR;
	}
#else
	if (i2c_writebyte (pi2c, &ByteOffset) != OK) {
		i2c_stop (pi2c);	/* Disable I2c			*/
		return ERROR;
	}
#endif

	return (OK);
}

STATUS i2c_stop (PSI2C pi2c)
{
	pi2c->cr &= ~I2C_CTL_STA;	/* Generate stop signal		*/
	if (chk_status (pi2c, I2C_STA_BB, 0) != OK)
		return ERROR;

	return (OK);
}

/******************************************************************************
 *
 * Read Len bytes to the location pointed to by *Data from the device
 * with address Addr.
 */
int i2c_readblock (SI2C * pi2c, PI2CSET pi2cSet, UINT8 * Data)
{
	int i = 0;
	UINT8 Tmp;

/*    UINT8 ByteOffset = pi2cSet->str_adr; not used? */
	UINT8 Addr = pi2cSet->slv_adr;
	int Length = pi2cSet->xfer_size;

	I2CCDBG (L1, ("i2c_readblock addr %x data 0x%08x len %d offset %d\n",
		      Addr, (int) Data, Length, ByteOffset, 0, 0));

	if (pi2c->sr & I2C_STA_AL) {	/* Check if Arbitration lost	*/
		I2CCDBG (FN, ("Arbitration lost\n", 0, 0, 0, 0, 0, 0));
		pi2c->sr &= ~I2C_STA_AL;	/* Clear Arbitration status bit */
		return ERROR;
	}

	pi2c->cr |= I2C_CTL_TX; /* Enable the I2c for TX, Ack	*/

	if (i2c_start (pi2c, pi2cSet) == ERROR)
		return ERROR;

	pi2c->cr |= I2C_CTL_RSTA;	/* Repeat Start */

	Tmp = Addr | 1;

	if (i2c_writebyte (pi2c, &Tmp) != OK) {
		i2c_stop (pi2c);	/* Disable I2c	*/
		return ERROR;
	}

	if (((pi2c->sr & 0x07) == 0x07) || (pi2c->sr & 0x01))
		return ERROR;

	pi2c->cr &= ~I2C_CTL_TX;	/* Set receive mode	*/

	if (((pi2c->sr & 0x07) == 0x07) || (pi2c->sr & 0x01))
		return ERROR;

	/* Dummy Read */
	if (i2c_readbyte (pi2c, &Tmp, &i) != OK) {
		i2c_stop (pi2c);	/* Disable I2c	*/
		return ERROR;
	}

	i = 0;
	while (Length) {
		if (Length == 2)
			pi2c->cr |= I2C_CTL_TXAK;

		if (Length == 1)
			pi2c->cr &= ~I2C_CTL_STA;

		if (i2c_readbyte (pi2c, Data, &Length) != OK) {
			return i2c_stop (pi2c);
		}
		i++;
		Length--;
		Data++;
	}

	if (i2c_stop (pi2c) == ERROR)
		return ERROR;

	return i;
}

STATUS i2c_writeblock (SI2C * pi2c, PI2CSET pi2cSet, UINT8 * Data)
{
	int Length = pi2cSet->xfer_size;

#ifdef TWOBYTES
	UINT16 ByteOffset = pi2cSet->str_adr;
#else
	UINT8 ByteOffset = pi2cSet->str_adr;
#endif
	int j, k;

	I2CCDBG (L2, ("i2c_writeblock\n", 0, 0, 0, 0, 0, 0));

	if (pi2c->sr & I2C_STA_AL) {
		/* Check if arbitration lost */
		I2CCDBG (L2, ("Arbitration lost\n", 0, 0, 0, 0, 0, 0));
		pi2c->sr &= ~I2C_STA_AL;	/* Clear the condition	*/
		return ERROR;
	}

	pi2c->cr |= I2C_CTL_TX; /* Enable the I2c for TX, Ack	*/

	/* Do the not even offset first */
	if ((ByteOffset % 8) != 0) {
		int remain;

		if (Length > 8) {
			remain = 8 - (ByteOffset % 8);
			Length -= remain;

			pi2cSet->str_adr = ByteOffset;

			if (i2c_start (pi2c, pi2cSet) == ERROR)
				return ERROR;

			for (j = ByteOffset; j < remain; j++) {
				if (i2c_writebyte (pi2c, Data++) != OK)
					return ERROR;
			}

			if (i2c_stop (pi2c) == ERROR)
				return ERROR;

			sysMsDelay (32);

			/* Update the new ByteOffset */
			ByteOffset += remain;
		}
	}

	for (j = ByteOffset, k = 0; j < (Length + ByteOffset); j++) {
		if ((j % 8) == 0) {
			pi2cSet->str_adr = j;
			if (i2c_start (pi2c, pi2cSet) == ERROR)
				return ERROR;
		}

		k++;

		if (i2c_writebyte (pi2c, Data++) != OK)
			return ERROR;

		if ((j == (Length - 1)) || ((k % 8) == 0)) {
			if (i2c_stop (pi2c) == ERROR)
				return ERROR;

			sysMsDelay (50);
		}

	}

	return k;
}

STATUS i2c_readbyte (SI2C * pi2c, UINT8 * readb, int *index)
{
	pi2c->sr &= ~I2C_STA_IF;	/* Clear Interrupt Bit	*/
	*readb = pi2c->dr;		/* Read a byte		*/

	/*
	   Set I2C_CTRL_TXAK will cause Transfer pending and
	   set I2C_CTRL_STA will cause Interrupt pending
	 */
	if (*index != 2) {
		if (chk_status (pi2c, I2C_STA_CF, 1) != OK)	/* Transfer not complete?	*/
			return ERROR;
	}

	if (*index != 1) {
		if (chk_status (pi2c, I2C_STA_IF, 1) != OK)
			return ERROR;
	}

	return (OK);
}


STATUS i2c_writebyte (SI2C * pi2c, UINT8 * writeb)
{
	pi2c->sr &= ~I2C_STA_IF;	/* Clear Interrupt	*/
	pi2c->dr = *writeb;		/* Write a byte		*/

	if (chk_status (pi2c, I2C_STA_CF, 1) != OK)	/* Transfer not complete?	*/
		return ERROR;

	if (chk_status (pi2c, I2C_STA_IF, 1) != OK)
		return ERROR;

	return OK;
}

STATUS i2c_write2byte (SI2C * pi2c, UINT16 * writeb)
{
	UINT8 data;

	data = (UINT8) ((*writeb >> 8) & 0xff);
	if (i2c_writebyte (pi2c, &data) != OK)
		return ERROR;
	data = (UINT8) (*writeb & 0xff);
	if (i2c_writebyte (pi2c, &data) != OK)
		return ERROR;
	return OK;
}

/* FDR table base on 33MHz - more detail please refer to Odini2c_dividers.xls
FDR FDR scl sda scl2tap2
510 432 tap tap tap tap scl_per	    sda_hold	I2C Freq    0	1   2	3   4	5
000 000 9   3	4   1	28 Clocks   9 Clocks	1190 KHz    0	0   0	0   0	0
000 001 9   3	4   2	44 Clocks   11 Clocks	758 KHz	    0	0   1	0   0	0
000 010 9   3	6   4	80 Clocks   17 Clocks	417 KHz	    0	0   0	1   0	0
000 011 9   3	6   8	144 Clocks  25 Clocks	231 KHz	    0	0   1	1   0	0
000 100 9   3	14  16	288 Clocks  49 Clocks	116 KHz	    0	0   0	0   1	0
000 101 9   3	30  32	576 Clocks  97 Clocks	58 KHz	    0	0   1	0   1	0
000 110 9   3	62  64	1152 Clocks 193 Clocks	29 KHz	    0	0   0	1   1	0
000 111 9   3	126 128 2304 Clocks 385 Clocks	14 KHz	    0	0   1	1   1	0
001 000 10  3	4   1	30 Clocks   9 Clocks	1111 KHz1   0	0   0	0   0
001 001 10  3	4   2	48 Clocks   11 Clocks	694 KHz	    1	0   1	0   0	0
001 010 10  3	6   4	88 Clocks   17 Clocks	379 KHz	    1	0   0	1   0	0
001 011 10  3	6   8	160 Clocks  25 Clocks	208 KHz	    1	0   1	1   0	0
001 100 10  3	14  16	320 Clocks  49 Clocks	104 KHz	    1	0   0	0   1	0
001 101 10  3	30  32	640 Clocks  97 Clocks	52 KHz	    1	0   1	0   1	0
001 110 10  3	62  64	1280 Clocks 193 Clocks	26 KHz	    1	0   0	1   1	0
001 111 10  3	126 128 2560 Clocks 385 Clocks	13 KHz	    1	0   1	1   1	0
010 000 12  4	4   1	34 Clocks   10 Clocks	980 KHz	    0	1   0	0   0	0
010 001 12  4	4   2	56 Clocks   13 Clocks	595 KHz	    0	1   1	0   0	0
010 010 12  4	6   4	104 Clocks  21 Clocks	321 KHz	    0	1   0	1   0	0
010 011 12  4	6   8	192 Clocks  33 Clocks	174 KHz	    0	1   1	1   0	0
010 100 12  4	14  16	384 Clocks  65 Clocks	87 KHz	    0	1   0	0   1	0
010 101 12  4	30  32	768 Clocks  129 Clocks	43 KHz	    0	1   1	0   1	0
010 110 12  4	62  64	1536 Clocks 257 Clocks	22 KHz	    0	1   0	1   1	0
010 111 12  4	126 128 3072 Clocks 513 Clocks	11 KHz	    0	1   1	1   1	0
011 000 15  4	4   1	40 Clocks   10 Clocks	833 KHz	    1	1   0	0   0	0
011 001 15  4	4   2	68 Clocks   13 Clocks	490 KHz	    1	1   1	0   0	0
011 010 15  4	6   4	128 Clocks  21 Clocks	260 KHz	    1	1   0	1   0	0
011 011 15  4	6   8	240 Clocks  33 Clocks	139 KHz	    1	1   1	1   0	0
011 100 15  4	14  16	480 Clocks  65 Clocks	69 KHz	    1	1   0	0   1	0
011 101 15  4	30  32	960 Clocks  129 Clocks	35 KHz	    1	1   1	0   1	0
011 110 15  4	62  64	1920 Clocks 257 Clocks	17 KHz	    1	1   0	1   1	0
011 111 15  4	126 128 3840 Clocks 513 Clocks	9 KHz	    1	1   1	1   1	0
100 000 5   1	4   1	20 Clocks   7 Clocks	1667 KHz    0	0   0	0   0	1
100 001 5   1	4   2	28 Clocks   7 Clocks	1190 KHz    0	0   1	0   0	1
100 010 5   1	6   4	48 Clocks   9 Clocks	694 KHz	    0	0   0	1   0	1
100 011 5   1	6   8	80 Clocks   9 Clocks	417 KHz	    0	0   1	1   0	1
100 100 5   1	14  16	160 Clocks  17 Clocks	208 KHz	    0	0   0	0   1	1
100 101 5   1	30  32	320 Clocks  33 Clocks	104 KHz	    0	0   1	0   1	1
100 110 5   1	62  64	640 Clocks  65 Clocks	52 KHz	    0	0   0	1   1	1
100 111 5   1	126 128 1280 Clocks 129 Clocks	26 KHz	    0	0   1	1   1	1
101 000 6   1	4   1	22 Clocks   7 Clocks	1515 KHz    1	0   0	0   0	1
101 001 6   1	4   2	32 Clocks   7 Clocks	1042 KHz    1	0   1	0   0	1
101 010 6   1	6   4	56 Clocks   9 Clocks	595 KHz	    1	0   0	1   0	1
101 011 6   1	6   8	96 Clocks   9 Clocks	347 KHz	    1	0   1	1   0	1
101 100 6   1	14  16	192 Clocks  17 Clocks	174 KHz	    1	0   0	0   1	1
101 101 6   1	30  32	384 Clocks  33 Clocks	87 KHz	    1	0   1	0   1	1
101 110 6   1	62  64	768 Clocks  65 Clocks	43 KHz	    1	0   0	1   1	1
101 111 6   1	126 128 1536 Clocks 129 Clocks	22 KHz	    1	0   1	1   1	1
110 000 7   2	4   1	24 Clocks   8 Clocks	1389 KHz    0	1   0	0   0	1
110 001 7   2	4   2	36 Clocks   9 Clocks	926 KHz	    0	1   1	0   0	1
110 010 7   2	6   4	64 Clocks   13 Clocks	521 KHz	    0	1   0	1   0	1
110 011 7   2	6   8	112 Clocks  17 Clocks	298 KHz	    0	1   1	1   0	1
110 100 7   2	14  16	224 Clocks  33 Clocks	149 KHz	    0	1   0	0   1	1
110 101 7   2	30  32	448 Clocks  65 Clocks	74 KHz	    0	1   1	0   1	1
110 110 7   2	62  64	896 Clocks  129 Clocks	37 KHz	    0	1   0	1   1	1
110 111 7   2	126 128 1792 Clocks 257 Clocks	19 KHz	    0	1   1	1   1	1
111 000 8   2	4   1	26 Clocks   8 Clocks	1282 KHz    1	1   0	0   0	1
111 001 8   2	4   2	40 Clocks   9 Clocks	833 KHz	    1	1   1	0   0	1
111 010 8   2	6   4	72 Clocks   13 Clocks	463 KHz	    1	1   0	1   0	1
111 011 8   2	6   8	128 Clocks  17 Clocks	260 KHz	    1	1   1	1   0	1
111 100 8   2	14  16	256 Clocks  33 Clocks	130 KHz	    1	1   0	0   1	1
111 101 8   2	30  32	512 Clocks  65 Clocks	65 KHz	    1	1   1	0   1	1
111 110 8   2	62  64	1024 Clocks 129 Clocks	33 KHz	    1	1   0	1   1	1
111 111 8   2	126 128 2048 Clocks 257 Clocks	16 KHz	    1	1   1	1   1	1
*/
STATUS SetI2cFDR (PSI2C pi2cRegs, int bitrate)
{
/* Constants */
	const UINT8 div_hold[8][3] = { {9, 3}, {10, 3},
	{12, 4}, {15, 4},
	{5, 1}, {6, 1},
	{7, 2}, {8, 2}
	};

	const UINT8 scl_tap[8][2] = { {4, 1}, {4, 2},
	{6, 4}, {6, 8},
	{14, 16}, {30, 32},
	{62, 64}, {126, 128}
	};

	UINT8 mfdr_bits;

	int i = 0;
	int j = 0;

	int Diff, min;
	int WhichFreq, iRec, jRec;
	int SCL_Period;
	int SCL_Hold;
	int I2C_Freq;

	I2CCDBG (L2, ("Entering getBitRate: bitrate %d pi2cRegs 0x%08x\n",
		      bitrate, (int) pi2cRegs, 0, 0, 0, 0));

	if (bitrate < 0) {
		I2CCDBG (NO, ("Invalid bitrate\n", 0, 0, 0, 0, 0, 0));
		return ERROR;
	}

	/* Initialize */
	mfdr_bits = 0;
	min = 0x7fffffff;
	WhichFreq = iRec = jRec = 0;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			/* SCL Period = 2 * (scl2tap + [(SCL_Tap - 1) * tap2tap] + 2)
			 * SCL Hold   = scl2tap + ((SDA_Tap - 1) * tap2tap) + 3
			 * Bit Rate (I2C Freq) = System Freq / SCL Period
			 */
			SCL_Period =
				2 * (scl_tap[i][0] +
				     ((div_hold[j][0] - 1) * scl_tap[i][1]) +
				     2);

			/* Now get the I2C Freq */
			I2C_Freq = DEV_CLOCK_FREQ / SCL_Period;

			/* Take equal or slower */
			if (I2C_Freq > bitrate)
				continue;

			/* Take the differences */
			Diff = I2C_Freq - bitrate;

			Diff = ABS (Diff);

			/* Find the closer value */
			if (Diff < min) {
				min = Diff;
				WhichFreq = I2C_Freq;
				iRec = i;
				jRec = j;
			}

			I2CCDBG (L2,
				 ("--- (%d,%d) I2C_Freq %d minDiff %d min %d\n",
				  i, j, I2C_Freq, Diff, min, 0));
		}
	}

	SCL_Period =
		2 * (scl_tap[iRec][0] +
		     ((div_hold[jRec][0] - 1) * scl_tap[iRec][1]) + 2);

	I2CCDBG (L2, ("\nmin %d WhichFreq %d iRec %d jRec %d\n",
		      min, WhichFreq, iRec, jRec, 0, 0));
	I2CCDBG (L2, ("--- scl2tap %d SCL_Tap %d tap2tap %d\n",
		      scl_tap[iRec][0], div_hold[jRec][0], scl_tap[iRec][1],
		      0, 0, 0));

	/* This may no require */
	SCL_Hold =
		scl_tap[iRec][0] +
		((div_hold[jRec][1] - 1) * scl_tap[iRec][1]) + 3;
	I2CCDBG (L2,
		 ("--- SCL_Period %d SCL_Hold %d\n", SCL_Period, SCL_Hold, 0,
		  0, 0, 0));

	I2CCDBG (L2, ("--- mfdr_bits %x\n", mfdr_bits, 0, 0, 0, 0, 0));

	/* FDR 4,3,2 */
	if ((iRec & 1) == 1)
		mfdr_bits |= 0x04;	/* FDR 2 */
	if ((iRec & 2) == 2)
		mfdr_bits |= 0x08;	/* FDR 3 */
	if ((iRec & 4) == 4)
		mfdr_bits |= 0x10;	/* FDR 4 */
	/* FDR 5,1,0 */
	if ((jRec & 1) == 1)
		mfdr_bits |= 0x01;	/* FDR 0 */
	if ((jRec & 2) == 2)
		mfdr_bits |= 0x02;	/* FDR 1 */
	if ((jRec & 4) == 4)
		mfdr_bits |= 0x20;	/* FDR 5 */

	I2CCDBG (L2, ("--- mfdr_bits %x\n", mfdr_bits, 0, 0, 0, 0, 0));

	pi2cRegs->fdr = mfdr_bits;

	return OK;
}