46b9a7594c99ca98e137cc829a9559ead0302ad4
[linux-2.6.git] / drivers / i2c / busses / scx200_acb.c
1 /*  linux/drivers/i2c/scx200_acb.c 
2
3     Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
4
5     National Semiconductor SCx200 ACCESS.bus support
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
27 #include <linux/module.h>
28 #include <linux/errno.h>
29 #include <linux/kernel.h>
30 #include <linux/init.h>
31 #include <linux/i2c.h>
32 #include <linux/smp_lock.h>
33 #include <linux/pci.h>
34 #include <linux/delay.h>
35 #include <asm/io.h>
36
37 #include <linux/scx200.h>
38
39 #define NAME "scx200_acb"
40
41 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
42 MODULE_DESCRIPTION("NatSemi SCx200 ACCESS.bus Driver");
43 MODULE_LICENSE("GPL");
44
45 #define MAX_DEVICES 4
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");
49
50 #ifdef DEBUG
51 #define DBG(x...) printk(KERN_DEBUG NAME ": " x)
52 #else
53 #define DBG(x...)
54 #endif
55
56 /* The hardware supports interrupt driven mode too, but I haven't
57    implemented that. */
58 #define POLLED_MODE 1
59 #define POLL_TIMEOUT (HZ)
60
61 enum scx200_acb_state {
62         state_idle,
63         state_address,
64         state_command,
65         state_repeat_start,
66         state_quick,
67         state_read,
68         state_write,
69 };
70
71 static const char *scx200_acb_state_name[] = {
72         "idle",
73         "address",
74         "command",
75         "repeat_start",
76         "quick",
77         "read",
78         "write",
79 };
80
81 /* Physical interface */
82 struct scx200_acb_iface
83 {
84         struct scx200_acb_iface *next;
85         struct i2c_adapter adapter;
86         unsigned base;
87         struct semaphore sem;
88
89         /* State machine data */
90         enum scx200_acb_state state;
91         int result;
92         u8 address_byte;
93         u8 command;
94         u8 *ptr;
95         char needs_reset;
96         unsigned len;
97 };
98
99 /* Register Definitions */
100 #define ACBSDA          (iface->base + 0)
101 #define ACBST           (iface->base + 1)
102 #define    ACBST_SDAST          0x40 /* SDA Status */
103 #define    ACBST_BER            0x20 
104 #define    ACBST_NEGACK         0x10 /* Negative Acknowledge */
105 #define    ACBST_STASTR         0x08 /* Stall After Start */
106 #define    ACBST_MASTER         0x02
107 #define ACBCST          (iface->base + 2)
108 #define    ACBCST_BB            0x02
109 #define ACBCTL1         (iface->base + 3)
110 #define    ACBCTL1_STASTRE      0x80
111 #define    ACBCTL1_NMINTE       0x40
112 #define    ACBCTL1_ACK          0x10
113 #define    ACBCTL1_STOP         0x02
114 #define    ACBCTL1_START        0x01
115 #define ACBADDR         (iface->base + 4)
116 #define ACBCTL2         (iface->base + 5)
117 #define    ACBCTL2_ENABLE       0x01
118
119 /************************************************************************/
120
121 static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
122 {
123         const char *errmsg;
124
125         DBG("state %s, status = 0x%02x\n", 
126             scx200_acb_state_name[iface->state], status);
127
128         if (status & ACBST_BER) {
129                 errmsg = "bus error";
130                 goto error;
131         }
132         if (!(status & ACBST_MASTER)) {
133                 errmsg = "not master";
134                 goto error;
135         }
136         if (status & ACBST_NEGACK)
137                 goto negack;
138
139         switch (iface->state) {
140         case state_idle:
141                 dev_warn(&iface->adapter.dev, "interrupt in idle state\n");
142                 break;
143
144         case state_address:
145                 /* Do a pointer write first */
146                 outb(iface->address_byte & ~1, ACBSDA);
147
148                 iface->state = state_command;
149                 break;
150
151         case state_command:
152                 outb(iface->command, ACBSDA);
153
154                 if (iface->address_byte & 1)
155                         iface->state = state_repeat_start;
156                 else
157                         iface->state = state_write;
158                 break;
159
160         case state_repeat_start:
161                 outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
162                 /* fallthrough */
163                 
164         case state_quick:
165                 if (iface->address_byte & 1) {
166                         if (iface->len == 1) 
167                                 outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
168                         else
169                                 outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
170                         outb(iface->address_byte, ACBSDA);
171
172                         iface->state = state_read;
173                 } else {
174                         outb(iface->address_byte, ACBSDA);
175
176                         iface->state = state_write;
177                 }
178                 break;
179
180         case state_read:
181                 /* Set ACK if receiving the last byte */
182                 if (iface->len == 1)
183                         outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
184                 else
185                         outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
186
187                 *iface->ptr++ = inb(ACBSDA);
188                 --iface->len;
189
190                 if (iface->len == 0) {
191                         iface->result = 0;
192                         iface->state = state_idle;
193                         outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
194                 }
195
196                 break;
197
198         case state_write:
199                 if (iface->len == 0) {
200                         iface->result = 0;
201                         iface->state = state_idle;
202                         outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
203                         break;
204                 }
205                 
206                 outb(*iface->ptr++, ACBSDA);
207                 --iface->len;
208                 
209                 break;
210         }
211
212         return;
213
214  negack:
215         DBG("negative acknowledge in state %s\n", 
216             scx200_acb_state_name[iface->state]);
217
218         iface->state = state_idle;
219         iface->result = -ENXIO;
220
221         outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
222         outb(ACBST_STASTR | ACBST_NEGACK, ACBST);
223         return;
224
225  error:
226         dev_err(&iface->adapter.dev, "%s in state %s\n", errmsg,
227                 scx200_acb_state_name[iface->state]);
228
229         iface->state = state_idle;
230         iface->result = -EIO;
231         iface->needs_reset = 1;
232 }
233
234 static void scx200_acb_timeout(struct scx200_acb_iface *iface) 
235 {
236         dev_err(&iface->adapter.dev, "timeout in state %s\n",
237                 scx200_acb_state_name[iface->state]);
238
239         iface->state = state_idle;
240         iface->result = -EIO;
241         iface->needs_reset = 1;
242 }
243
244 #ifdef POLLED_MODE
245 static void scx200_acb_poll(struct scx200_acb_iface *iface)
246 {
247         u8 status = 0;
248         unsigned long timeout;
249
250         timeout = jiffies + POLL_TIMEOUT;
251         while (time_before(jiffies, timeout)) {
252                 status = inb(ACBST);
253                 if ((status & (ACBST_SDAST|ACBST_BER|ACBST_NEGACK)) != 0) {
254                         scx200_acb_machine(iface, status);
255                         return;
256                 }
257                 msleep(10);
258         }
259
260         scx200_acb_timeout(iface);
261 }
262 #endif /* POLLED_MODE */
263
264 static void scx200_acb_reset(struct scx200_acb_iface *iface)
265 {
266         /* Disable the ACCESS.bus device and Configure the SCL
267            frequency: 16 clock cycles */
268         outb(0x70, ACBCTL2);
269         /* Polling mode */
270         outb(0, ACBCTL1);
271         /* Disable slave address */
272         outb(0, ACBADDR);
273         /* Enable the ACCESS.bus device */
274         outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
275         /* Free STALL after START */
276         outb(inb(ACBCTL1) & ~(ACBCTL1_STASTRE | ACBCTL1_NMINTE), ACBCTL1);
277         /* Send a STOP */
278         outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
279         /* Clear BER, NEGACK and STASTR bits */
280         outb(ACBST_BER | ACBST_NEGACK | ACBST_STASTR, ACBST);
281         /* Clear BB bit */
282         outb(inb(ACBCST) | ACBCST_BB, ACBCST);
283 }
284
285 static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
286                                 u16 address, unsigned short flags,      
287                                 char rw, u8 command, int size, 
288                                 union i2c_smbus_data *data)
289 {
290         struct scx200_acb_iface *iface = i2c_get_adapdata(adapter);
291         int len;
292         u8 *buffer;
293         u16 cur_word;
294         int rc;
295
296         switch (size) {
297         case I2C_SMBUS_QUICK:
298                 len = 0;
299                 buffer = NULL;
300                 break;
301         case I2C_SMBUS_BYTE:
302                 if (rw == I2C_SMBUS_READ) {
303                         len = 1;
304                         buffer = &data->byte;
305                 } else {
306                         len = 1;
307                         buffer = &command;
308                 }
309                 break;
310         case I2C_SMBUS_BYTE_DATA:
311                 len = 1;
312                 buffer = &data->byte;
313                 break;
314         case I2C_SMBUS_WORD_DATA:
315                 len = 2;
316                 cur_word = cpu_to_le16(data->word);
317                 buffer = (u8 *)&cur_word;
318                 break;
319         case I2C_SMBUS_BLOCK_DATA:
320                 len = data->block[0];
321                 buffer = &data->block[1];
322                 break;
323         default:
324                 return -EINVAL;
325         }
326
327         DBG("size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
328             size, address, command, len, rw == I2C_SMBUS_READ);
329
330         if (!len && rw == I2C_SMBUS_READ) {
331                 dev_warn(&adapter->dev, "zero length read\n");
332                 return -EINVAL;
333         }
334
335         if (len && !buffer) {
336                 dev_warn(&adapter->dev, "nonzero length but no buffer\n");
337                 return -EFAULT;
338         }
339
340         down(&iface->sem);
341
342         iface->address_byte = address<<1;
343         if (rw == I2C_SMBUS_READ)
344                 iface->address_byte |= 1;
345         iface->command = command;
346         iface->ptr = buffer;
347         iface->len = len;
348         iface->result = -EINVAL;
349         iface->needs_reset = 0;
350
351         outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
352
353         if (size == I2C_SMBUS_QUICK || size == I2C_SMBUS_BYTE)
354                 iface->state = state_quick;
355         else
356                 iface->state = state_address;
357
358 #ifdef POLLED_MODE
359         while (iface->state != state_idle)
360                 scx200_acb_poll(iface);
361 #else /* POLLED_MODE */
362 #error Interrupt driven mode not implemented
363 #endif /* POLLED_MODE */        
364
365         if (iface->needs_reset)
366                 scx200_acb_reset(iface);
367
368         rc = iface->result;
369
370         up(&iface->sem);
371
372         if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ)
373                 data->word = le16_to_cpu(cur_word);
374
375 #ifdef DEBUG
376         DBG(": transfer done, result: %d", rc);
377         if (buffer) {
378                 int i;
379                 printk(" data:");
380                 for (i = 0; i < len; ++i)
381                         printk(" %02x", buffer[i]);
382         }
383         printk("\n");
384 #endif
385
386         return rc;
387 }
388
389 static u32 scx200_acb_func(struct i2c_adapter *adapter)
390 {
391         return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
392                I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
393                I2C_FUNC_SMBUS_BLOCK_DATA;
394 }
395
396 /* For now, we only handle combined mode (smbus) */
397 static struct i2c_algorithm scx200_acb_algorithm = {
398         .smbus_xfer     = scx200_acb_smbus_xfer,
399         .functionality  = scx200_acb_func,
400 };
401
402 static struct scx200_acb_iface *scx200_acb_list;
403
404 static int scx200_acb_probe(struct scx200_acb_iface *iface)
405 {
406         u8 val;
407
408         /* Disable the ACCESS.bus device and Configure the SCL
409            frequency: 16 clock cycles */
410         outb(0x70, ACBCTL2);
411
412         if (inb(ACBCTL2) != 0x70) {
413                 DBG("ACBCTL2 readback failed\n");
414                 return -ENXIO;
415         }
416
417         outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);
418
419         val = inb(ACBCTL1);
420         if (val) {
421                 DBG("disabled, but ACBCTL1=0x%02x\n", val);
422                 return -ENXIO;
423         }
424
425         outb(inb(ACBCTL2) | ACBCTL2_ENABLE, ACBCTL2);
426
427         outb(inb(ACBCTL1) | ACBCTL1_NMINTE, ACBCTL1);
428
429         val = inb(ACBCTL1);
430         if ((val & ACBCTL1_NMINTE) != ACBCTL1_NMINTE) {
431                 DBG("enabled, but NMINTE won't be set, ACBCTL1=0x%02x\n", val);
432                 return -ENXIO;
433         }
434
435         return 0;
436 }
437
438 static int  __init scx200_acb_create(int base, int index)
439 {
440         struct scx200_acb_iface *iface;
441         struct i2c_adapter *adapter;
442         int rc = 0;
443         char description[64];
444
445         iface = kmalloc(sizeof(*iface), GFP_KERNEL);
446         if (!iface) {
447                 printk(KERN_ERR NAME ": can't allocate memory\n");
448                 rc = -ENOMEM;
449                 goto errout;
450         }
451
452         memset(iface, 0, sizeof(*iface));
453         adapter = &iface->adapter;
454         i2c_set_adapdata(adapter, iface);
455         snprintf(adapter->name, I2C_NAME_SIZE, "SCx200 ACB%d", index);
456         adapter->owner = THIS_MODULE;
457         adapter->id = I2C_ALGO_SMBUS;
458         adapter->algo = &scx200_acb_algorithm;
459         adapter->class = I2C_CLASS_HWMON;
460
461         init_MUTEX(&iface->sem);
462
463         snprintf(description, sizeof(description), "NatSemi SCx200 ACCESS.bus [%s]", adapter->name);
464         if (request_region(base, 8, description) == 0) {
465                 dev_err(&adapter->dev, "can't allocate io 0x%x-0x%x\n",
466                         base, base + 8-1);
467                 rc = -EBUSY;
468                 goto errout;
469         }
470         iface->base = base;
471
472         rc = scx200_acb_probe(iface);
473         if (rc) {
474                 dev_warn(&adapter->dev, "probe failed\n");
475                 goto errout;
476         }
477
478         scx200_acb_reset(iface);
479
480         if (i2c_add_adapter(adapter) < 0) {
481                 dev_err(&adapter->dev, "failed to register\n");
482                 rc = -ENODEV;
483                 goto errout;
484         }
485
486         lock_kernel();
487         iface->next = scx200_acb_list;
488         scx200_acb_list = iface;
489         unlock_kernel();
490
491         return 0;
492
493  errout:
494         if (iface) {
495                 if (iface->base)
496                         release_region(iface->base, 8);
497                 kfree(iface);
498         }
499         return rc;
500 }
501
502 static struct pci_device_id scx200[] = {
503         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
504         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
505         { },
506 };
507
508 static int __init scx200_acb_init(void)
509 {
510         int i;
511         int rc;
512
513         pr_debug(NAME ": NatSemi SCx200 ACCESS.bus Driver\n");
514
515         /* Verify that this really is a SCx200 processor */
516         if (pci_dev_present(scx200) == 0)
517                 return -ENODEV;
518
519         rc = -ENXIO;
520         for (i = 0; i < MAX_DEVICES; ++i) {
521                 if (base[i] > 0)
522                         rc = scx200_acb_create(base[i], i);
523         }
524         if (scx200_acb_list)
525                 return 0;
526         return rc;
527 }
528
529 static void __exit scx200_acb_cleanup(void)
530 {
531         struct scx200_acb_iface *iface;
532         lock_kernel();
533         while ((iface = scx200_acb_list) != NULL) {
534                 scx200_acb_list = iface->next;
535                 unlock_kernel();
536
537                 i2c_del_adapter(&iface->adapter);
538                 release_region(iface->base, 8);
539                 kfree(iface);
540                 lock_kernel();
541         }
542         unlock_kernel();
543 }
544
545 module_init(scx200_acb_init);
546 module_exit(scx200_acb_cleanup);
547
548 /*
549     Local variables:
550         compile-command: "make -k -C ../.. SUBDIRS=drivers/i2c modules"
551         c-basic-offset: 8
552     End:
553 */
554