2 Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
4 National Semiconductor SCx200 ACCESS.bus support
5 Also supports the AMD CS5535 and AMD CS5536
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>
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.
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.
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.
26 #include <linux/module.h>
27 #include <linux/errno.h>
28 #include <linux/kernel.h>
29 #include <linux/init.h>
30 #include <linux/i2c.h>
31 #include <linux/smp_lock.h>
32 #include <linux/pci.h>
33 #include <linux/delay.h>
34 #include <linux/mutex.h>
37 #include <linux/scx200.h>
39 #define NAME "scx200_acb"
41 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
42 MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver");
43 MODULE_LICENSE("GPL");
46 static int base
[MAX_DEVICES
] = { 0x820, 0x840 };
47 module_param_array(base
, int, NULL
, 0);
48 MODULE_PARM_DESC(base
, "Base addresses for the ACCESS.bus controllers");
50 #define POLL_TIMEOUT (HZ/5)
52 enum scx200_acb_state
{
62 static const char *scx200_acb_state_name
[] = {
72 /* Physical interface */
73 struct scx200_acb_iface
{
74 struct scx200_acb_iface
*next
;
75 struct i2c_adapter adapter
;
79 /* State machine data */
80 enum scx200_acb_state state
;
93 /* Register Definitions */
94 #define ACBSDA (iface->base + 0)
95 #define ACBST (iface->base + 1)
96 #define ACBST_SDAST 0x40 /* SDA Status */
97 #define ACBST_BER 0x20
98 #define ACBST_NEGACK 0x10 /* Negative Acknowledge */
99 #define ACBST_STASTR 0x08 /* Stall After Start */
100 #define ACBST_MASTER 0x02
101 #define ACBCST (iface->base + 2)
102 #define ACBCST_BB 0x02
103 #define ACBCTL1 (iface->base + 3)
104 #define ACBCTL1_STASTRE 0x80
105 #define ACBCTL1_NMINTE 0x40
106 #define ACBCTL1_ACK 0x10
107 #define ACBCTL1_STOP 0x02
108 #define ACBCTL1_START 0x01
109 #define ACBADDR (iface->base + 4)
110 #define ACBCTL2 (iface->base + 5)
111 #define ACBCTL2_ENABLE 0x01
113 /************************************************************************/
115 static void scx200_acb_machine(struct scx200_acb_iface
*iface
, u8 status
)
119 dev_dbg(&iface
->adapter
.dev
, "state %s, status = 0x%02x\n",
120 scx200_acb_state_name
[iface
->state
], status
);
122 if (status
& ACBST_BER
) {
123 errmsg
= "bus error";
126 if (!(status
& ACBST_MASTER
)) {
127 errmsg
= "not master";
130 if (status
& ACBST_NEGACK
) {
131 dev_dbg(&iface
->adapter
.dev
, "negative ack in state %s\n",
132 scx200_acb_state_name
[iface
->state
]);
134 iface
->state
= state_idle
;
135 iface
->result
= -ENXIO
;
137 outb(inb(ACBCTL1
) | ACBCTL1_STOP
, ACBCTL1
);
138 outb(ACBST_STASTR
| ACBST_NEGACK
, ACBST
);
140 /* Reset the status register */
145 switch (iface
->state
) {
147 dev_warn(&iface
->adapter
.dev
, "interrupt in idle state\n");
151 /* Do a pointer write first */
152 outb(iface
->address_byte
& ~1, ACBSDA
);
154 iface
->state
= state_command
;
158 outb(iface
->command
, ACBSDA
);
160 if (iface
->address_byte
& 1)
161 iface
->state
= state_repeat_start
;
163 iface
->state
= state_write
;
166 case state_repeat_start
:
167 outb(inb(ACBCTL1
) | ACBCTL1_START
, ACBCTL1
);
171 if (iface
->address_byte
& 1) {
173 outb(inb(ACBCTL1
) | ACBCTL1_ACK
, ACBCTL1
);
175 outb(inb(ACBCTL1
) & ~ACBCTL1_ACK
, ACBCTL1
);
176 outb(iface
->address_byte
, ACBSDA
);
178 iface
->state
= state_read
;
180 outb(iface
->address_byte
, ACBSDA
);
182 iface
->state
= state_write
;
187 /* Set ACK if receiving the last byte */
189 outb(inb(ACBCTL1
) | ACBCTL1_ACK
, ACBCTL1
);
191 outb(inb(ACBCTL1
) & ~ACBCTL1_ACK
, ACBCTL1
);
193 *iface
->ptr
++ = inb(ACBSDA
);
196 if (iface
->len
== 0) {
198 iface
->state
= state_idle
;
199 outb(inb(ACBCTL1
) | ACBCTL1_STOP
, ACBCTL1
);
205 if (iface
->len
== 0) {
207 iface
->state
= state_idle
;
208 outb(inb(ACBCTL1
) | ACBCTL1_STOP
, ACBCTL1
);
212 outb(*iface
->ptr
++, ACBSDA
);
221 dev_err(&iface
->adapter
.dev
, "%s in state %s\n", errmsg
,
222 scx200_acb_state_name
[iface
->state
]);
224 iface
->state
= state_idle
;
225 iface
->result
= -EIO
;
226 iface
->needs_reset
= 1;
229 static void scx200_acb_poll(struct scx200_acb_iface
*iface
)
232 unsigned long timeout
;
234 timeout
= jiffies
+ POLL_TIMEOUT
;
235 while (time_before(jiffies
, timeout
)) {
238 /* Reset the status register to avoid the hang */
241 if ((status
& (ACBST_SDAST
|ACBST_BER
|ACBST_NEGACK
)) != 0) {
242 scx200_acb_machine(iface
, status
);
248 dev_err(&iface
->adapter
.dev
, "timeout in state %s\n",
249 scx200_acb_state_name
[iface
->state
]);
251 iface
->state
= state_idle
;
252 iface
->result
= -EIO
;
253 iface
->needs_reset
= 1;
256 static void scx200_acb_reset(struct scx200_acb_iface
*iface
)
258 /* Disable the ACCESS.bus device and Configure the SCL
259 frequency: 16 clock cycles */
263 /* Disable slave address */
265 /* Enable the ACCESS.bus device */
266 outb(inb(ACBCTL2
) | ACBCTL2_ENABLE
, ACBCTL2
);
267 /* Free STALL after START */
268 outb(inb(ACBCTL1
) & ~(ACBCTL1_STASTRE
| ACBCTL1_NMINTE
), ACBCTL1
);
270 outb(inb(ACBCTL1
) | ACBCTL1_STOP
, ACBCTL1
);
271 /* Clear BER, NEGACK and STASTR bits */
272 outb(ACBST_BER
| ACBST_NEGACK
| ACBST_STASTR
, ACBST
);
274 outb(inb(ACBCST
) | ACBCST_BB
, ACBCST
);
277 static s32
scx200_acb_smbus_xfer(struct i2c_adapter
*adapter
,
278 u16 address
, unsigned short flags
,
279 char rw
, u8 command
, int size
,
280 union i2c_smbus_data
*data
)
282 struct scx200_acb_iface
*iface
= i2c_get_adapdata(adapter
);
289 case I2C_SMBUS_QUICK
:
296 buffer
= rw
? &data
->byte
: &command
;
299 case I2C_SMBUS_BYTE_DATA
:
301 buffer
= &data
->byte
;
304 case I2C_SMBUS_WORD_DATA
:
306 cur_word
= cpu_to_le16(data
->word
);
307 buffer
= (u8
*)&cur_word
;
310 case I2C_SMBUS_BLOCK_DATA
:
311 len
= data
->block
[0];
312 buffer
= &data
->block
[1];
319 dev_dbg(&adapter
->dev
,
320 "size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
321 size
, address
, command
, len
, rw
);
323 if (!len
&& rw
== I2C_SMBUS_READ
) {
324 dev_dbg(&adapter
->dev
, "zero length read\n");
328 mutex_lock(&iface
->mutex
);
330 iface
->address_byte
= (address
<< 1) | rw
;
331 iface
->command
= command
;
334 iface
->result
= -EINVAL
;
335 iface
->needs_reset
= 0;
337 outb(inb(ACBCTL1
) | ACBCTL1_START
, ACBCTL1
);
339 if (size
== I2C_SMBUS_QUICK
|| size
== I2C_SMBUS_BYTE
)
340 iface
->state
= state_quick
;
342 iface
->state
= state_address
;
344 while (iface
->state
!= state_idle
)
345 scx200_acb_poll(iface
);
347 if (iface
->needs_reset
)
348 scx200_acb_reset(iface
);
352 mutex_unlock(&iface
->mutex
);
354 if (rc
== 0 && size
== I2C_SMBUS_WORD_DATA
&& rw
== I2C_SMBUS_READ
)
355 data
->word
= le16_to_cpu(cur_word
);
358 dev_dbg(&adapter
->dev
, "transfer done, result: %d", rc
);
362 for (i
= 0; i
< len
; ++i
)
363 printk(" %02x", buffer
[i
]);
371 static u32
scx200_acb_func(struct i2c_adapter
*adapter
)
373 return I2C_FUNC_SMBUS_QUICK
| I2C_FUNC_SMBUS_BYTE
|
374 I2C_FUNC_SMBUS_BYTE_DATA
| I2C_FUNC_SMBUS_WORD_DATA
|
375 I2C_FUNC_SMBUS_BLOCK_DATA
;
378 /* For now, we only handle combined mode (smbus) */
379 static struct i2c_algorithm scx200_acb_algorithm
= {
380 .smbus_xfer
= scx200_acb_smbus_xfer
,
381 .functionality
= scx200_acb_func
,
384 static struct scx200_acb_iface
*scx200_acb_list
;
385 static DECLARE_MUTEX(scx200_acb_list_mutex
);
387 static __init
int scx200_acb_probe(struct scx200_acb_iface
*iface
)
391 /* Disable the ACCESS.bus device and Configure the SCL
392 frequency: 16 clock cycles */
395 if (inb(ACBCTL2
) != 0x70) {
396 pr_debug(NAME
": ACBCTL2 readback failed\n");
400 outb(inb(ACBCTL1
) | ACBCTL1_NMINTE
, ACBCTL1
);
404 pr_debug(NAME
": disabled, but ACBCTL1=0x%02x\n",
409 outb(inb(ACBCTL2
) | ACBCTL2_ENABLE
, ACBCTL2
);
411 outb(inb(ACBCTL1
) | ACBCTL1_NMINTE
, ACBCTL1
);
414 if ((val
& ACBCTL1_NMINTE
) != ACBCTL1_NMINTE
) {
415 pr_debug(NAME
": enabled, but NMINTE won't be set, "
416 "ACBCTL1=0x%02x\n", val
);
423 static __init
struct scx200_acb_iface
*scx200_create_iface(const char *text
,
426 struct scx200_acb_iface
*iface
;
427 struct i2c_adapter
*adapter
;
429 iface
= kzalloc(sizeof(*iface
), GFP_KERNEL
);
431 printk(KERN_ERR NAME
": can't allocate memory\n");
435 adapter
= &iface
->adapter
;
436 i2c_set_adapdata(adapter
, iface
);
437 snprintf(adapter
->name
, I2C_NAME_SIZE
, "%s ACB%d", text
, index
);
438 adapter
->owner
= THIS_MODULE
;
439 adapter
->id
= I2C_HW_SMBUS_SCX200
;
440 adapter
->algo
= &scx200_acb_algorithm
;
441 adapter
->class = I2C_CLASS_HWMON
;
443 mutex_init(&iface
->mutex
);
448 static int __init
scx200_acb_create(struct scx200_acb_iface
*iface
)
450 struct i2c_adapter
*adapter
;
453 adapter
= &iface
->adapter
;
455 rc
= scx200_acb_probe(iface
);
457 printk(KERN_WARNING NAME
": probe failed\n");
461 scx200_acb_reset(iface
);
463 if (i2c_add_adapter(adapter
) < 0) {
464 printk(KERN_ERR NAME
": failed to register\n");
468 down(&scx200_acb_list_mutex
);
469 iface
->next
= scx200_acb_list
;
470 scx200_acb_list
= iface
;
471 up(&scx200_acb_list_mutex
);
476 static __init
int scx200_create_pci(const char *text
, struct pci_dev
*pdev
,
479 struct scx200_acb_iface
*iface
;
482 iface
= scx200_create_iface(text
, 0);
490 pci_enable_device_bars(iface
->pdev
, 1 << iface
->bar
);
492 rc
= pci_request_region(iface
->pdev
, iface
->bar
, iface
->adapter
.name
);
495 printk(KERN_ERR NAME
": can't allocate PCI BAR %d\n",
500 iface
->base
= pci_resource_start(iface
->pdev
, iface
->bar
);
501 rc
= scx200_acb_create(iface
);
506 pci_release_region(iface
->pdev
, iface
->bar
);
507 pci_dev_put(iface
->pdev
);
513 static int __init
scx200_create_isa(const char *text
, unsigned long base
,
516 struct scx200_acb_iface
*iface
;
519 iface
= scx200_create_iface(text
, index
);
524 if (request_region(base
, 8, iface
->adapter
.name
) == 0) {
525 printk(KERN_ERR NAME
": can't allocate io 0x%lx-0x%lx\n",
532 rc
= scx200_acb_create(iface
);
537 release_region(base
, 8);
543 /* Driver data is an index into the scx200_data array that indicates
544 * the name and the BAR where the I/O address resource is located. ISA
545 * devices are flagged with a bar value of -1 */
547 static struct pci_device_id scx200_pci
[] = {
548 { PCI_DEVICE(PCI_VENDOR_ID_NS
, PCI_DEVICE_ID_NS_SCx200_BRIDGE
),
550 { PCI_DEVICE(PCI_VENDOR_ID_NS
, PCI_DEVICE_ID_NS_SC1100_BRIDGE
),
552 { PCI_DEVICE(PCI_VENDOR_ID_NS
, PCI_DEVICE_ID_NS_CS5535_ISA
),
554 { PCI_DEVICE(PCI_VENDOR_ID_AMD
, PCI_DEVICE_ID_AMD_CS5536_ISA
),
567 static __init
int scx200_scan_pci(void)
571 struct pci_dev
*pdev
;
573 for(dev
= 0; dev
< ARRAY_SIZE(scx200_pci
); dev
++) {
574 pdev
= pci_get_device(scx200_pci
[dev
].vendor
,
575 scx200_pci
[dev
].device
, NULL
);
580 data
= scx200_pci
[dev
].driver_data
;
582 /* if .bar is greater or equal to zero, this is a
583 * PCI device - otherwise, we assume
584 that the ports are ISA based
587 if (scx200_data
[data
].bar
>= 0)
588 rc
= scx200_create_pci(scx200_data
[data
].name
, pdev
,
589 scx200_data
[data
].bar
);
593 for (i
= 0; i
< MAX_DEVICES
; ++i
) {
597 rc
= scx200_create_isa(scx200_data
[data
].name
,
609 static int __init
scx200_acb_init(void)
613 pr_debug(NAME
": NatSemi SCx200 ACCESS.bus Driver\n");
615 rc
= scx200_scan_pci();
617 /* If at least one bus was created, init must succeed */
623 static void __exit
scx200_acb_cleanup(void)
625 struct scx200_acb_iface
*iface
;
627 down(&scx200_acb_list_mutex
);
628 while ((iface
= scx200_acb_list
) != NULL
) {
629 scx200_acb_list
= iface
->next
;
630 up(&scx200_acb_list_mutex
);
632 i2c_del_adapter(&iface
->adapter
);
635 pci_release_region(iface
->pdev
, iface
->bar
);
636 pci_dev_put(iface
->pdev
);
639 release_region(iface
->base
, 8);
642 down(&scx200_acb_list_mutex
);
644 up(&scx200_acb_list_mutex
);
647 module_init(scx200_acb_init
);
648 module_exit(scx200_acb_cleanup
);