xref: /openbmc/linux/drivers/sbus/char/bbc_i2c.c (revision 878f2774)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III
3  *            platforms.
4  *
5  * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
6  */
7 
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/types.h>
11 #include <linux/slab.h>
12 #include <linux/sched.h>
13 #include <linux/wait.h>
14 #include <linux/delay.h>
15 #include <linux/interrupt.h>
16 #include <linux/of.h>
17 #include <linux/of_platform.h>
18 #include <linux/platform_device.h>
19 #include <asm/bbc.h>
20 #include <asm/io.h>
21 
22 #include "bbc_i2c.h"
23 
24 /* Convert this driver to use i2c bus layer someday... */
25 #define I2C_PCF_PIN	0x80
26 #define I2C_PCF_ESO	0x40
27 #define I2C_PCF_ES1	0x20
28 #define I2C_PCF_ES2	0x10
29 #define I2C_PCF_ENI	0x08
30 #define I2C_PCF_STA	0x04
31 #define I2C_PCF_STO	0x02
32 #define I2C_PCF_ACK	0x01
33 
34 #define I2C_PCF_START    (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_ENI | I2C_PCF_STA | I2C_PCF_ACK)
35 #define I2C_PCF_STOP     (I2C_PCF_PIN | I2C_PCF_ESO | I2C_PCF_STO | I2C_PCF_ACK)
36 #define I2C_PCF_REPSTART (              I2C_PCF_ESO | I2C_PCF_STA | I2C_PCF_ACK)
37 #define I2C_PCF_IDLE     (I2C_PCF_PIN | I2C_PCF_ESO               | I2C_PCF_ACK)
38 
39 #define I2C_PCF_INI 0x40   /* 1 if not initialized */
40 #define I2C_PCF_STS 0x20
41 #define I2C_PCF_BER 0x10
42 #define I2C_PCF_AD0 0x08
43 #define I2C_PCF_LRB 0x08
44 #define I2C_PCF_AAS 0x04
45 #define I2C_PCF_LAB 0x02
46 #define I2C_PCF_BB  0x01
47 
48 /* The BBC devices have two I2C controllers.  The first I2C controller
49  * connects mainly to configuration proms (NVRAM, cpu configuration,
50  * dimm types, etc.).  Whereas the second I2C controller connects to
51  * environmental control devices such as fans and temperature sensors.
52  * The second controller also connects to the smartcard reader, if present.
53  */
54 
set_device_claimage(struct bbc_i2c_bus * bp,struct platform_device * op,int val)55 static void set_device_claimage(struct bbc_i2c_bus *bp, struct platform_device *op, int val)
56 {
57 	int i;
58 
59 	for (i = 0; i < NUM_CHILDREN; i++) {
60 		if (bp->devs[i].device == op) {
61 			bp->devs[i].client_claimed = val;
62 			return;
63 		}
64 	}
65 }
66 
67 #define claim_device(BP,ECHILD)		set_device_claimage(BP,ECHILD,1)
68 #define release_device(BP,ECHILD)	set_device_claimage(BP,ECHILD,0)
69 
bbc_i2c_getdev(struct bbc_i2c_bus * bp,int index)70 struct platform_device *bbc_i2c_getdev(struct bbc_i2c_bus *bp, int index)
71 {
72 	struct platform_device *op = NULL;
73 	int curidx = 0, i;
74 
75 	for (i = 0; i < NUM_CHILDREN; i++) {
76 		if (!(op = bp->devs[i].device))
77 			break;
78 		if (curidx == index)
79 			goto out;
80 		op = NULL;
81 		curidx++;
82 	}
83 
84 out:
85 	if (curidx == index)
86 		return op;
87 	return NULL;
88 }
89 
bbc_i2c_attach(struct bbc_i2c_bus * bp,struct platform_device * op)90 struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct platform_device *op)
91 {
92 	struct bbc_i2c_client *client;
93 	const u32 *reg;
94 
95 	client = kzalloc(sizeof(*client), GFP_KERNEL);
96 	if (!client)
97 		return NULL;
98 	client->bp = bp;
99 	client->op = op;
100 
101 	reg = of_get_property(op->dev.of_node, "reg", NULL);
102 	if (!reg) {
103 		kfree(client);
104 		return NULL;
105 	}
106 
107 	client->bus = reg[0];
108 	client->address = reg[1];
109 
110 	claim_device(bp, op);
111 
112 	return client;
113 }
114 
bbc_i2c_detach(struct bbc_i2c_client * client)115 void bbc_i2c_detach(struct bbc_i2c_client *client)
116 {
117 	struct bbc_i2c_bus *bp = client->bp;
118 	struct platform_device *op = client->op;
119 
120 	release_device(bp, op);
121 	kfree(client);
122 }
123 
wait_for_pin(struct bbc_i2c_bus * bp,u8 * status)124 static int wait_for_pin(struct bbc_i2c_bus *bp, u8 *status)
125 {
126 	DECLARE_WAITQUEUE(wait, current);
127 	int limit = 32;
128 	int ret = 1;
129 
130 	bp->waiting = 1;
131 	add_wait_queue(&bp->wq, &wait);
132 	while (limit-- > 0) {
133 		long val;
134 
135 		val = wait_event_interruptible_timeout(
136 				bp->wq,
137 				(((*status = readb(bp->i2c_control_regs + 0))
138 				  & I2C_PCF_PIN) == 0),
139 				msecs_to_jiffies(250));
140 		if (val > 0) {
141 			ret = 0;
142 			break;
143 		}
144 	}
145 	remove_wait_queue(&bp->wq, &wait);
146 	bp->waiting = 0;
147 
148 	return ret;
149 }
150 
bbc_i2c_writeb(struct bbc_i2c_client * client,unsigned char val,int off)151 int bbc_i2c_writeb(struct bbc_i2c_client *client, unsigned char val, int off)
152 {
153 	struct bbc_i2c_bus *bp = client->bp;
154 	int address = client->address;
155 	u8 status;
156 	int ret = -1;
157 
158 	if (bp->i2c_bussel_reg != NULL)
159 		writeb(client->bus, bp->i2c_bussel_reg);
160 
161 	writeb(address, bp->i2c_control_regs + 0x1);
162 	writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
163 	if (wait_for_pin(bp, &status))
164 		goto out;
165 
166 	writeb(off, bp->i2c_control_regs + 0x1);
167 	if (wait_for_pin(bp, &status) ||
168 	    (status & I2C_PCF_LRB) != 0)
169 		goto out;
170 
171 	writeb(val, bp->i2c_control_regs + 0x1);
172 	if (wait_for_pin(bp, &status))
173 		goto out;
174 
175 	ret = 0;
176 
177 out:
178 	writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
179 	return ret;
180 }
181 
bbc_i2c_readb(struct bbc_i2c_client * client,unsigned char * byte,int off)182 int bbc_i2c_readb(struct bbc_i2c_client *client, unsigned char *byte, int off)
183 {
184 	struct bbc_i2c_bus *bp = client->bp;
185 	unsigned char address = client->address, status;
186 	int ret = -1;
187 
188 	if (bp->i2c_bussel_reg != NULL)
189 		writeb(client->bus, bp->i2c_bussel_reg);
190 
191 	writeb(address, bp->i2c_control_regs + 0x1);
192 	writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
193 	if (wait_for_pin(bp, &status))
194 		goto out;
195 
196 	writeb(off, bp->i2c_control_regs + 0x1);
197 	if (wait_for_pin(bp, &status) ||
198 	    (status & I2C_PCF_LRB) != 0)
199 		goto out;
200 
201 	writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
202 
203 	address |= 0x1; /* READ */
204 
205 	writeb(address, bp->i2c_control_regs + 0x1);
206 	writeb(I2C_PCF_START, bp->i2c_control_regs + 0x0);
207 	if (wait_for_pin(bp, &status))
208 		goto out;
209 
210 	/* Set PIN back to one so the device sends the first
211 	 * byte.
212 	 */
213 	(void) readb(bp->i2c_control_regs + 0x1);
214 	if (wait_for_pin(bp, &status))
215 		goto out;
216 
217 	writeb(I2C_PCF_ESO | I2C_PCF_ENI, bp->i2c_control_regs + 0x0);
218 	*byte = readb(bp->i2c_control_regs + 0x1);
219 	if (wait_for_pin(bp, &status))
220 		goto out;
221 
222 	ret = 0;
223 
224 out:
225 	writeb(I2C_PCF_STOP, bp->i2c_control_regs + 0x0);
226 	(void) readb(bp->i2c_control_regs + 0x1);
227 
228 	return ret;
229 }
230 
bbc_i2c_write_buf(struct bbc_i2c_client * client,char * buf,int len,int off)231 int bbc_i2c_write_buf(struct bbc_i2c_client *client,
232 		      char *buf, int len, int off)
233 {
234 	int ret = 0;
235 
236 	while (len > 0) {
237 		ret = bbc_i2c_writeb(client, *buf, off);
238 		if (ret < 0)
239 			break;
240 		len--;
241 		buf++;
242 		off++;
243 	}
244 	return ret;
245 }
246 
bbc_i2c_read_buf(struct bbc_i2c_client * client,char * buf,int len,int off)247 int bbc_i2c_read_buf(struct bbc_i2c_client *client,
248 		     char *buf, int len, int off)
249 {
250 	int ret = 0;
251 
252 	while (len > 0) {
253 		ret = bbc_i2c_readb(client, buf, off);
254 		if (ret < 0)
255 			break;
256 		len--;
257 		buf++;
258 		off++;
259 	}
260 
261 	return ret;
262 }
263 
264 EXPORT_SYMBOL(bbc_i2c_getdev);
265 EXPORT_SYMBOL(bbc_i2c_attach);
266 EXPORT_SYMBOL(bbc_i2c_detach);
267 EXPORT_SYMBOL(bbc_i2c_writeb);
268 EXPORT_SYMBOL(bbc_i2c_readb);
269 EXPORT_SYMBOL(bbc_i2c_write_buf);
270 EXPORT_SYMBOL(bbc_i2c_read_buf);
271 
bbc_i2c_interrupt(int irq,void * dev_id)272 static irqreturn_t bbc_i2c_interrupt(int irq, void *dev_id)
273 {
274 	struct bbc_i2c_bus *bp = dev_id;
275 
276 	/* PIN going from set to clear is the only event which
277 	 * makes the i2c assert an interrupt.
278 	 */
279 	if (bp->waiting &&
280 	    !(readb(bp->i2c_control_regs + 0x0) & I2C_PCF_PIN))
281 		wake_up_interruptible(&bp->wq);
282 
283 	return IRQ_HANDLED;
284 }
285 
reset_one_i2c(struct bbc_i2c_bus * bp)286 static void reset_one_i2c(struct bbc_i2c_bus *bp)
287 {
288 	writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
289 	writeb(bp->own, bp->i2c_control_regs + 0x1);
290 	writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
291 	writeb(bp->clock, bp->i2c_control_regs + 0x1);
292 	writeb(I2C_PCF_IDLE, bp->i2c_control_regs + 0x0);
293 }
294 
attach_one_i2c(struct platform_device * op,int index)295 static struct bbc_i2c_bus * attach_one_i2c(struct platform_device *op, int index)
296 {
297 	struct bbc_i2c_bus *bp;
298 	struct device_node *dp;
299 	int entry;
300 
301 	bp = kzalloc(sizeof(*bp), GFP_KERNEL);
302 	if (!bp)
303 		return NULL;
304 
305 	INIT_LIST_HEAD(&bp->temps);
306 	INIT_LIST_HEAD(&bp->fans);
307 
308 	bp->i2c_control_regs = of_ioremap(&op->resource[0], 0, 0x2, "bbc_i2c_regs");
309 	if (!bp->i2c_control_regs)
310 		goto fail;
311 
312 	if (op->num_resources == 2) {
313 		bp->i2c_bussel_reg = of_ioremap(&op->resource[1], 0, 0x1, "bbc_i2c_bussel");
314 		if (!bp->i2c_bussel_reg)
315 			goto fail;
316 	}
317 
318 	bp->waiting = 0;
319 	init_waitqueue_head(&bp->wq);
320 	if (request_irq(op->archdata.irqs[0], bbc_i2c_interrupt,
321 			IRQF_SHARED, "bbc_i2c", bp))
322 		goto fail;
323 
324 	bp->index = index;
325 	bp->op = op;
326 
327 	spin_lock_init(&bp->lock);
328 
329 	entry = 0;
330 	for (dp = op->dev.of_node->child;
331 	     dp && entry < 8;
332 	     dp = dp->sibling, entry++) {
333 		struct platform_device *child_op;
334 
335 		child_op = of_find_device_by_node(dp);
336 		bp->devs[entry].device = child_op;
337 		bp->devs[entry].client_claimed = 0;
338 	}
339 
340 	writeb(I2C_PCF_PIN, bp->i2c_control_regs + 0x0);
341 	bp->own = readb(bp->i2c_control_regs + 0x01);
342 	writeb(I2C_PCF_PIN | I2C_PCF_ES1, bp->i2c_control_regs + 0x0);
343 	bp->clock = readb(bp->i2c_control_regs + 0x01);
344 
345 	printk(KERN_INFO "i2c-%d: Regs at %p, %d devices, own %02x, clock %02x.\n",
346 	       bp->index, bp->i2c_control_regs, entry, bp->own, bp->clock);
347 
348 	reset_one_i2c(bp);
349 
350 	return bp;
351 
352 fail:
353 	if (bp->i2c_bussel_reg)
354 		of_iounmap(&op->resource[1], bp->i2c_bussel_reg, 1);
355 	if (bp->i2c_control_regs)
356 		of_iounmap(&op->resource[0], bp->i2c_control_regs, 2);
357 	kfree(bp);
358 	return NULL;
359 }
360 
361 extern int bbc_envctrl_init(struct bbc_i2c_bus *bp);
362 extern void bbc_envctrl_cleanup(struct bbc_i2c_bus *bp);
363 
bbc_i2c_probe(struct platform_device * op)364 static int bbc_i2c_probe(struct platform_device *op)
365 {
366 	struct bbc_i2c_bus *bp;
367 	int err, index = 0;
368 
369 	bp = attach_one_i2c(op, index);
370 	if (!bp)
371 		return -EINVAL;
372 
373 	err = bbc_envctrl_init(bp);
374 	if (err) {
375 		free_irq(op->archdata.irqs[0], bp);
376 		if (bp->i2c_bussel_reg)
377 			of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
378 		if (bp->i2c_control_regs)
379 			of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
380 		kfree(bp);
381 	} else {
382 		dev_set_drvdata(&op->dev, bp);
383 	}
384 
385 	return err;
386 }
387 
bbc_i2c_remove(struct platform_device * op)388 static int bbc_i2c_remove(struct platform_device *op)
389 {
390 	struct bbc_i2c_bus *bp = dev_get_drvdata(&op->dev);
391 
392 	bbc_envctrl_cleanup(bp);
393 
394 	free_irq(op->archdata.irqs[0], bp);
395 
396 	if (bp->i2c_bussel_reg)
397 		of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
398 	if (bp->i2c_control_regs)
399 		of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
400 
401 	kfree(bp);
402 
403 	return 0;
404 }
405 
406 static const struct of_device_id bbc_i2c_match[] = {
407 	{
408 		.name = "i2c",
409 		.compatible = "SUNW,bbc-i2c",
410 	},
411 	{},
412 };
413 MODULE_DEVICE_TABLE(of, bbc_i2c_match);
414 
415 static struct platform_driver bbc_i2c_driver = {
416 	.driver = {
417 		.name = "bbc_i2c",
418 		.of_match_table = bbc_i2c_match,
419 	},
420 	.probe		= bbc_i2c_probe,
421 	.remove		= bbc_i2c_remove,
422 };
423 
424 module_platform_driver(bbc_i2c_driver);
425 
426 MODULE_LICENSE("GPL");
427