xref: /openbmc/linux/drivers/i2c/busses/scx200_acb.c (revision b34e08d5)
1 /*
2     Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
3 
4     National Semiconductor SCx200 ACCESS.bus support
5     Also supports the AMD CS5535 and AMD CS5536
6 
7     Based on i2c-keywest.c which is:
8         Copyright (c) 2001 Benjamin Herrenschmidt <benh@kernel.crashing.org>
9         Copyright (c) 2000 Philip Edelbrock <phil@stimpy.netroedge.com>
10 
11     This program is free software; you can redistribute it and/or
12     modify it under the terms of the GNU General Public License as
13     published by the Free Software Foundation; either version 2 of the
14     License, or (at your option) any later version.
15 
16     This program is distributed in the hope that it will be useful,
17     but WITHOUT ANY WARRANTY; without even the implied warranty of
18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19     General Public License for more details.
20 
21     You should have received a copy of the GNU General Public License
22     along with this program; if not, write to the Free Software
23     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25 
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27 
28 #include <linux/module.h>
29 #include <linux/errno.h>
30 #include <linux/kernel.h>
31 #include <linux/init.h>
32 #include <linux/i2c.h>
33 #include <linux/pci.h>
34 #include <linux/platform_device.h>
35 #include <linux/delay.h>
36 #include <linux/mutex.h>
37 #include <linux/slab.h>
38 #include <linux/io.h>
39 
40 #include <linux/scx200.h>
41 
42 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
43 MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver");
44 MODULE_ALIAS("platform:cs5535-smb");
45 MODULE_LICENSE("GPL");
46 
47 #define MAX_DEVICES 4
48 static int base[MAX_DEVICES] = { 0x820, 0x840 };
49 module_param_array(base, int, NULL, 0);
50 MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers");
51 
52 #define POLL_TIMEOUT	(HZ/5)
53 
54 enum scx200_acb_state {
55 	state_idle,
56 	state_address,
57 	state_command,
58 	state_repeat_start,
59 	state_quick,
60 	state_read,
61 	state_write,
62 };
63 
64 static const char *scx200_acb_state_name[] = {
65 	"idle",
66 	"address",
67 	"command",
68 	"repeat_start",
69 	"quick",
70 	"read",
71 	"write",
72 };
73 
74 /* Physical interface */
75 struct scx200_acb_iface {
76 	struct scx200_acb_iface *next;
77 	struct i2c_adapter adapter;
78 	unsigned base;
79 	struct mutex mutex;
80 
81 	/* State machine data */
82 	enum scx200_acb_state state;
83 	int result;
84 	u8 address_byte;
85 	u8 command;
86 	u8 *ptr;
87 	char needs_reset;
88 	unsigned len;
89 };
90 
91 /* Register Definitions */
92 #define ACBSDA		(iface->base + 0)
93 #define ACBST		(iface->base + 1)
94 #define    ACBST_SDAST		0x40 /* SDA Status */
95 #define    ACBST_BER		0x20
96 #define    ACBST_NEGACK		0x10 /* Negative Acknowledge */
97 #define    ACBST_STASTR		0x08 /* Stall After Start */
98 #define    ACBST_MASTER		0x02
99 #define ACBCST		(iface->base + 2)
100 #define    ACBCST_BB		0x02
101 #define ACBCTL1		(iface->base + 3)
102 #define    ACBCTL1_STASTRE	0x80
103 #define    ACBCTL1_NMINTE	0x40
104 #define    ACBCTL1_ACK		0x10
105 #define    ACBCTL1_STOP		0x02
106 #define    ACBCTL1_START	0x01
107 #define ACBADDR		(iface->base + 4)
108 #define ACBCTL2		(iface->base + 5)
109 #define    ACBCTL2_ENABLE	0x01
110 
111 /************************************************************************/
112 
113 static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
114 {
115 	const char *errmsg;
116 
117 	dev_dbg(&iface->adapter.dev, "state %s, status = 0x%02x\n",
118 		scx200_acb_state_name[iface->state], status);
119 
120 	if (status & ACBST_BER) {
121 		errmsg = "bus error";
122 		goto error;
123 	}
124 	if (!(status & ACBST_MASTER)) {
125 		errmsg = "not master";
126 		goto error;
127 	}
128 	if (status & ACBST_NEGACK) {
129 		dev_dbg(&iface->adapter.dev, "negative ack in state %s\n",
130 			scx200_acb_state_name[iface->state]);
131 
132 		iface->state = state_idle;
133 		iface->result = -ENXIO;
134 
135 		outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
136 		outb(ACBST_STASTR | ACBST_NEGACK, ACBST);
137 
138 		/* Reset the status register */
139 		outb(0, ACBST);
140 		return;
141 	}
142 
143 	switch (iface->state) {
144 	case state_idle:
145 		dev_warn(&iface->adapter.dev, "interrupt in idle state\n");
146 		break;
147 
148 	case state_address:
149 		/* Do a pointer write first */
150 		outb(iface->address_byte & ~1, ACBSDA);
151 
152 		iface->state = state_command;
153 		break;
154 
155 	case state_command:
156 		outb(iface->command, ACBSDA);
157 
158 		if (iface->address_byte & 1)
159 			iface->state = state_repeat_start;
160 		else
161 			iface->state = state_write;
162 		break;
163 
164 	case state_repeat_start:
165 		outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
166 		/* fallthrough */
167 
168 	case state_quick:
169 		if (iface->address_byte & 1) {
170 			if (iface->len == 1)
171 				outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
172 			else
173 				outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
174 			outb(iface->address_byte, ACBSDA);
175 
176 			iface->state = state_read;
177 		} else {
178 			outb(iface->address_byte, ACBSDA);
179 
180 			iface->state = state_write;
181 		}
182 		break;
183 
184 	case state_read:
185 		/* Set ACK if _next_ byte will be the last one */
186 		if (iface->len == 2)
187 			outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
188 		else
189 			outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
190 
191 		if (iface->len == 1) {
192 			iface->result = 0;
193 			iface->state = state_idle;
194 			outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
195 		}
196 
197 		*iface->ptr++ = inb(ACBSDA);
198 		--iface->len;
199 
200 		break;
201 
202 	case state_write:
203 		if (iface->len == 0) {
204 			iface->result = 0;
205 			iface->state = state_idle;
206 			outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
207 			break;
208 		}
209 
210 		outb(*iface->ptr++, ACBSDA);
211 		--iface->len;
212 
213 		break;
214 	}
215 
216 	return;
217 
218  error:
219 	dev_err(&iface->adapter.dev,
220 		"%s in state %s (addr=0x%02x, len=%d, status=0x%02x)\n", errmsg,
221 		scx200_acb_state_name[iface->state], iface->address_byte,
222 		iface->len, status);
223 
224 	iface->state = state_idle;
225 	iface->result = -EIO;
226 	iface->needs_reset = 1;
227 }
228 
229 static void scx200_acb_poll(struct scx200_acb_iface *iface)
230 {
231 	u8 status;
232 	unsigned long timeout;
233 
234 	timeout = jiffies + POLL_TIMEOUT;
235 	while (1) {
236 		status = inb(ACBST);
237 
238 		/* Reset the status register to avoid the hang */
239 		outb(0, ACBST);
240 
241 		if ((status & (ACBST_SDAST|ACBST_BER|ACBST_NEGACK)) != 0) {
242 			scx200_acb_machine(iface, status);
243 			return;
244 		}
245 		if (time_after(jiffies, timeout))
246 			break;
247 		cpu_relax();
248 		cond_resched();
249 	}
250 
251 	dev_err(&iface->adapter.dev, "timeout in state %s\n",
252 		scx200_acb_state_name[iface->state]);
253 
254 	iface->state = state_idle;
255 	iface->result = -EIO;
256 	iface->needs_reset = 1;
257 }
258 
259 static void scx200_acb_reset(struct scx200_acb_iface *iface)
260 {
261 	/* Disable the ACCESS.bus device and Configure the SCL
262 	   frequency: 16 clock cycles */
263 	outb(0x70, ACBCTL2);
264 	/* Polling mode */
265 	outb(0, ACBCTL1);
266 	/* Disable slave address */
267 	outb(0, ACBADDR);
268 	/* Enable the ACCESS.bus device */
269 	outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
270 	/* Free STALL after START */
271 	outb(inb(ACBCTL1) & ~(ACBCTL1_STASTRE | ACBCTL1_NMINTE), ACBCTL1);
272 	/* Send a STOP */
273 	outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
274 	/* Clear BER, NEGACK and STASTR bits */
275 	outb(ACBST_BER | ACBST_NEGACK | ACBST_STASTR, ACBST);
276 	/* Clear BB bit */
277 	outb(inb(ACBCST) | ACBCST_BB, ACBCST);
278 }
279 
280 static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
281 				 u16 address, unsigned short flags,
282 				 char rw, u8 command, int size,
283 				 union i2c_smbus_data *data)
284 {
285 	struct scx200_acb_iface *iface = i2c_get_adapdata(adapter);
286 	int len;
287 	u8 *buffer;
288 	u16 cur_word;
289 	int rc;
290 
291 	switch (size) {
292 	case I2C_SMBUS_QUICK:
293 		len = 0;
294 		buffer = NULL;
295 		break;
296 
297 	case I2C_SMBUS_BYTE:
298 		len = 1;
299 		buffer = rw ? &data->byte : &command;
300 		break;
301 
302 	case I2C_SMBUS_BYTE_DATA:
303 		len = 1;
304 		buffer = &data->byte;
305 		break;
306 
307 	case I2C_SMBUS_WORD_DATA:
308 		len = 2;
309 		cur_word = cpu_to_le16(data->word);
310 		buffer = (u8 *)&cur_word;
311 		break;
312 
313 	case I2C_SMBUS_I2C_BLOCK_DATA:
314 		len = data->block[0];
315 		if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
316 			return -EINVAL;
317 		buffer = &data->block[1];
318 		break;
319 
320 	default:
321 		return -EINVAL;
322 	}
323 
324 	dev_dbg(&adapter->dev,
325 		"size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
326 		size, address, command, len, rw);
327 
328 	if (!len && rw == I2C_SMBUS_READ) {
329 		dev_dbg(&adapter->dev, "zero length read\n");
330 		return -EINVAL;
331 	}
332 
333 	mutex_lock(&iface->mutex);
334 
335 	iface->address_byte = (address << 1) | rw;
336 	iface->command = command;
337 	iface->ptr = buffer;
338 	iface->len = len;
339 	iface->result = -EINVAL;
340 	iface->needs_reset = 0;
341 
342 	outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
343 
344 	if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE)
345 		iface->state = state_quick;
346 	else
347 		iface->state = state_address;
348 
349 	while (iface->state != state_idle)
350 		scx200_acb_poll(iface);
351 
352 	if (iface->needs_reset)
353 		scx200_acb_reset(iface);
354 
355 	rc = iface->result;
356 
357 	mutex_unlock(&iface->mutex);
358 
359 	if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ)
360 		data->word = le16_to_cpu(cur_word);
361 
362 #ifdef DEBUG
363 	dev_dbg(&adapter->dev, "transfer done, result: %d", rc);
364 	if (buffer) {
365 		int i;
366 		printk(" data:");
367 		for (i = 0; i < len; ++i)
368 			printk(" %02x", buffer[i]);
369 	}
370 	printk("\n");
371 #endif
372 
373 	return rc;
374 }
375 
376 static u32 scx200_acb_func(struct i2c_adapter *adapter)
377 {
378 	return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
379 	       I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
380 	       I2C_FUNC_SMBUS_I2C_BLOCK;
381 }
382 
383 /* For now, we only handle combined mode (smbus) */
384 static const struct i2c_algorithm scx200_acb_algorithm = {
385 	.smbus_xfer	= scx200_acb_smbus_xfer,
386 	.functionality	= scx200_acb_func,
387 };
388 
389 static struct scx200_acb_iface *scx200_acb_list;
390 static DEFINE_MUTEX(scx200_acb_list_mutex);
391 
392 static int scx200_acb_probe(struct scx200_acb_iface *iface)
393 {
394 	u8 val;
395 
396 	/* Disable the ACCESS.bus device and Configure the SCL
397 	   frequency: 16 clock cycles */
398 	outb(0x70, ACBCTL2);
399 
400 	if (inb(ACBCTL2) != 0x70) {
401 		pr_debug("ACBCTL2 readback failed\n");
402 		return -ENXIO;
403 	}
404 
405 	outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);
406 
407 	val = inb(ACBCTL1);
408 	if (val) {
409 		pr_debug("disabled, but ACBCTL1=0x%02x\n", val);
410 		return -ENXIO;
411 	}
412 
413 	outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
414 
415 	outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);
416 
417 	val = inb(ACBCTL1);
418 	if ((val & ACBCTL1_NMINTE) != ACBCTL1_NMINTE) {
419 		pr_debug("enabled, but NMINTE won't be set, ACBCTL1=0x%02x\n",
420 			 val);
421 		return -ENXIO;
422 	}
423 
424 	return 0;
425 }
426 
427 static struct scx200_acb_iface *scx200_create_iface(const char *text,
428 		struct device *dev, int index)
429 {
430 	struct scx200_acb_iface *iface;
431 	struct i2c_adapter *adapter;
432 
433 	iface = kzalloc(sizeof(*iface), GFP_KERNEL);
434 	if (!iface) {
435 		pr_err("can't allocate memory\n");
436 		return NULL;
437 	}
438 
439 	adapter = &iface->adapter;
440 	i2c_set_adapdata(adapter, iface);
441 	snprintf(adapter->name, sizeof(adapter->name), "%s ACB%d", text, index);
442 	adapter->owner = THIS_MODULE;
443 	adapter->algo = &scx200_acb_algorithm;
444 	adapter->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
445 	adapter->dev.parent = dev;
446 
447 	mutex_init(&iface->mutex);
448 
449 	return iface;
450 }
451 
452 static int scx200_acb_create(struct scx200_acb_iface *iface)
453 {
454 	struct i2c_adapter *adapter;
455 	int rc;
456 
457 	adapter = &iface->adapter;
458 
459 	rc = scx200_acb_probe(iface);
460 	if (rc) {
461 		pr_warn("probe failed\n");
462 		return rc;
463 	}
464 
465 	scx200_acb_reset(iface);
466 
467 	if (i2c_add_adapter(adapter) < 0) {
468 		pr_err("failed to register\n");
469 		return -ENODEV;
470 	}
471 
472 	if (!adapter->dev.parent) {
473 		/* If there's no dev, we're tracking (ISA) ifaces manually */
474 		mutex_lock(&scx200_acb_list_mutex);
475 		iface->next = scx200_acb_list;
476 		scx200_acb_list = iface;
477 		mutex_unlock(&scx200_acb_list_mutex);
478 	}
479 
480 	return 0;
481 }
482 
483 static struct scx200_acb_iface *scx200_create_dev(const char *text,
484 		unsigned long base, int index, struct device *dev)
485 {
486 	struct scx200_acb_iface *iface;
487 	int rc;
488 
489 	iface = scx200_create_iface(text, dev, index);
490 
491 	if (iface == NULL)
492 		return NULL;
493 
494 	if (!request_region(base, 8, iface->adapter.name)) {
495 		pr_err("can't allocate io 0x%lx-0x%lx\n", base, base + 8 - 1);
496 		goto errout_free;
497 	}
498 
499 	iface->base = base;
500 	rc = scx200_acb_create(iface);
501 
502 	if (rc == 0)
503 		return iface;
504 
505 	release_region(base, 8);
506  errout_free:
507 	kfree(iface);
508 	return NULL;
509 }
510 
511 static int scx200_probe(struct platform_device *pdev)
512 {
513 	struct scx200_acb_iface *iface;
514 	struct resource *res;
515 
516 	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
517 	if (!res) {
518 		dev_err(&pdev->dev, "can't fetch device resource info\n");
519 		return -ENODEV;
520 	}
521 
522 	iface = scx200_create_dev("CS5535", res->start, 0, &pdev->dev);
523 	if (!iface)
524 		return -EIO;
525 
526 	dev_info(&pdev->dev, "SCx200 device '%s' registered\n",
527 			iface->adapter.name);
528 	platform_set_drvdata(pdev, iface);
529 
530 	return 0;
531 }
532 
533 static void scx200_cleanup_iface(struct scx200_acb_iface *iface)
534 {
535 	i2c_del_adapter(&iface->adapter);
536 	release_region(iface->base, 8);
537 	kfree(iface);
538 }
539 
540 static int scx200_remove(struct platform_device *pdev)
541 {
542 	struct scx200_acb_iface *iface;
543 
544 	iface = platform_get_drvdata(pdev);
545 	scx200_cleanup_iface(iface);
546 
547 	return 0;
548 }
549 
550 static struct platform_driver scx200_pci_driver = {
551 	.driver = {
552 		.name = "cs5535-smb",
553 		.owner = THIS_MODULE,
554 	},
555 	.probe = scx200_probe,
556 	.remove = scx200_remove,
557 };
558 
559 static const struct pci_device_id scx200_isa[] = {
560 	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
561 	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
562 	{ 0, }
563 };
564 
565 static __init void scx200_scan_isa(void)
566 {
567 	int i;
568 
569 	if (!pci_dev_present(scx200_isa))
570 		return;
571 
572 	for (i = 0; i < MAX_DEVICES; ++i) {
573 		if (base[i] == 0)
574 			continue;
575 
576 		/* XXX: should we care about failures? */
577 		scx200_create_dev("SCx200", base[i], i, NULL);
578 	}
579 }
580 
581 static int __init scx200_acb_init(void)
582 {
583 	pr_debug("NatSemi SCx200 ACCESS.bus Driver\n");
584 
585 	/* First scan for ISA-based devices */
586 	scx200_scan_isa();	/* XXX: should we care about errors? */
587 
588 	/* If at least one bus was created, init must succeed */
589 	if (scx200_acb_list)
590 		return 0;
591 
592 	/* No ISA devices; register the platform driver for PCI-based devices */
593 	return platform_driver_register(&scx200_pci_driver);
594 }
595 
596 static void __exit scx200_acb_cleanup(void)
597 {
598 	struct scx200_acb_iface *iface;
599 
600 	platform_driver_unregister(&scx200_pci_driver);
601 
602 	mutex_lock(&scx200_acb_list_mutex);
603 	while ((iface = scx200_acb_list) != NULL) {
604 		scx200_acb_list = iface->next;
605 		mutex_unlock(&scx200_acb_list_mutex);
606 
607 		scx200_cleanup_iface(iface);
608 
609 		mutex_lock(&scx200_acb_list_mutex);
610 	}
611 	mutex_unlock(&scx200_acb_list_mutex);
612 }
613 
614 module_init(scx200_acb_init);
615 module_exit(scx200_acb_cleanup);
616