2 Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
4 National Semiconductor SCx200 ACCESS.bus support
6 Based on i2c-keywest.c which is:
7 Copyright (c) 2001 Benjamin Herrenschmidt <benh@kernel.crashing.org>
8 Copyright (c) 2000 Philip Edelbrock <phil@stimpy.netroedge.com>
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2 of the
13 License, or (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <linux/module.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/init.h>
29 #include <linux/i2c.h>
30 #include <linux/smp_lock.h>
31 #include <linux/pci.h>
32 #include <linux/delay.h>
35 #include <linux/scx200.h>
37 #define NAME "scx200_acb"
39 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
40 MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver");
41 MODULE_LICENSE("GPL");
44 static int base[MAX_DEVICES] = { 0x820, 0x840 };
45 module_param_array(base, int, NULL, 0);
46 MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers");
49 #define DBG(x...) printk(KERN_DEBUG NAME ": " x)
54 /* The hardware supports interrupt driven mode too, but I haven't
57 #define POLL_TIMEOUT (HZ)
59 enum scx200_acb_state {
69 static const char *scx200_acb_state_name[] = {
79 /* Physical interface */
80 struct scx200_acb_iface {
81 struct scx200_acb_iface *next;
82 struct i2c_adapter adapter;
86 /* State machine data */
87 enum scx200_acb_state state;
96 /* Register Definitions */
97 #define ACBSDA (iface->base + 0)
98 #define ACBST (iface->base + 1)
99 #define ACBST_SDAST 0x40 /* SDA Status */
100 #define ACBST_BER 0x20
101 #define ACBST_NEGACK 0x10 /* Negative Acknowledge */
102 #define ACBST_STASTR 0x08 /* Stall After Start */
103 #define ACBST_MASTER 0x02
104 #define ACBCST (iface->base + 2)
105 #define ACBCST_BB 0x02
106 #define ACBCTL1 (iface->base + 3)
107 #define ACBCTL1_STASTRE 0x80
108 #define ACBCTL1_NMINTE 0x40
109 #define ACBCTL1_ACK 0x10
110 #define ACBCTL1_STOP 0x02
111 #define ACBCTL1_START 0x01
112 #define ACBADDR (iface->base + 4)
113 #define ACBCTL2 (iface->base + 5)
114 #define ACBCTL2_ENABLE 0x01
116 /************************************************************************/
118 static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
122 DBG("state %s, status = 0x%02x\n",
123 scx200_acb_state_name[iface->state], status);
125 if (status & ACBST_BER) {
126 errmsg = "bus error";
129 if (!(status & ACBST_MASTER)) {
130 errmsg = "not master";
133 if (status & ACBST_NEGACK)
136 switch (iface->state) {
138 dev_warn(&iface->adapter.dev, "interrupt in idle state\n");
142 /* Do a pointer write first */
143 outb(iface->address_byte & ~1, ACBSDA);
145 iface->state = state_command;
149 outb(iface->command, ACBSDA);
151 if (iface->address_byte & 1)
152 iface->state = state_repeat_start;
154 iface->state = state_write;
157 case state_repeat_start:
158 outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
162 if (iface->address_byte & 1) {
164 outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
166 outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
167 outb(iface->address_byte, ACBSDA);
169 iface->state = state_read;
171 outb(iface->address_byte, ACBSDA);
173 iface->state = state_write;
178 /* Set ACK if receiving the last byte */
180 outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
182 outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
184 *iface->ptr++ = inb(ACBSDA);
187 if (iface->len == 0) {
189 iface->state = state_idle;
190 outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
196 if (iface->len == 0) {
198 iface->state = state_idle;
199 outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
203 outb(*iface->ptr++, ACBSDA);
212 DBG("negative acknowledge in state %s\n",
213 scx200_acb_state_name[iface->state]);
215 iface->state = state_idle;
216 iface->result = -ENXIO;
218 outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
219 outb(ACBST_STASTR | ACBST_NEGACK, ACBST);
223 dev_err(&iface->adapter.dev, "%s in state %s\n", errmsg,
224 scx200_acb_state_name[iface->state]);
226 iface->state = state_idle;
227 iface->result = -EIO;
228 iface->needs_reset = 1;
231 static void scx200_acb_timeout(struct scx200_acb_iface *iface)
233 dev_err(&iface->adapter.dev, "timeout in state %s\n",
234 scx200_acb_state_name[iface->state]);
236 iface->state = state_idle;
237 iface->result = -EIO;
238 iface->needs_reset = 1;
242 static void scx200_acb_poll(struct scx200_acb_iface *iface)
245 unsigned long timeout;
247 timeout = jiffies + POLL_TIMEOUT;
248 while (time_before(jiffies, timeout)) {
250 if ((status & (ACBST_SDAST|ACBST_BER|ACBST_NEGACK)) != 0) {
251 scx200_acb_machine(iface, status);
257 scx200_acb_timeout(iface);
259 #endif /* POLLED_MODE */
261 static void scx200_acb_reset(struct scx200_acb_iface *iface)
263 /* Disable the ACCESS.bus device and Configure the SCL
264 frequency: 16 clock cycles */
268 /* Disable slave address */
270 /* Enable the ACCESS.bus device */
271 outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
272 /* Free STALL after START */
273 outb(inb(ACBCTL1) & ~(ACBCTL1_STASTRE | ACBCTL1_NMINTE), ACBCTL1);
275 outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
276 /* Clear BER, NEGACK and STASTR bits */
277 outb(ACBST_BER | ACBST_NEGACK | ACBST_STASTR, ACBST);
279 outb(inb(ACBCST) | ACBCST_BB, ACBCST);
282 static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
283 u16 address, unsigned short flags,
284 char rw, u8 command, int size,
285 union i2c_smbus_data *data)
287 struct scx200_acb_iface *iface = i2c_get_adapdata(adapter);
294 case I2C_SMBUS_QUICK:
300 if (rw == I2C_SMBUS_READ) {
302 buffer = &data->byte;
309 case I2C_SMBUS_BYTE_DATA:
311 buffer = &data->byte;
314 case I2C_SMBUS_WORD_DATA:
316 cur_word = cpu_to_le16(data->word);
317 buffer = (u8 *)&cur_word;
320 case I2C_SMBUS_BLOCK_DATA:
321 len = data->block[0];
322 buffer = &data->block[1];
329 DBG("size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
330 size, address, command, len, rw == I2C_SMBUS_READ);
332 if (!len && rw == I2C_SMBUS_READ) {
333 dev_warn(&adapter->dev, "zero length read\n");
337 if (len && !buffer) {
338 dev_warn(&adapter->dev, "nonzero length but no buffer\n");
344 iface->address_byte = address<<1;
345 if (rw == I2C_SMBUS_READ)
346 iface->address_byte |= 1;
347 iface->command = command;
350 iface->result = -EINVAL;
351 iface->needs_reset = 0;
353 outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
355 if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE)
356 iface->state = state_quick;
358 iface->state = state_address;
361 while (iface->state != state_idle)
362 scx200_acb_poll(iface);
363 #else /* POLLED_MODE */
364 #error Interrupt driven mode not implemented
365 #endif /* POLLED_MODE */
367 if (iface->needs_reset)
368 scx200_acb_reset(iface);
374 if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ)
375 data->word = le16_to_cpu(cur_word);
378 DBG(": transfer done, result: %d", rc);
382 for (i = 0; i < len; ++i)
383 printk(" %02x", buffer[i]);
391 static u32 scx200_acb_func(struct i2c_adapter *adapter)
393 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
394 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
395 I2C_FUNC_SMBUS_BLOCK_DATA;
398 /* For now, we only handle combined mode (smbus) */
399 static struct i2c_algorithm scx200_acb_algorithm = {
400 .smbus_xfer = scx200_acb_smbus_xfer,
401 .functionality = scx200_acb_func,
404 static struct scx200_acb_iface *scx200_acb_list;
406 static int scx200_acb_probe(struct scx200_acb_iface *iface)
410 /* Disable the ACCESS.bus device and Configure the SCL
411 frequency: 16 clock cycles */
414 if (inb(ACBCTL2) != 0x70) {
415 DBG("ACBCTL2 readback failed\n");
419 outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);
423 DBG("disabled, but ACBCTL1=0x%02x\n", val);
427 outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
429 outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);
432 if ((val & ACBCTL1_NMINTE) != ACBCTL1_NMINTE) {
433 DBG("enabled, but NMINTE won't be set, ACBCTL1=0x%02x\n", val);
440 static int __init scx200_acb_create(int base, int index)
442 struct scx200_acb_iface *iface;
443 struct i2c_adapter *adapter;
445 char description[64];
447 iface = kzalloc(sizeof(*iface), GFP_KERNEL);
449 printk(KERN_ERR NAME ": can't allocate memory\n");
454 adapter = &iface->adapter;
455 i2c_set_adapdata(adapter, iface);
456 snprintf(adapter->name, I2C_NAME_SIZE, "SCx200 ACB%d", index);
457 adapter->owner = THIS_MODULE;
458 adapter->id = I2C_HW_SMBUS_SCX200;
459 adapter->algo = &scx200_acb_algorithm;
460 adapter->class = I2C_CLASS_HWMON;
462 init_MUTEX(&iface->sem);
464 snprintf(description, sizeof(description),
465 "NatSemi SCx200 ACCESS.bus [%s]", adapter->name);
466 if (request_region(base, 8, description) == 0) {
467 dev_err(&adapter->dev, "can't allocate io 0x%x-0x%x\n",
474 rc = scx200_acb_probe(iface);
476 dev_warn(&adapter->dev, "probe failed\n");
480 scx200_acb_reset(iface);
482 if (i2c_add_adapter(adapter) < 0) {
483 dev_err(&adapter->dev, "failed to register\n");
489 iface->next = scx200_acb_list;
490 scx200_acb_list = iface;
498 release_region(iface->base, 8);
504 static struct pci_device_id scx200[] = {
505 { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
506 { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
510 static int __init scx200_acb_init(void)
515 pr_debug(NAME ": NatSemi SCx200 ACCESS.bus Driver\n");
517 /* Verify that this really is a SCx200 processor */
518 if (pci_dev_present(scx200) == 0)
522 for (i = 0; i < MAX_DEVICES; ++i) {
524 rc = scx200_acb_create(base[i], i);
531 static void __exit scx200_acb_cleanup(void)
533 struct scx200_acb_iface *iface;
536 while ((iface = scx200_acb_list) != NULL) {
537 scx200_acb_list = iface->next;
540 i2c_del_adapter(&iface->adapter);
541 release_region(iface->base, 8);
548 module_init(scx200_acb_init);
549 module_exit(scx200_acb_cleanup);