* Move function types to a separate line.
[dragonfly.git] / sys / bus / iicbus / i386 / pcf.c
1 /*-
2  * Copyright (c) 1998 Nicolas Souchu, Marc Bouget
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/i386/isa/pcf.c,v 1.14 2000/01/14 00:18:05 nsouch Exp $
27  * $DragonFly: src/sys/bus/iicbus/i386/pcf.c,v 1.7 2006/01/22 14:03:51 swildner Exp $
28  *
29  */
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
33 #include <sys/module.h>
34 #include <sys/bus.h>
35 #include <sys/malloc.h>
36
37 #include <machine/clock.h>
38 #include <machine/bus.h>
39 #include <machine/resource.h>
40 #include <sys/rman.h>
41
42 #include <bus/isa/isareg.h>
43 #include <bus/isa/isavar.h>
44
45 #include <bus/isa/i386/isa_device.h>
46
47 #include "../iiconf.h"
48 #include "iicbus_if.h"
49
50 #define IO_PCFSIZE      2
51
52 #define TIMEOUT 9999                                    /* XXX */
53
54 /* Status bits of S1 register (read only) */
55 #define nBB     0x01            /* busy when low set/reset by STOP/START*/
56 #define LAB     0x02            /* lost arbitration bit in multi-master mode */
57 #define AAS     0x04            /* addressed as slave */
58 #define LRB     0x08            /* last received byte when not AAS */
59 #define AD0     0x08            /* general call received when AAS */
60 #define BER     0x10            /* bus error, misplaced START or STOP */
61 #define STS     0x20            /* STOP detected in slave receiver mode */
62 #define PIN     0x80            /* pending interrupt not (r/w) */
63
64 /* Control bits of S1 register (write only) */
65 #define ACK     0x01
66 #define STO     0x02
67 #define STA     0x04
68 #define ENI     0x08
69 #define ES2     0x10
70 #define ES1     0x20
71 #define ES0     0x40
72
73 #define BUFSIZE 2048
74
75 #define SLAVE_TRANSMITTER       0x1
76 #define SLAVE_RECEIVER          0x2
77
78 #define PCF_DEFAULT_ADDR        0xaa
79
80 struct pcf_softc {
81
82         int pcf_base;                   /* isa port */
83         int pcf_flags;
84         u_char pcf_addr;                /* interface I2C address */
85
86         int pcf_slave_mode;             /* receiver or transmitter */
87         int pcf_started;                /* 1 if start condition sent */
88
89         device_t iicbus;                /* the corresponding iicbus */
90
91         int rid_irq, rid_ioport;
92         struct resource *res_irq, *res_ioport;
93         void *intr_cookie;
94 };
95
96 static int pcf_probe(device_t);
97 static int pcf_attach(device_t);
98 static void pcfintr(void *arg);
99
100 static int pcf_print_child(device_t, device_t);
101
102 static int pcf_repeated_start(device_t, u_char, int);
103 static int pcf_start(device_t, u_char, int);
104 static int pcf_stop(device_t);
105 static int pcf_write(device_t, char *, int, int *, int);
106 static int pcf_read(device_t, char *, int, int *, int, int);
107 static int pcf_rst_card(device_t, u_char, u_char, u_char *);
108
109 static device_method_t pcf_methods[] = {
110         /* device interface */
111         DEVMETHOD(device_probe,         pcf_probe),
112         DEVMETHOD(device_attach,        pcf_attach),
113
114         /* bus interface */
115         DEVMETHOD(bus_print_child,      pcf_print_child),
116
117         /* iicbus interface */
118         DEVMETHOD(iicbus_callback,      iicbus_null_callback),
119         DEVMETHOD(iicbus_repeated_start, pcf_repeated_start),
120         DEVMETHOD(iicbus_start,         pcf_start),
121         DEVMETHOD(iicbus_stop,          pcf_stop),
122         DEVMETHOD(iicbus_write,         pcf_write),
123         DEVMETHOD(iicbus_read,          pcf_read),
124         DEVMETHOD(iicbus_reset,         pcf_rst_card),
125
126         { 0, 0 }
127 };
128
129 static driver_t pcf_driver = {
130         "pcf",
131         pcf_methods,
132         sizeof(struct pcf_softc),
133 };
134
135 static devclass_t pcf_devclass;
136
137 #define DEVTOSOFTC(dev) ((struct pcf_softc *)device_get_softc(dev))
138
139 static int
140 pcf_probe(device_t pcfdev)
141 {
142         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
143         device_t parent = device_get_parent(pcfdev);
144
145         device_set_desc(pcfdev, "PCF8584 I2C bus controller");
146
147         pcf = DEVTOSOFTC(pcfdev);
148         bzero(pcf, sizeof(struct pcf_softc));
149
150         pcf->rid_irq = pcf->rid_ioport = 0;
151         pcf->res_irq = pcf->res_ioport = 0;
152
153         /* IO port is mandatory */
154         pcf->res_ioport = bus_alloc_resource(pcfdev, SYS_RES_IOPORT,
155                                              &pcf->rid_ioport, 0ul, ~0ul, 
156                                              IO_PCFSIZE, RF_ACTIVE);
157         if (pcf->res_ioport == 0) {
158                 device_printf(pcfdev, "cannot reserve I/O port range\n");
159                 goto error;
160         }
161         BUS_READ_IVAR(parent, pcfdev, ISA_IVAR_PORT, &pcf->pcf_base);
162
163         pcf->pcf_flags = device_get_flags(pcfdev);
164
165         if (!(pcf->pcf_flags & IIC_POLLED)) {
166                 pcf->res_irq = bus_alloc_resource(pcfdev, SYS_RES_IRQ, &pcf->rid_irq,
167                                                   0ul, ~0ul, 1, RF_ACTIVE);
168                 if (pcf->res_irq == 0) {
169                         device_printf(pcfdev, "can't reserve irq, polled mode.\n");
170                         pcf->pcf_flags |= IIC_POLLED;
171                 }
172         }
173
174         /* reset the chip */
175         pcf_rst_card(pcfdev, IIC_FASTEST, PCF_DEFAULT_ADDR, NULL);
176
177         return (0);
178 error:
179         if (pcf->res_ioport != 0) {
180                 bus_deactivate_resource(pcfdev, SYS_RES_IOPORT, pcf->rid_ioport,
181                                         pcf->res_ioport);
182                 bus_release_resource(pcfdev, SYS_RES_IOPORT, pcf->rid_ioport,
183                                      pcf->res_ioport);
184         }
185         return (ENXIO);
186 }
187
188 static int
189 pcf_attach(device_t pcfdev)
190 {
191         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
192         device_t parent = device_get_parent(pcfdev);
193         int error = 0;
194
195         if (pcf->res_irq) {
196                 /* default to the tty mask for registration */  /* XXX */
197                 error = BUS_SETUP_INTR(parent, pcfdev, pcf->res_irq, 
198                                         0, pcfintr, pcfdev,
199                                         &pcf->intr_cookie, NULL);
200                 if (error)
201                         return (error);
202         }
203
204         pcf->iicbus = iicbus_alloc_bus(pcfdev);
205
206         /* probe and attach the iicbus */
207         device_probe_and_attach(pcf->iicbus);
208
209         return (0);
210 }
211
212 static int
213 pcf_print_child(device_t bus, device_t dev)
214 {
215         struct pcf_softc *pcf = (struct pcf_softc *)device_get_softc(bus);
216         int retval = 0;
217
218         retval += bus_print_child_header(bus, dev);
219         retval += printf(" on %s addr 0x%x\n", device_get_nameunit(bus),
220                          (int)pcf->pcf_addr);
221
222         return (retval);
223 }
224
225 /*
226  * PCF8584 datasheet : when operate at 8 MHz or more, a minimun time of
227  * 6 clocks cycles must be left between two consecutives access
228  */
229 #define pcf_nops()      DELAY(10)
230
231 #define dummy_read(pcf)         PCF_GET_S0(pcf)
232 #define dummy_write(pcf)        PCF_SET_S0(pcf, 0)
233
234 /*
235  * Specific register access to PCF8584
236  */
237 static void
238 PCF_SET_S0(struct pcf_softc *pcf, int data)
239 {
240         outb(pcf->pcf_base, data);
241         pcf_nops();
242 }
243
244 static void
245 PCF_SET_S1(struct pcf_softc *pcf, int data)
246 {
247         outb(pcf->pcf_base+1, data);
248         pcf_nops();
249 }
250
251 static char
252 PCF_GET_S0(struct pcf_softc *pcf)
253 {
254         char data;
255
256         data = inb(pcf->pcf_base);
257         pcf_nops();
258
259         return (data);
260 }
261
262 static char
263 PCF_GET_S1(struct pcf_softc *pcf)
264 {
265         char data;
266
267         data = inb(pcf->pcf_base+1);
268         pcf_nops();
269
270         return (data);
271 }
272
273 /*
274  * Polling mode for master operations wait for a new
275  * byte incomming or outgoing
276  */
277 static int
278 pcf_wait_byte(struct pcf_softc *pcf)
279 {
280         int counter = TIMEOUT;
281
282         while (counter--) {
283
284                 if ((PCF_GET_S1(pcf) & PIN) == 0)
285                         return (0);
286         }
287
288         return (IIC_ETIMEOUT);
289 }
290
291 static int
292 pcf_stop(device_t pcfdev)
293 {
294         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
295
296         /*
297          * Send STOP condition iff the START condition was previously sent.
298          * STOP is sent only once even if a iicbus_stop() is called after
299          * an iicbus_read()... see pcf_read(): the pcf needs to send the stop
300          * before the last char is read.
301          */
302         if (pcf->pcf_started) {
303                 /* set stop condition and enable IT */
304                 PCF_SET_S1(pcf, PIN|ES0|ENI|STO|ACK);
305
306                 pcf->pcf_started = 0;
307         }
308
309         return (0);
310 }
311
312
313 static int
314 pcf_noack(struct pcf_softc *pcf, int timeout)
315 {
316         int noack;
317         int k = timeout/10;
318
319         do {
320                 noack = PCF_GET_S1(pcf) & LRB;
321                 if (!noack)
322                         break;
323                 DELAY(10);                              /* XXX wait 10 us */
324         } while (k--);
325
326         return (noack);
327 }
328
329 static int
330 pcf_repeated_start(device_t pcfdev, u_char slave, int timeout)
331 {
332         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
333         int error = 0;
334
335         /* repeated start */
336         PCF_SET_S1(pcf, ES0|STA|STO|ACK);
337
338         /* set slave address to PCF. Last bit (LSB) must be set correctly
339          * according to transfer direction */
340         PCF_SET_S0(pcf, slave);
341
342         /* wait for address sent, polling */
343         if ((error = pcf_wait_byte(pcf)))
344                 goto error;
345
346         /* check for ack */
347         if (pcf_noack(pcf, timeout)) {
348                 error = IIC_ENOACK;
349                 goto error;
350         }
351
352         return (0);
353
354 error:
355         pcf_stop(pcfdev);
356         return (error);
357 }
358
359 static int
360 pcf_start(device_t pcfdev, u_char slave, int timeout)
361 {
362         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
363         int error = 0;
364
365         if ((PCF_GET_S1(pcf) & nBB) == 0)
366                 return (IIC_EBUSBSY);
367
368         /* set slave address to PCF. Last bit (LSB) must be set correctly
369          * according to transfer direction */
370         PCF_SET_S0(pcf, slave);
371
372         /* START only */
373         PCF_SET_S1(pcf, PIN|ES0|STA|ACK);
374
375         pcf->pcf_started = 1;
376
377         /* wait for address sent, polling */
378         if ((error = pcf_wait_byte(pcf)))
379                 goto error;
380
381         /* check for ACK */
382         if (pcf_noack(pcf, timeout)) {
383                 error = IIC_ENOACK;
384                 goto error;
385         }
386
387         return (0);
388
389 error:
390         pcf_stop(pcfdev);
391         return (error);
392 }
393
394 static void
395 pcfintr(void *arg)
396 {
397         device_t pcfdev = (device_t)arg;
398         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
399
400         char data, status, addr;
401         char error = 0;
402
403         status = PCF_GET_S1(pcf);
404
405         if (status & PIN) {
406                 device_printf(pcfdev, "spurious interrupt, status=0x%x\n", status & 0xff);
407
408                 goto error;
409         }       
410
411         if (status & LAB)
412                 device_printf(pcfdev, "bus arbitration lost!\n");
413
414         if (status & BER) {
415                 error = IIC_EBUSERR;
416                 iicbus_intr(pcf->iicbus, INTR_ERROR, &error);
417
418                 goto error;
419         }
420
421         do {
422                 status = PCF_GET_S1(pcf);
423
424                 switch(pcf->pcf_slave_mode) {
425
426                 case SLAVE_TRANSMITTER:
427                         if (status & LRB) {
428                                 /* ack interrupt line */
429                                 dummy_write(pcf);
430
431                                 /* no ack, don't send anymore */
432                                 pcf->pcf_slave_mode = SLAVE_RECEIVER;
433
434                                 iicbus_intr(pcf->iicbus, INTR_NOACK, NULL);
435                                 break;
436                         }
437
438                         /* get data from upper code */
439                         iicbus_intr(pcf->iicbus, INTR_TRANSMIT, &data);
440
441                         PCF_SET_S0(pcf, data);  
442                         break;  
443                 
444                 case SLAVE_RECEIVER:
445                         if (status & AAS) {
446                                 addr = PCF_GET_S0(pcf);
447
448                                 if (status & AD0)
449                                         iicbus_intr(pcf->iicbus, INTR_GENERAL, &addr);
450                                 else
451                                         iicbus_intr(pcf->iicbus, INTR_START, &addr);
452
453                                 if (addr & LSB) {
454                                         pcf->pcf_slave_mode = SLAVE_TRANSMITTER;
455
456                                         /* get the first char from upper code */
457                                         iicbus_intr(pcf->iicbus, INTR_TRANSMIT, &data);
458
459                                         /* send first data byte */
460                                         PCF_SET_S0(pcf, data);
461                                 }
462
463                                 break;
464                         }
465
466                         /* stop condition received? */
467                         if (status & STS) {
468                                 /* ack interrupt line */
469                                 dummy_read(pcf);
470
471                                 /* emulate intr stop condition */
472                                 iicbus_intr(pcf->iicbus, INTR_STOP, NULL);
473
474                         } else {
475                                 /* get data, ack interrupt line */
476                                 data = PCF_GET_S0(pcf);
477
478                                 /* deliver the character */
479                                 iicbus_intr(pcf->iicbus, INTR_RECEIVE, &data);
480                         }
481                         break;
482
483                     default:
484                         panic("%s: unknown slave mode (%d)!", __func__,
485                                 pcf->pcf_slave_mode);
486                     }
487
488         } while ((PCF_GET_S1(pcf) & PIN) == 0);
489
490         return;
491
492 error:
493         /* unknown event on bus...reset PCF */
494         PCF_SET_S1(pcf, PIN|ES0|ENI|ACK);
495
496         pcf->pcf_slave_mode = SLAVE_RECEIVER;
497
498         return;
499 }
500
501 static int
502 pcf_rst_card(device_t pcfdev, u_char speed, u_char addr, u_char *oldaddr)
503 {
504         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
505
506         if (oldaddr)
507                 *oldaddr = pcf->pcf_addr;
508
509         /* retrieve own address from bus level */
510         if (!addr)
511                 pcf->pcf_addr = PCF_DEFAULT_ADDR;
512         else
513                 pcf->pcf_addr = addr;
514         
515         PCF_SET_S1(pcf, PIN);                           /* initialize S1 */
516
517         /* own address S'O<>0 */
518         PCF_SET_S0(pcf, pcf->pcf_addr >> 1);
519
520         /* select clock register */
521         PCF_SET_S1(pcf, PIN|ES1);
522
523         /* select bus speed : 18=90kb, 19=45kb, 1A=11kb, 1B=1.5kb */
524         switch (speed) {
525         case IIC_SLOW:
526                 PCF_SET_S0(pcf,  0x1b);
527                 break;
528
529         case IIC_FAST:
530                 PCF_SET_S0(pcf,  0x19);
531                 break;
532
533         case IIC_UNKNOWN:
534         case IIC_FASTEST:
535         default:
536                 PCF_SET_S0(pcf,  0x18);
537                 break;
538         }
539
540         /* set bus on, ack=yes, INT=yes */
541         PCF_SET_S1(pcf, PIN|ES0|ENI|ACK);
542
543         pcf->pcf_slave_mode = SLAVE_RECEIVER;
544
545         return (0);
546 }
547
548 static int
549 pcf_write(device_t pcfdev, char *buf, int len, int *sent, int timeout /* us */)
550 {
551         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
552         int bytes, error = 0;
553
554 #ifdef PCFDEBUG
555         printf("pcf%d: >> writing %d bytes\n", device_get_unit(pcfdev), len);
556 #endif
557
558         bytes = 0;
559         while (len) {
560
561                 PCF_SET_S0(pcf, *buf++);
562
563                 /* wait for the byte to be send */
564                 if ((error = pcf_wait_byte(pcf)))
565                         goto error;
566
567                 /* check if ack received */
568                 if (pcf_noack(pcf, timeout)) {
569                         error = IIC_ENOACK;
570                         goto error;
571                 }
572
573                 len --;
574                 bytes ++;
575         }
576
577 error:
578         *sent = bytes;
579
580 #ifdef PCFDEBUG
581         printf("pcf%d: >> %d bytes written (%d)\n",
582                 device_get_unit(pcfdev), bytes, error);
583 #endif
584
585         return (error);
586 }
587
588 static int
589 pcf_read(device_t pcfdev, char *buf, int len, int *read, int last,
590                                                         int delay /* us */)
591 {
592         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
593         int bytes, error = 0;
594
595 #ifdef PCFDEBUG
596         printf("pcf%d: << reading %d bytes\n", device_get_unit(pcfdev), len);
597 #endif
598
599         /* trig the bus to get the first data byte in S0 */
600         if (len) {
601                 if (len == 1 && last)
602                         /* just one byte to read */
603                         PCF_SET_S1(pcf, ES0);           /* no ack */
604
605                 dummy_read(pcf);
606         }
607
608         bytes = 0;
609         while (len) {
610
611                 /* XXX delay needed here */
612
613                 /* wait for trigged byte */
614                 if ((error = pcf_wait_byte(pcf))) {
615                         pcf_stop(pcfdev);
616                         goto error;
617                 }
618
619                 if (len == 1 && last)
620                         /* ok, last data byte already in S0, no I2C activity
621                          * on next PCF_GET_S0() */
622                         pcf_stop(pcfdev);
623
624                 else if (len == 2 && last)
625                         /* next trigged byte with no ack */
626                         PCF_SET_S1(pcf, ES0);
627
628                 /* receive byte, trig next byte */
629                 *buf++ = PCF_GET_S0(pcf);
630
631                 len --;
632                 bytes ++;
633         };
634
635 error:
636         *read = bytes;
637
638 #ifdef PCFDEBUG
639         printf("pcf%d: << %d bytes read (%d)\n",
640                 device_get_unit(pcfdev), bytes, error);
641 #endif
642
643         return (error);
644 }
645
646 DRIVER_MODULE(pcf, isa, pcf_driver, pcf_devclass, 0, 0);