i2c-nomadik.c 27.8 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2
/*
3
 * Copyright (C) 2009 ST-Ericsson SA
4
5
6
7
8
9
10
11
12
13
 * Copyright (C) 2009 STMicroelectronics
 *
 * I2C master mode controller driver, used in Nomadik 8815
 * and Ux500 platforms.
 *
 * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
 * Author: Sachin Verma <sachin.verma@st.com>
 */
#include <linux/init.h>
#include <linux/module.h>
14
#include <linux/amba/bus.h>
15
#include <linux/slab.h>
16
17
18
19
20
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
21
#include <linux/pm_runtime.h>
22
#include <linux/of.h>
23
#include <linux/pinctrl/consumer.h>
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

#define DRIVER_NAME "nmk-i2c"

/* I2C Controller register offsets */
#define I2C_CR		(0x000)
#define I2C_SCR		(0x004)
#define I2C_HSMCR	(0x008)
#define I2C_MCR		(0x00C)
#define I2C_TFR		(0x010)
#define I2C_SR		(0x014)
#define I2C_RFR		(0x018)
#define I2C_TFTR	(0x01C)
#define I2C_RFTR	(0x020)
#define I2C_DMAR	(0x024)
#define I2C_BRCR	(0x028)
#define I2C_IMSCR	(0x02C)
#define I2C_RISR	(0x030)
#define I2C_MISR	(0x034)
#define I2C_ICR		(0x038)

/* Control registers */
#define I2C_CR_PE		(0x1 << 0)	/* Peripheral Enable */
#define I2C_CR_OM		(0x3 << 1)	/* Operating mode */
#define I2C_CR_SAM		(0x1 << 3)	/* Slave addressing mode */
#define I2C_CR_SM		(0x3 << 4)	/* Speed mode */
#define I2C_CR_SGCM		(0x1 << 6)	/* Slave general call mode */
#define I2C_CR_FTX		(0x1 << 7)	/* Flush Transmit */
#define I2C_CR_FRX		(0x1 << 8)	/* Flush Receive */
#define I2C_CR_DMA_TX_EN	(0x1 << 9)	/* DMA Tx enable */
#define I2C_CR_DMA_RX_EN	(0x1 << 10)	/* DMA Rx Enable */
#define I2C_CR_DMA_SLE		(0x1 << 11)	/* DMA sync. logic enable */
#define I2C_CR_LM		(0x1 << 12)	/* Loopback mode */
#define I2C_CR_FON		(0x3 << 13)	/* Filtering on */
#define I2C_CR_FS		(0x3 << 15)	/* Force stop enable */

/* Master controller (MCR) register */
#define I2C_MCR_OP		(0x1 << 0)	/* Operation */
#define I2C_MCR_A7		(0x7f << 1)	/* 7-bit address */
62
#define I2C_MCR_EA10		(0x7 << 8)	/* 10-bit Extended address */
63
64
#define I2C_MCR_SB		(0x1 << 11)	/* Extended address */
#define I2C_MCR_AM		(0x3 << 12)	/* Address type */
65
66
#define I2C_MCR_STOP		(0x1 << 14)	/* Stop condition */
#define I2C_MCR_LENGTH		(0x7ff << 15)	/* Transaction length */
67
68
69
70
71
72
73
74
75

/* Status register (SR) */
#define I2C_SR_OP		(0x3 << 0)	/* Operation */
#define I2C_SR_STATUS		(0x3 << 2)	/* controller status */
#define I2C_SR_CAUSE		(0x7 << 4)	/* Abort cause */
#define I2C_SR_TYPE		(0x3 << 7)	/* Receive type */
#define I2C_SR_LENGTH		(0x7ff << 9)	/* Transfer length */

/* Interrupt mask set/clear (IMSCR) bits */
76
#define I2C_IT_TXFE		(0x1 << 0)
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
#define I2C_IT_TXFNE		(0x1 << 1)
#define I2C_IT_TXFF		(0x1 << 2)
#define I2C_IT_TXFOVR		(0x1 << 3)
#define I2C_IT_RXFE		(0x1 << 4)
#define I2C_IT_RXFNF		(0x1 << 5)
#define I2C_IT_RXFF		(0x1 << 6)
#define I2C_IT_RFSR		(0x1 << 16)
#define I2C_IT_RFSE		(0x1 << 17)
#define I2C_IT_WTSR		(0x1 << 18)
#define I2C_IT_MTD		(0x1 << 19)
#define I2C_IT_STD		(0x1 << 20)
#define I2C_IT_MAL		(0x1 << 24)
#define I2C_IT_BERR		(0x1 << 25)
#define I2C_IT_MTDWS		(0x1 << 28)

#define GEN_MASK(val, mask, sb)  (((val) << (sb)) & (mask))

/* some bits in ICR are reserved */
#define I2C_CLEAR_ALL_INTS	0x131f007f

/* first three msb bits are reserved */
#define IRQ_MASK(mask)		(mask & 0x1fffffff)

/* maximum threshold value */
#define MAX_I2C_FIFO_THRESHOLD	15

103
104
105
106
107
108
109
enum i2c_freq_mode {
	I2C_FREQ_MODE_STANDARD,		/* up to 100 Kb/s */
	I2C_FREQ_MODE_FAST,		/* up to 400 Kb/s */
	I2C_FREQ_MODE_HIGH_SPEED,	/* up to 3.4 Mb/s */
	I2C_FREQ_MODE_FAST_PLUS,	/* up to 1 Mb/s */
};

110
111
112
113
114
115
116
117
118
119
/**
 * struct i2c_vendor_data - per-vendor variations
 * @has_mtdws: variant has the MTDWS bit
 * @fifodepth: variant FIFO depth
 */
struct i2c_vendor_data {
	bool has_mtdws;
	u32 fifodepth;
};

120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
enum i2c_status {
	I2C_NOP,
	I2C_ON_GOING,
	I2C_OK,
	I2C_ABORT
};

/* operation */
enum i2c_operation {
	I2C_NO_OPERATION = 0xff,
	I2C_WRITE = 0x00,
	I2C_READ = 0x01
};

/**
 * struct i2c_nmk_client - client specific data
 * @slave_adr: 7-bit slave address
Lucas De Marchi's avatar
Lucas De Marchi committed
137
 * @count: no. bytes to be transferred
138
 * @buffer: client data buffer
Lucas De Marchi's avatar
Lucas De Marchi committed
139
 * @xfer_bytes: bytes transferred till now
140
141
142
143
144
145
146
147
148
149
150
 * @operation: current I2C operation
 */
struct i2c_nmk_client {
	unsigned short		slave_adr;
	unsigned long		count;
	unsigned char		*buffer;
	unsigned long		xfer_bytes;
	enum i2c_operation	operation;
};

/**
151
 * struct nmk_i2c_dev - private data structure of the controller.
152
 * @vendor: vendor data for this variant.
153
 * @adev: parent amba device.
154
155
156
157
158
 * @adap: corresponding I2C adapter.
 * @irq: interrupt line for the controller.
 * @virtbase: virtual io memory area.
 * @clk: hardware i2c block clock.
 * @cli: holder of client specific data.
159
160
161
 * @clk_freq: clock frequency for the operation mode
 * @tft: Tx FIFO Threshold in bytes
 * @rft: Rx FIFO Threshold in bytes
162
 * @timeout: Slave response timeout (ms)
163
 * @sm: speed mode
164
165
166
 * @stop: stop condition.
 * @xfer_complete: acknowledge completion for a I2C message.
 * @result: controller propogated result.
167
168
 */
struct nmk_i2c_dev {
169
	struct i2c_vendor_data		*vendor;
170
	struct amba_device		*adev;
171
172
	struct i2c_adapter		adap;
	int				irq;
173
174
175
	void __iomem			*virtbase;
	struct clk			*clk;
	struct i2c_nmk_client		cli;
176
177
178
179
180
	u32				clk_freq;
	unsigned char			tft;
	unsigned char			rft;
	int				timeout;
	enum i2c_freq_mode		sm;
181
	int				stop;
182
	struct completion		xfer_complete;
183
	int				result;
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
};

/* controller's abort causes */
static const char *abort_causes[] = {
	"no ack received after address transmission",
	"no ack received during data phase",
	"ack received after xmission of master code",
	"master lost arbitration",
	"slave restarts",
	"slave reset",
	"overflow, maxsize is 2047 bytes",
};

static inline void i2c_set_bit(void __iomem *reg, u32 mask)
{
	writel(readl(reg) | mask, reg);
}

static inline void i2c_clr_bit(void __iomem *reg, u32 mask)
{
	writel(readl(reg) & ~mask, reg);
}

/**
 * flush_i2c_fifo() - This function flushes the I2C FIFO
 * @dev: private data of I2C Driver
 *
 * This function flushes the I2C Tx and Rx FIFOs. It returns
 * 0 on successful flushing of FIFO
 */
static int flush_i2c_fifo(struct nmk_i2c_dev *dev)
{
#define LOOP_ATTEMPTS 10
	int i;
	unsigned long timeout;

	/*
	 * flush the transmit and receive FIFO. The flushing
	 * operation takes several cycles before to be completed.
	 * On the completion, the I2C internal logic clears these
	 * bits, until then no one must access Tx, Rx FIFO and
	 * should poll on these bits waiting for the completion.
	 */
	writel((I2C_CR_FTX | I2C_CR_FRX), dev->virtbase + I2C_CR);

	for (i = 0; i < LOOP_ATTEMPTS; i++) {
230
		timeout = jiffies + dev->adap.timeout;
231
232
233
234
235
236
237
238

		while (!time_after(jiffies, timeout)) {
			if ((readl(dev->virtbase + I2C_CR) &
				(I2C_CR_FTX | I2C_CR_FRX)) == 0)
					return 0;
		}
	}

239
	dev_err(&dev->adev->dev,
240
241
		"flushing operation timed out giving up after %d attempts",
		LOOP_ATTEMPTS);
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

	return -ETIMEDOUT;
}

/**
 * disable_all_interrupts() - Disable all interrupts of this I2c Bus
 * @dev: private data of I2C Driver
 */
static void disable_all_interrupts(struct nmk_i2c_dev *dev)
{
	u32 mask = IRQ_MASK(0);
	writel(mask, dev->virtbase + I2C_IMSCR);
}

/**
 * clear_all_interrupts() - Clear all interrupts of I2C Controller
 * @dev: private data of I2C Driver
 */
static void clear_all_interrupts(struct nmk_i2c_dev *dev)
{
	u32 mask;
	mask = IRQ_MASK(I2C_CLEAR_ALL_INTS);
	writel(mask, dev->virtbase + I2C_ICR);
}

/**
 * init_hw() - initialize the I2C hardware
 * @dev: private data of I2C Driver
 */
static int init_hw(struct nmk_i2c_dev *dev)
{
	int stat;

	stat = flush_i2c_fifo(dev);
	if (stat)
277
		goto exit;
278
279

	/* disable the controller */
Tian Tao's avatar
Tian Tao committed
280
	i2c_clr_bit(dev->virtbase + I2C_CR, I2C_CR_PE);
281
282
283
284
285
286
287

	disable_all_interrupts(dev);

	clear_all_interrupts(dev);

	dev->cli.operation = I2C_NO_OPERATION;

288
289
exit:
	return stat;
290
291
292
}

/* enable peripheral, master mode operation */
293
#define DEFAULT_I2C_REG_CR	((1 << 1) | I2C_CR_PE)
294
295
296
297

/**
 * load_i2c_mcr_reg() - load the MCR register
 * @dev: private data of controller
298
 * @flags: message flags
299
 */
300
static u32 load_i2c_mcr_reg(struct nmk_i2c_dev *dev, u16 flags)
301
302
{
	u32 mcr = 0;
303
	unsigned short slave_adr_3msb_bits;
304
305
306

	mcr |= GEN_MASK(dev->cli.slave_adr, I2C_MCR_A7, 1);

307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
	if (unlikely(flags & I2C_M_TEN)) {
		/* 10-bit address transaction */
		mcr |= GEN_MASK(2, I2C_MCR_AM, 12);
		/*
		 * Get the top 3 bits.
		 * EA10 represents extended address in MCR. This includes
		 * the extension (MSB bits) of the 7 bit address loaded
		 * in A7
		 */
		slave_adr_3msb_bits = (dev->cli.slave_adr >> 7) & 0x7;

		mcr |= GEN_MASK(slave_adr_3msb_bits, I2C_MCR_EA10, 8);
	} else {
		/* 7-bit address transaction */
		mcr |= GEN_MASK(1, I2C_MCR_AM, 12);
	}

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
	/* start byte procedure not applied */
	mcr |= GEN_MASK(0, I2C_MCR_SB, 11);

	/* check the operation, master read/write? */
	if (dev->cli.operation == I2C_WRITE)
		mcr |= GEN_MASK(I2C_WRITE, I2C_MCR_OP, 0);
	else
		mcr |= GEN_MASK(I2C_READ, I2C_MCR_OP, 0);

	/* stop or repeated start? */
	if (dev->stop)
		mcr |= GEN_MASK(1, I2C_MCR_STOP, 14);
	else
		mcr &= ~(GEN_MASK(1, I2C_MCR_STOP, 14));

	mcr |= GEN_MASK(dev->cli.count, I2C_MCR_LENGTH, 15);

	return mcr;
}

/**
 * setup_i2c_controller() - setup the controller
 * @dev: private data of controller
 */
static void setup_i2c_controller(struct nmk_i2c_dev *dev)
{
	u32 brcr1, brcr2;
	u32 i2c_clk, div;
352
353
	u32 ns;
	u16 slsu;
354
355
356
357
358
359
360

	writel(0x0, dev->virtbase + I2C_CR);
	writel(0x0, dev->virtbase + I2C_HSMCR);
	writel(0x0, dev->virtbase + I2C_TFTR);
	writel(0x0, dev->virtbase + I2C_RFTR);
	writel(0x0, dev->virtbase + I2C_DMAR);

361
362
	i2c_clk = clk_get_rate(dev->clk);

363
364
365
366
	/*
	 * set the slsu:
	 *
	 * slsu defines the data setup time after SCL clock
367
368
369
370
371
372
373
	 * stretching in terms of i2c clk cycles + 1 (zero means
	 * "wait one cycle"), the needed setup time for the three
	 * modes are 250ns, 100ns, 10ns respectively.
	 *
	 * As the time for one cycle T in nanoseconds is
	 * T = (1/f) * 1000000000 =>
	 * slsu = cycles / (1000000000 / f) + 1
374
	 */
375
	ns = DIV_ROUND_UP_ULL(1000000000ULL, i2c_clk);
376
	switch (dev->sm) {
377
378
379
380
381
382
383
384
385
386
387
388
389
	case I2C_FREQ_MODE_FAST:
	case I2C_FREQ_MODE_FAST_PLUS:
		slsu = DIV_ROUND_UP(100, ns); /* Fast */
		break;
	case I2C_FREQ_MODE_HIGH_SPEED:
		slsu = DIV_ROUND_UP(10, ns); /* High */
		break;
	case I2C_FREQ_MODE_STANDARD:
	default:
		slsu = DIV_ROUND_UP(250, ns); /* Standard */
		break;
	}
	slsu += 1;
390

391
392
	dev_dbg(&dev->adev->dev, "calculated SLSU = %04x\n", slsu);
	writel(slsu << 16, dev->virtbase + I2C_SCR);
393
394
395
396
397
398

	/*
	 * The spec says, in case of std. mode the divider is
	 * 2 whereas it is 3 for fast and fastplus mode of
	 * operation. TODO - high speed support.
	 */
399
	div = (dev->clk_freq > I2C_MAX_STANDARD_MODE_FREQ) ? 3 : 2;
400
401
402
403
404
405
406
407
408

	/*
	 * generate the mask for baud rate counters. The controller
	 * has two baud rate counters. One is used for High speed
	 * operation, and the other is for std, fast mode, fast mode
	 * plus operation. Currently we do not supprt high speed mode
	 * so set brcr1 to 0.
	 */
	brcr1 = 0 << 16;
409
	brcr2 = (i2c_clk/(dev->clk_freq * div)) & 0xffff;
410
411
412
413
414
415
416

	/* set the baud rate counter register */
	writel((brcr1 | brcr2), dev->virtbase + I2C_BRCR);

	/*
	 * set the speed mode. Currently we support
	 * only standard and fast mode of operation
Lucas De Marchi's avatar
Lucas De Marchi committed
417
	 * TODO - support for fast mode plus (up to 1Mb/s)
418
419
	 * and high speed (up to 3.4 Mb/s)
	 */
420
	if (dev->sm > I2C_FREQ_MODE_FAST) {
421
		dev_err(&dev->adev->dev,
422
			"do not support this mode defaulting to std. mode\n");
423
		brcr2 = i2c_clk / (I2C_MAX_STANDARD_MODE_FREQ * 2) & 0xffff;
424
425
426
427
		writel((brcr1 | brcr2), dev->virtbase + I2C_BRCR);
		writel(I2C_FREQ_MODE_STANDARD << 4,
				dev->virtbase + I2C_CR);
	}
428
	writel(dev->sm << 4, dev->virtbase + I2C_CR);
429
430

	/* set the Tx and Rx FIFO threshold */
431
432
	writel(dev->tft, dev->virtbase + I2C_TFTR);
	writel(dev->rft, dev->virtbase + I2C_RFTR);
433
434
435
436
437
}

/**
 * read_i2c() - Read from I2C client device
 * @dev: private data of I2C Driver
438
 * @flags: message flags
439
440
441
442
443
 *
 * This function reads from i2c client device when controller is in
 * master mode. There is a completion timeout. If there is no transfer
 * before timeout error is returned.
 */
444
static int read_i2c(struct nmk_i2c_dev *dev, u16 flags)
445
{
446
	int status = 0;
447
	u32 mcr, irq_mask;
448
	unsigned long timeout;
449

450
	mcr = load_i2c_mcr_reg(dev, flags);
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
	writel(mcr, dev->virtbase + I2C_MCR);

	/* load the current CR value */
	writel(readl(dev->virtbase + I2C_CR) | DEFAULT_I2C_REG_CR,
			dev->virtbase + I2C_CR);

	/* enable the controller */
	i2c_set_bit(dev->virtbase + I2C_CR, I2C_CR_PE);

	init_completion(&dev->xfer_complete);

	/* enable interrupts by setting the mask */
	irq_mask = (I2C_IT_RXFNF | I2C_IT_RXFF |
			I2C_IT_MAL | I2C_IT_BERR);

466
	if (dev->stop || !dev->vendor->has_mtdws)
467
468
469
470
471
472
473
474
475
		irq_mask |= I2C_IT_MTD;
	else
		irq_mask |= I2C_IT_MTDWS;

	irq_mask = I2C_CLEAR_ALL_INTS & IRQ_MASK(irq_mask);

	writel(readl(dev->virtbase + I2C_IMSCR) | irq_mask,
			dev->virtbase + I2C_IMSCR);

476
	timeout = wait_for_completion_timeout(
477
		&dev->xfer_complete, dev->adap.timeout);
478
479

	if (timeout == 0) {
480
		/* Controller timed out */
481
		dev_err(&dev->adev->dev, "read from slave 0x%x timed out\n",
482
				dev->cli.slave_adr);
483
484
485
486
487
		status = -ETIMEDOUT;
	}
	return status;
}

488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
static void fill_tx_fifo(struct nmk_i2c_dev *dev, int no_bytes)
{
	int count;

	for (count = (no_bytes - 2);
			(count > 0) &&
			(dev->cli.count != 0);
			count--) {
		/* write to the Tx FIFO */
		writeb(*dev->cli.buffer,
			dev->virtbase + I2C_TFR);
		dev->cli.buffer++;
		dev->cli.count--;
		dev->cli.xfer_bytes++;
	}

}

506
507
508
/**
 * write_i2c() - Write data to I2C client.
 * @dev: private data of I2C Driver
509
 * @flags: message flags
510
511
512
 *
 * This function writes data to I2C client
 */
513
static int write_i2c(struct nmk_i2c_dev *dev, u16 flags)
514
515
{
	u32 status = 0;
516
	u32 mcr, irq_mask;
517
	unsigned long timeout;
518

519
	mcr = load_i2c_mcr_reg(dev, flags);
520
521
522
523
524
525
526
527

	writel(mcr, dev->virtbase + I2C_MCR);

	/* load the current CR value */
	writel(readl(dev->virtbase + I2C_CR) | DEFAULT_I2C_REG_CR,
			dev->virtbase + I2C_CR);

	/* enable the controller */
Tian Tao's avatar
Tian Tao committed
528
	i2c_set_bit(dev->virtbase + I2C_CR, I2C_CR_PE);
529
530
531
532

	init_completion(&dev->xfer_complete);

	/* enable interrupts by settings the masks */
533
534
535
536
537
538
539
	irq_mask = (I2C_IT_TXFOVR | I2C_IT_MAL | I2C_IT_BERR);

	/* Fill the TX FIFO with transmit data */
	fill_tx_fifo(dev, MAX_I2C_FIFO_THRESHOLD);

	if (dev->cli.count != 0)
		irq_mask |= I2C_IT_TXFNE;
540
541
542
543
544
545

	/*
	 * check if we want to transfer a single or multiple bytes, if so
	 * set the MTDWS bit (Master Transaction Done Without Stop)
	 * to start repeated start operation
	 */
546
	if (dev->stop || !dev->vendor->has_mtdws)
547
548
549
550
551
552
553
554
555
		irq_mask |= I2C_IT_MTD;
	else
		irq_mask |= I2C_IT_MTDWS;

	irq_mask = I2C_CLEAR_ALL_INTS & IRQ_MASK(irq_mask);

	writel(readl(dev->virtbase + I2C_IMSCR) | irq_mask,
			dev->virtbase + I2C_IMSCR);

556
	timeout = wait_for_completion_timeout(
557
		&dev->xfer_complete, dev->adap.timeout);
558
559

	if (timeout == 0) {
560
		/* Controller timed out */
561
		dev_err(&dev->adev->dev, "write to slave 0x%x timed out\n",
562
				dev->cli.slave_adr);
563
564
565
566
567
568
		status = -ETIMEDOUT;
	}

	return status;
}

569
570
571
572
573
574
575
576
577
578
579
580
/**
 * nmk_i2c_xfer_one() - transmit a single I2C message
 * @dev: device with a message encoded into it
 * @flags: message flags
 */
static int nmk_i2c_xfer_one(struct nmk_i2c_dev *dev, u16 flags)
{
	int status;

	if (flags & I2C_M_RD) {
		/* read operation */
		dev->cli.operation = I2C_READ;
581
		status = read_i2c(dev, flags);
582
583
584
	} else {
		/* write operation */
		dev->cli.operation = I2C_WRITE;
585
		status = write_i2c(dev, flags);
586
587
588
589
590
591
592
593
594
595
596
597
598
599
	}

	if (status || (dev->result)) {
		u32 i2c_sr;
		u32 cause;

		i2c_sr = readl(dev->virtbase + I2C_SR);
		/*
		 * Check if the controller I2C operation status
		 * is set to ABORT(11b).
		 */
		if (((i2c_sr >> 2) & 0x3) == 0x3) {
			/* get the abort cause */
			cause =	(i2c_sr >> 4) & 0x7;
600
			dev_err(&dev->adev->dev, "%s\n",
601
				cause >= ARRAY_SIZE(abort_causes) ?
602
603
604
605
606
607
608
609
610
611
612
613
				"unknown reason" :
				abort_causes[cause]);
		}

		(void) init_hw(dev);

		status = status ? status : dev->result;
	}

	return status;
}

614
615
/**
 * nmk_i2c_xfer() - I2C transfer function used by kernel framework
616
617
618
 * @i2c_adap: Adapter pointer to the controller
 * @msgs: Pointer to data to be written.
 * @num_msgs: Number of messages to be executed
619
620
621
622
623
624
625
 *
 * This is the function called by the generic kernel i2c_transfer()
 * or i2c_smbus...() API calls. Note that this code is protected by the
 * semaphore set in the kernel i2c_transfer() function.
 *
 * NOTE:
 * READ TRANSFER : We impose a restriction of the first message to be the
626
627
628
629
630
631
632
 *		index message for any read transaction.
 *		- a no index is coded as '0',
 *		- 2byte big endian index is coded as '3'
 *		!!! msg[0].buf holds the actual index.
 *		This is compatible with generic messages of smbus emulator
 *		that send a one byte index.
 *		eg. a I2C transation to read 2 bytes from index 0
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
 *			idx = 0;
 *			msg[0].addr = client->addr;
 *			msg[0].flags = 0x0;
 *			msg[0].len = 1;
 *			msg[0].buf = &idx;
 *
 *			msg[1].addr = client->addr;
 *			msg[1].flags = I2C_M_RD;
 *			msg[1].len = 2;
 *			msg[1].buf = rd_buff
 *			i2c_transfer(adap, msg, 2);
 *
 * WRITE TRANSFER : The I2C standard interface interprets all data as payload.
 *		If you want to emulate an SMBUS write transaction put the
 *		index as first byte(or first and second) in the payload.
 *		eg. a I2C transation to write 2 bytes from index 1
 *			wr_buff[0] = 0x1;
 *			wr_buff[1] = 0x23;
 *			wr_buff[2] = 0x46;
 *			msg[0].flags = 0x0;
 *			msg[0].len = 3;
 *			msg[0].buf = wr_buff;
 *			i2c_transfer(adap, msg, 1);
 *
 * To read or write a block of data (multiple bytes) using SMBUS emulation
 * please use the i2c_smbus_read_i2c_block_data()
 * or i2c_smbus_write_i2c_block_data() API
 */
static int nmk_i2c_xfer(struct i2c_adapter *i2c_adap,
		struct i2c_msg msgs[], int num_msgs)
{
664
	int status = 0;
665
666
	int i;
	struct nmk_i2c_dev *dev = i2c_get_adapdata(i2c_adap);
667
	int j;
668

669
	pm_runtime_get_sync(&dev->adev->dev);
670

671
	/* Attempt three times to send the message queue */
672
673
674
	for (j = 0; j < 3; j++) {
		/* setup the i2c controller */
		setup_i2c_controller(dev);
675

676
677
678
679
680
681
682
		for (i = 0; i < num_msgs; i++) {
			dev->cli.slave_adr	= msgs[i].addr;
			dev->cli.buffer		= msgs[i].buf;
			dev->cli.count		= msgs[i].len;
			dev->stop = (i < (num_msgs - 1)) ? 0 : 1;
			dev->result = 0;

683
684
			status = nmk_i2c_xfer_one(dev, msgs[i].flags);
			if (status != 0)
685
				break;
686
		}
687
688
		if (status == 0)
			break;
689
	}
690

691
	pm_runtime_put_sync(&dev->adev->dev);
692

693
694
695
696
697
698
699
700
701
702
	/* return the no. messages processed */
	if (status)
		return status;
	else
		return num_msgs;
}

/**
 * disable_interrupts() - disable the interrupts
 * @dev: private data of controller
703
 * @irq: interrupt number
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
 */
static int disable_interrupts(struct nmk_i2c_dev *dev, u32 irq)
{
	irq = IRQ_MASK(irq);
	writel(readl(dev->virtbase + I2C_IMSCR) & ~(I2C_CLEAR_ALL_INTS & irq),
			dev->virtbase + I2C_IMSCR);
	return 0;
}

/**
 * i2c_irq_handler() - interrupt routine
 * @irq: interrupt number
 * @arg: data passed to the handler
 *
 * This is the interrupt handler for the i2c driver. Currently
 * it handles the major interrupts like Rx & Tx FIFO management
 * interrupts, master transaction interrupts, arbitration and
 * bus error interrupts. The rest of the interrupts are treated as
 * unhandled.
 */
static irqreturn_t i2c_irq_handler(int irq, void *arg)
{
	struct nmk_i2c_dev *dev = arg;
	u32 tft, rft;
	u32 count;
729
	u32 misr, src;
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750

	/* load Tx FIFO and Rx FIFO threshold values */
	tft = readl(dev->virtbase + I2C_TFTR);
	rft = readl(dev->virtbase + I2C_RFTR);

	/* read interrupt status register */
	misr = readl(dev->virtbase + I2C_MISR);

	src = __ffs(misr);
	switch ((1 << src)) {

	/* Transmit FIFO nearly empty interrupt */
	case I2C_IT_TXFNE:
	{
		if (dev->cli.operation == I2C_READ) {
			/*
			 * in read operation why do we care for writing?
			 * so disable the Transmit FIFO interrupt
			 */
			disable_interrupts(dev, I2C_IT_TXFNE);
		} else {
751
			fill_tx_fifo(dev, (MAX_I2C_FIFO_THRESHOLD - tft));
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
			/*
			 * if done, close the transfer by disabling the
			 * corresponding TXFNE interrupt
			 */
			if (dev->cli.count == 0)
				disable_interrupts(dev,	I2C_IT_TXFNE);
		}
	}
	break;

	/*
	 * Rx FIFO nearly full interrupt.
	 * This is set when the numer of entries in Rx FIFO is
	 * greater or equal than the threshold value programmed
	 * in RFT
	 */
	case I2C_IT_RXFNF:
		for (count = rft; count > 0; count--) {
			/* Read the Rx FIFO */
			*dev->cli.buffer = readb(dev->virtbase + I2C_RFR);
			dev->cli.buffer++;
		}
		dev->cli.count -= rft;
		dev->cli.xfer_bytes += rft;
		break;

	/* Rx FIFO full */
	case I2C_IT_RXFF:
		for (count = MAX_I2C_FIFO_THRESHOLD; count > 0; count--) {
			*dev->cli.buffer = readb(dev->virtbase + I2C_RFR);
			dev->cli.buffer++;
		}
		dev->cli.count -= MAX_I2C_FIFO_THRESHOLD;
		dev->cli.xfer_bytes += MAX_I2C_FIFO_THRESHOLD;
		break;

	/* Master Transaction Done with/without stop */
	case I2C_IT_MTD:
	case I2C_IT_MTDWS:
		if (dev->cli.operation == I2C_READ) {
792
793
			while (!(readl(dev->virtbase + I2C_RISR)
				 & I2C_IT_RXFE)) {
794
795
796
797
798
799
800
801
802
803
				if (dev->cli.count == 0)
					break;
				*dev->cli.buffer =
					readb(dev->virtbase + I2C_RFR);
				dev->cli.buffer++;
				dev->cli.count--;
				dev->cli.xfer_bytes++;
			}
		}

804
805
		disable_all_interrupts(dev);
		clear_all_interrupts(dev);
806
807

		if (dev->cli.count) {
808
			dev->result = -EIO;
809
			dev_err(&dev->adev->dev,
810
811
				"%lu bytes still remain to be xfered\n",
				dev->cli.count);
812
813
814
815
816
817
818
819
			(void) init_hw(dev);
		}
		complete(&dev->xfer_complete);

		break;

	/* Master Arbitration lost interrupt */
	case I2C_IT_MAL:
820
		dev->result = -EIO;
821
822
823
824
825
826
827
828
829
830
831
832
833
		(void) init_hw(dev);

		i2c_set_bit(dev->virtbase + I2C_ICR, I2C_IT_MAL);
		complete(&dev->xfer_complete);

		break;

	/*
	 * Bus Error interrupt.
	 * This happens when an unexpected start/stop condition occurs
	 * during the transaction.
	 */
	case I2C_IT_BERR:
834
		dev->result = -EIO;
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
		/* get the status */
		if (((readl(dev->virtbase + I2C_SR) >> 2) & 0x3) == I2C_ABORT)
			(void) init_hw(dev);

		i2c_set_bit(dev->virtbase + I2C_ICR, I2C_IT_BERR);
		complete(&dev->xfer_complete);

		break;

	/*
	 * Tx FIFO overrun interrupt.
	 * This is set when a write operation in Tx FIFO is performed and
	 * the Tx FIFO is full.
	 */
	case I2C_IT_TXFOVR:
850
		dev->result = -EIO;
851
852
		(void) init_hw(dev);

853
		dev_err(&dev->adev->dev, "Tx Fifo Over run\n");
854
855
856
857
858
859
860
861
862
863
864
865
		complete(&dev->xfer_complete);

		break;

	/* unhandled interrupts by this driver - TODO*/
	case I2C_IT_TXFE:
	case I2C_IT_TXFF:
	case I2C_IT_RXFE:
	case I2C_IT_RFSR:
	case I2C_IT_RFSE:
	case I2C_IT_WTSR:
	case I2C_IT_STD:
866
		dev_err(&dev->adev->dev, "unhandled Interrupt\n");
867
868
		break;
	default:
869
		dev_err(&dev->adev->dev, "spurious Interrupt..\n");
870
871
872
873
874
875
		break;
	}

	return IRQ_HANDLED;
}

876
877
#ifdef CONFIG_PM_SLEEP
static int nmk_i2c_suspend_late(struct device *dev)
878
{
879
	int ret;
880

881
882
883
884
885
	ret = pm_runtime_force_suspend(dev);
	if (ret)
		return ret;

	pinctrl_pm_select_sleep_state(dev);
886
887
888
	return 0;
}

889
static int nmk_i2c_resume_early(struct device *dev)
890
{
891
	return pm_runtime_force_resume(dev);
892
893
894
}
#endif

895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
#ifdef CONFIG_PM
static int nmk_i2c_runtime_suspend(struct device *dev)
{
	struct amba_device *adev = to_amba_device(dev);
	struct nmk_i2c_dev *nmk_i2c = amba_get_drvdata(adev);

	clk_disable_unprepare(nmk_i2c->clk);
	pinctrl_pm_select_idle_state(dev);
	return 0;
}

static int nmk_i2c_runtime_resume(struct device *dev)
{
	struct amba_device *adev = to_amba_device(dev);
	struct nmk_i2c_dev *nmk_i2c = amba_get_drvdata(adev);
	int ret;

	ret = clk_prepare_enable(nmk_i2c->clk);
	if (ret) {
		dev_err(dev, "can't prepare_enable clock\n");
		return ret;
	}

	pinctrl_pm_select_default_state(dev);

	ret = init_hw(nmk_i2c);
	if (ret) {
		clk_disable_unprepare(nmk_i2c->clk);
		pinctrl_pm_select_idle_state(dev);
	}

	return ret;
}
#endif

930
static const struct dev_pm_ops nmk_i2c_pm = {
931
	SET_LATE_SYSTEM_SLEEP_PM_OPS(nmk_i2c_suspend_late, nmk_i2c_resume_early)
932
	SET_RUNTIME_PM_OPS(nmk_i2c_runtime_suspend,
933
934
			nmk_i2c_runtime_resume,
			NULL)
935
936
};

937
938
static unsigned int nmk_i2c_functionality(struct i2c_adapter *adap)
{
939
	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR;
940
941
942
943
944
945
946
}

static const struct i2c_algorithm nmk_i2c_algo = {
	.master_xfer	= nmk_i2c_xfer,
	.functionality	= nmk_i2c_functionality
};

947
static void nmk_i2c_of_probe(struct device_node *np,
948
			     struct nmk_i2c_dev *nmk)
949
{
950
951
	/* Default to 100 kHz if no frequency is given in the node */
	if (of_property_read_u32(np, "clock-frequency", &nmk->clk_freq))
952
		nmk->clk_freq = I2C_MAX_STANDARD_MODE_FREQ;
953
954

	/* This driver only supports 'standard' and 'fast' modes of operation. */
955
	if (nmk->clk_freq <= I2C_MAX_STANDARD_MODE_FREQ)
956
		nmk->sm = I2C_FREQ_MODE_STANDARD;
957
	else
958
959
960
961
		nmk->sm = I2C_FREQ_MODE_FAST;
	nmk->tft = 1; /* Tx FIFO threshold */
	nmk->rft = 8; /* Rx FIFO threshold */
	nmk->timeout = 200; /* Slave response timeout(ms) */
962
963
}

964
static int nmk_i2c_probe(struct amba_device *adev, const struct amba_id *id)
965
966
{
	int ret = 0;
967
	struct device_node *np = adev->dev.of_node;
968
969
	struct nmk_i2c_dev	*dev;
	struct i2c_adapter *adap;
970
971
	struct i2c_vendor_data *vendor = id->data;
	u32 max_fifo_threshold = (vendor->fifodepth / 2) - 1;
972

973
	dev = devm_kzalloc(&adev->dev, sizeof(struct nmk_i2c_dev), GFP_KERNEL);
974
	if (!dev) {
975
		dev_err(&adev->dev, "cannot allocate memory\n");
976
977
978
		ret = -ENOMEM;
		goto err_no_mem;
	}
979
	dev->vendor = vendor;
980
	dev->adev = adev;
981
982
983
984
985
986
987
988
989
990
991
992
993
994
	nmk_i2c_of_probe(np, dev);

	if (dev->tft > max_fifo_threshold) {
		dev_warn(&adev->dev, "requested TX FIFO threshold %u, adjusted down to %u\n",
			 dev->tft, max_fifo_threshold);
		dev->tft = max_fifo_threshold;
	}

	if (dev->rft > max_fifo_threshold) {
		dev_warn(&adev->dev, "requested RX FIFO threshold %u, adjusted down to %u\n",
			dev->rft, max_fifo_threshold);
		dev->rft = max_fifo_threshold;
	}

995
	amba_set_drvdata(adev, dev);
996

997
998
	dev->virtbase = devm_ioremap(&adev->dev, adev->res.start,
				resource_size(&adev->res));
999
	if (!dev->virtbase) {
1000
		ret = -ENOMEM;
1001
		goto err_no_mem;
1002
1003
	}

1004
	dev->irq = adev->irq[0];
1005
	ret = devm_request_irq(&adev->dev, dev->irq, i2c_irq_handler, 0,
1006
1007
				DRIVER_NAME, dev);
	if (ret) {
1008
		dev_err(&adev->dev, "cannot claim the irq %d\n", dev->irq);
1009
		goto err_no_mem;
1010
1011
	}

1012
	dev->clk = devm_clk_get(&adev->dev, NULL);
1013
	if (IS_ERR(dev->clk)) {
1014
		dev_err(&adev->dev, "could not get i2c clock\n");
1015
		ret = PTR_ERR(dev->clk);
1016
		goto err_no_mem;
1017
1018
	}

1019
1020
1021
1022
1023
1024
1025
1026
	ret = clk_prepare_enable(dev->clk);
	if (ret) {
		dev_err(&adev->dev, "can't prepare_enable clock\n");
		goto err_no_mem;
	}

	init_hw(dev);

1027
	adap = &dev->adap;
1028
	adap->dev.of_node = np;
1029
	adap->dev.parent = &adev->dev;
1030
1031
1032
1033
	adap->owner = THIS_MODULE;
	adap->class = I2C_CLASS_DEPRECATED;
	adap->algo = &nmk_i2c_algo;
	adap->timeout = msecs_to_jiffies(dev->timeout);
1034
	snprintf(adap->name, sizeof(adap->name),
1035
		 "Nomadik I2C at %pR", &adev->res);
1036
1037
1038

	i2c_set_adapdata(adap, dev);

1039
	dev_info(&adev->dev,
1040
1041
		 "initialize %s on virtual base %p\n",
		 adap->name, dev->virtbase);
1042

1043
	ret = i2c_add_adapter(adap);
1044
	if (ret)
1045
		goto err_no_adap;
1046

1047
1048
	pm_runtime_put(&adev->dev);

1049
1050
	return 0;

1051
1052
 err_no_adap:
	clk_disable_unprepare(dev->clk);
1053
1054
1055
1056
1057
 err_no_mem:

	return ret;
}

1058
static void nmk_i2c_remove(struct amba_device *adev)
1059
{
1060
1061
	struct resource *res = &adev->res;
	struct nmk_i2c_dev *dev = amba_get_drvdata(adev);
1062
1063
1064
1065
1066
1067
1068

	i2c_del_adapter(&dev->adap);
	flush_i2c_fifo(dev);
	disable_all_interrupts(dev);
	clear_all_interrupts(dev);
	/* disable the controller */
	i2c_clr_bit(dev->virtbase + I2C_CR, I2C_CR_PE);
1069
	clk_disable_unprepare(dev->clk);
1070
	release_mem_region(res->start, resource_size(res));
1071
1072
}

1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
static struct i2c_vendor_data vendor_stn8815 = {
	.has_mtdws = false,
	.fifodepth = 16, /* Guessed from TFTR/RFTR = 7 */
};

static struct i2c_vendor_data vendor_db8500 = {
	.has_mtdws = true,
	.fifodepth = 32, /* Guessed from TFTR/RFTR = 15 */
};

Arvind Yadav's avatar
Arvind Yadav committed
1083
static const struct amba_id nmk_i2c_ids[] = {
1084
1085
1086
	{
		.id	= 0x00180024,
		.mask	= 0x00ffffff,
1087
		.data	= &vendor_stn8815,
1088
1089
1090
1091
	},
	{
		.id	= 0x00380024,
		.mask	= 0x00ffffff,
1092
		.data	= &vendor_db8500,
1093
1094
1095
1096
1097
1098
1099
1100
	},
	{},
};

MODULE_DEVICE_TABLE(amba, nmk_i2c_ids);

static struct amba_driver nmk_i2c_driver = {
	.drv = {
1101
1102
		.owner = THIS_MODULE,
		.name = DRIVER_NAME,
1103
		.pm = &nmk_i2c_pm,
1104
	},
1105
	.id_table = nmk_i2c_ids,
1106
	.probe = nmk_i2c_probe,
1107
	.remove = nmk_i2c_remove,
1108
1109
1110
1111
};

static int __init nmk_i2c_init(void)
{
1112
	return amba_driver_register(&nmk_i2c_driver);
1113
1114
1115
1116
}

static void __exit nmk_i2c_exit(void)
{
1117
	amba_driver_unregister(&nmk_i2c_driver);
1118
1119
1120
1121
1122
}

subsys_initcall(nmk_i2c_init);
module_exit(nmk_i2c_exit);

1123
1124
MODULE_AUTHOR("Sachin Verma");
MODULE_AUTHOR("Srinidhi KASAGAR");
1125
1126
MODULE_DESCRIPTION("Nomadik/Ux500 I2C driver");
MODULE_LICENSE("GPL");