File: /usr/src/linux/arch/cris/drivers/parport.c
1 /* $Id: parport.c,v 1.7 2001/06/25 16:17:30 jonashg Exp $
2 *
3 * Elinux parallel port driver
4 * NOTE!
5 * Since par0 shares DMA with ser2 and par 1 shares DMA with ser3
6 * this should be handled if both are enabled at the same time.
7 * THIS IS NOT HANDLED YET!
8 *
9 * Copyright (c) 2001 Axis Communications AB
10 *
11 * Author: Fredrik Hugosson
12 *
13 */
14
15
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/parport.h>
19 #include <linux/ioport.h>
20 #include <linux/config.h>
21 #include <linux/errno.h>
22 #include <linux/kernel.h>
23 #include <linux/major.h>
24 #include <linux/sched.h>
25
26 #include <linux/slab.h>
27 #include <linux/interrupt.h>
28
29 #include <asm/setup.h>
30 #include <asm/irq.h>
31 #include <asm/io.h>
32
33 #include <asm/segment.h>
34 #include <asm/system.h>
35
36 #include <asm/svinto.h>
37
38
39 #undef DEBUG
40 #ifdef DEBUG
41 #define DPRINTK printk
42 #else
43 static inline int DPRINTK(void *nothing, ...) {return 0;}
44 #endif
45
46 /*
47 * Etrax100 DMAchannels:
48 * Par0 out : DMA2
49 * Par0 in : DMA3
50 * Par1 out : DMA4
51 * Par1 in : DMA5
52 * NOTE! par0 is shared with ser2 and par1 is shared with ser3 regarding
53 * DMA and DMA irq
54 */
55
56 //#define CONFIG_PAR0_INT 1
57 //#define CONFIG_PAR1_INT 1
58
59 #define SETF(var, reg, field, val) \
60 var = (var & ~IO_MASK(##reg##, field)) | IO_FIELD(##reg##, field, val)
61
62 #define SETS(var, reg, field, val) \
63 var = (var & ~IO_MASK(##reg##, field)) | IO_STATE(##reg##, field, val)
64
65 struct etrax100par_struct {
66 /* parallell port control */
67 volatile u32 *reg_ctrl_data; /* R_PARx_CTRL_DATA */
68 const volatile u32 *reg_status_data; /* R_PARx_STATUS_DATA */
69 volatile u32 *reg_config; /* R_PARx_CONFIG */
70 volatile u32 *reg_delay; /* R_PARx_DELAY */
71
72 /* DMA control */
73 int odma;
74 unsigned long dma_irq; /* bitnr in R_IRQ_MASK2 for dmaX_descr */
75
76 volatile char *oclrintradr; /* adr to R_DMA_CHx_CLR_INTR, output */
77 volatile u32 *ofirstadr; /* adr to R_DMA_CHx_FIRST, output */
78 volatile char *ocmdadr; /* adr to R_DMA_CHx_CMD, output */
79
80 volatile char *iclrintradr; /* adr to R_DMA_CHx_CLR_INTR, input */
81 volatile u32 *ifirstadr; /* adr to R_DMA_CHx_FIRST, input */
82 volatile char *icmdadr; /* adr to R_DMA_CHx_CMD, input */
83
84 /* Non DMA interrupt stuff */
85 unsigned long int_irq; /* R_VECT_MASK_RD */
86 const volatile u32 *irq_mask_rd; /* R_IRQ_MASKX_RD */
87 volatile u32 *irq_mask_clr; /* R_IRQ_MASKX_RD */
88 const volatile u32 *irq_read; /* R_IRQ_READX */
89 volatile u32 *irq_mask_set; /* R_IRQ_MASKX_SET */
90 unsigned long irq_mask_tx; /* bitmask in R_IRQ_ for tx (ready) int */
91 unsigned long irq_mask_rx; /* bitmask in R_IRQ_ for rx (data) int */
92 unsigned long irq_mask_ecp_cmd; /* mask in R_IRQ_ for ecp_cmd int */
93 unsigned long irq_mask_peri; /* bitmask in R_IRQ_ for peri int */
94 int portnr;
95
96 /* ----- end of fields initialised in port_table[] below ----- */
97
98 struct parport *port;
99
100 /* Shadow registers */
101 volatile unsigned long reg_ctrl_data_shadow; /* for R_PARx_CTRL_DATA */
102 volatile unsigned long reg_config_shadow; /* for R_PARx_CONFIG */
103 volatile unsigned long reg_delay_shadow; /* for R_PARx_DELAY */
104 };
105
106 /* Always have the complete structs here, even if the port is not used!
107 * (that way we can index this by the port number)
108 */
109 static struct etrax100par_struct port_table[] = {
110 {
111 R_PAR0_CTRL_DATA,
112 R_PAR0_STATUS_DATA,
113 R_PAR0_CONFIG,
114 R_PAR0_DELAY,
115 /* DMA interrupt stuff */
116 2,
117 1U << 4, /* uses DMA 2 and 3 */
118 R_DMA_CH2_CLR_INTR,
119 R_DMA_CH2_FIRST,
120 R_DMA_CH2_CMD,
121 R_DMA_CH3_CLR_INTR,
122 R_DMA_CH3_FIRST,
123 R_DMA_CH3_CMD,
124 /* Non DMA interrupt stuff */
125 IO_BITNR(R_VECT_MASK_RD, par0),
126 R_IRQ_MASK0_RD,
127 R_IRQ_MASK0_CLR,
128 R_IRQ_READ0,
129 R_IRQ_MASK0_SET,
130 IO_FIELD(R_IRQ_MASK0_RD, par0_ready, 1U), /* tx (ready)*/
131 IO_FIELD(R_IRQ_MASK0_RD, par0_data, 1U), /* rx (data)*/
132 IO_FIELD(R_IRQ_MASK0_RD, par0_ecp_cmd, 1U), /* ecp_cmd */
133 IO_FIELD(R_IRQ_MASK0_RD, par0_peri, 1U), /* peri */
134 0
135 },
136 {
137 R_PAR1_CTRL_DATA,
138 R_PAR1_STATUS_DATA,
139 R_PAR1_CONFIG,
140 R_PAR1_DELAY,
141 /* DMA interrupt stuff */
142 4,
143 1U << 8, /* uses DMA 4 and 5 */
144
145 R_DMA_CH4_CLR_INTR,
146 R_DMA_CH4_FIRST,
147 R_DMA_CH4_CMD,
148 R_DMA_CH5_CLR_INTR,
149 R_DMA_CH5_FIRST,
150 R_DMA_CH5_CMD,
151 /* Non DMA interrupt stuff */
152 IO_BITNR(R_VECT_MASK_RD, par1),
153 R_IRQ_MASK1_RD,
154 R_IRQ_MASK1_CLR,
155 R_IRQ_READ1,
156 R_IRQ_MASK1_SET,
157 IO_FIELD(R_IRQ_MASK1_RD, par1_ready, 1U), /* tx (ready)*/
158 IO_FIELD(R_IRQ_MASK1_RD, par1_data, 1U), /* rx (data)*/
159 IO_FIELD(R_IRQ_MASK1_RD, par1_ecp_cmd, 1U), /* ecp_cmd */
160 IO_FIELD(R_IRQ_MASK1_RD, par1_peri, 1U), /* peri */
161 1
162 }
163 };
164
165
166 #define NR_PORTS (sizeof(port_table)/sizeof(struct etrax100par_struct))
167
168 static void
169 parport_etrax_write_data(struct parport *p, unsigned char value)
170 {
171 struct etrax100par_struct *info =
172 (struct etrax100par_struct *)p->private_data;
173
174 DPRINTK("* E100 PP %d: etrax_write_data %02X\n", p->portnum, value);
175 SETF(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, data, value);
176 *info->reg_ctrl_data = info->reg_ctrl_data_shadow;
177 }
178
179
180 static unsigned char
181 parport_etrax_read_data(struct parport *p)
182 {
183 unsigned char ret;
184 struct etrax100par_struct *info =
185 (struct etrax100par_struct *)p->private_data;
186
187 ret = IO_EXTRACT(R_PAR0_STATUS_DATA, data, *info->reg_status_data);
188
189 DPRINTK("* E100 PP %d: etrax_read_data %02X\n", p->portnum, ret);
190 return ret;
191 }
192
193
194 static void
195 parport_etrax_write_control(struct parport *p, unsigned char control)
196 {
197 struct etrax100par_struct *info =
198 (struct etrax100par_struct *)p->private_data;
199
200 DPRINTK("* E100 PP %d: etrax_write_control %02x\n", p->portnum, control);
201
202 SETF(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, strb,
203 (control & PARPORT_CONTROL_STROBE) > 0);
204 SETF(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, autofd,
205 (control & PARPORT_CONTROL_AUTOFD) > 0);
206 SETF(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, init,
207 (control & PARPORT_CONTROL_INIT) > 0);
208 SETF(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, seli,
209 (control & PARPORT_CONTROL_SELECT) > 0);
210
211 *info->reg_ctrl_data = info->reg_ctrl_data_shadow;
212 }
213
214
215 static unsigned char
216 parport_etrax_read_control( struct parport *p)
217 {
218 unsigned char ret = 0;
219 struct etrax100par_struct *info =
220 (struct etrax100par_struct *)p->private_data;
221
222 if (IO_EXTRACT(R_PAR0_CTRL_DATA, strb, info->reg_ctrl_data_shadow))
223 ret |= PARPORT_CONTROL_STROBE;
224 if (IO_EXTRACT(R_PAR0_CTRL_DATA, autofd, info->reg_ctrl_data_shadow))
225 ret |= PARPORT_CONTROL_AUTOFD;
226 if (IO_EXTRACT(R_PAR0_CTRL_DATA, init, info->reg_ctrl_data_shadow))
227 ret |= PARPORT_CONTROL_INIT;
228 if (IO_EXTRACT(R_PAR0_CTRL_DATA, seli, info->reg_ctrl_data_shadow))
229 ret |= PARPORT_CONTROL_SELECT;
230
231 DPRINTK("* E100 PP %d: etrax_read_control %02x\n", p->portnum, ret);
232 return ret;
233 }
234
235
236 static unsigned char
237 parport_etrax_frob_control(struct parport *p, unsigned char mask,
238 unsigned char val)
239 {
240 unsigned char old;
241
242 DPRINTK("* E100 PP %d: frob_control mask %02x, value %02x\n",
243 p->portnum, mask, val);
244 old = parport_etrax_read_control(p);
245 parport_etrax_write_control(p, (old & ~mask) ^ val);
246 return old;
247 }
248
249
250 static unsigned char
251 parport_etrax_read_status(struct parport *p)
252 {
253 unsigned char ret = 0;
254 struct etrax100par_struct *info =
255 (struct etrax100par_struct *)p->private_data;
256
257 if (IO_EXTRACT(R_PAR0_STATUS_DATA, fault, *info->reg_status_data))
258 ret |= PARPORT_STATUS_ERROR;
259 if (IO_EXTRACT(R_PAR0_STATUS_DATA, sel, *info->reg_status_data))
260 ret |= PARPORT_STATUS_SELECT;
261 if (!IO_EXTRACT(R_PAR0_STATUS_DATA, perr, *info->reg_status_data))
262 ret |= PARPORT_STATUS_PAPEROUT;
263 if (IO_EXTRACT(R_PAR0_STATUS_DATA, ack, *info->reg_status_data))
264 ret |= PARPORT_STATUS_ACK;
265 if (!IO_EXTRACT(R_PAR0_STATUS_DATA, busy, *info->reg_status_data))
266 ret |= PARPORT_STATUS_BUSY;
267
268 DPRINTK("* E100 PP %d: status register %04x\n",
269 p->portnum, *info->reg_status_data);
270 DPRINTK("* E100 PP %d: read_status %02x\n", p->portnum, ret);
271 return ret;
272 }
273
274
275 static void
276 parport_etrax_enable_irq(struct parport *p)
277 {
278 struct etrax100par_struct *info =
279 (struct etrax100par_struct *)p->private_data;
280 *info->irq_mask_set = info->irq_mask_tx;
281 DPRINTK("* E100 PP %d: enable irq\n", p->portnum);
282 }
283
284
285 static void
286 parport_etrax_disable_irq(struct parport *p)
287 {
288 struct etrax100par_struct *info =
289 (struct etrax100par_struct *)p->private_data;
290 *info->irq_mask_clr = info->irq_mask_tx;
291 DPRINTK("* E100 PP %d: disable irq\n", p->portnum);
292 }
293
294
295 static void
296 parport_etrax_data_forward(struct parport *p)
297 {
298 struct etrax100par_struct *info =
299 (struct etrax100par_struct *)p->private_data;
300
301 DPRINTK("* E100 PP %d: forward mode\n", p->portnum);
302 SETS(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, oe, enable);
303 *info->reg_ctrl_data = info->reg_ctrl_data_shadow;
304 }
305
306
307 static void
308 parport_etrax_data_reverse(struct parport *p)
309 {
310 struct etrax100par_struct *info =
311 (struct etrax100par_struct *)p->private_data;
312
313 DPRINTK("* E100 PP %d: reverse mode\n", p->portnum);
314 SETS(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, oe, disable);
315 *info->reg_ctrl_data = info->reg_ctrl_data_shadow;
316 }
317
318
319 static void
320 parport_etrax_init_state(struct pardevice *dev, struct parport_state *s)
321 {
322 DPRINTK("* E100 PP: parport_etrax_init_state\n");
323 }
324
325
326 static void
327 parport_etrax_save_state(struct parport *p, struct parport_state *s)
328 {
329 DPRINTK("* E100 PP: parport_etrax_save_state\n");
330 }
331
332
333 static void
334 parport_etrax_restore_state(struct parport *p, struct parport_state *s)
335 {
336 DPRINTK("* E100 PP: parport_etrax_restore_state\n");
337 }
338
339
340 static void
341 parport_etrax_inc_use_count(void)
342 {
343 MOD_INC_USE_COUNT;
344 }
345
346
347 static void
348 parport_etrax_dec_use_count(void)
349 {
350 MOD_DEC_USE_COUNT;
351 }
352
353
354 static struct
355 parport_operations pp_etrax_ops = {
356 parport_etrax_write_data,
357 parport_etrax_read_data,
358
359 parport_etrax_write_control,
360 parport_etrax_read_control,
361 parport_etrax_frob_control,
362
363 parport_etrax_read_status,
364
365 parport_etrax_enable_irq,
366 parport_etrax_disable_irq,
367
368 parport_etrax_data_forward,
369 parport_etrax_data_reverse,
370
371 parport_etrax_init_state,
372 parport_etrax_save_state,
373 parport_etrax_restore_state,
374
375 parport_etrax_inc_use_count,
376 parport_etrax_dec_use_count,
377
378 parport_ieee1284_epp_write_data,
379 parport_ieee1284_epp_read_data,
380 parport_ieee1284_epp_write_addr,
381 parport_ieee1284_epp_read_addr,
382
383 parport_ieee1284_ecp_write_data,
384 parport_ieee1284_ecp_read_data,
385 parport_ieee1284_ecp_write_addr,
386
387 parport_ieee1284_write_compat,
388 parport_ieee1284_read_nibble,
389 parport_ieee1284_read_byte,
390 };
391
392
393 static void
394 parport_etrax_interrupt(int irq, void *dev_id, struct pt_regs *regs)
395 {
396 struct etrax100par_struct *info = (struct etrax100par_struct *)
397 ((struct parport *)dev_id)->private_data;
398 DPRINTK("* E100 PP %d: Interrupt received\n",
399 ((struct parport *)dev_id)->portnum);
400 *info->irq_mask_clr = info->irq_mask_tx;
401 parport_generic_irq(irq, (struct parport *)dev_id, regs);
402 }
403
404 /* ----------- Initialisation code --------------------------------- */
405
406 static void __init
407 parport_etrax_show_parallel_version(void)
408 {
409 printk("ETRAX 100LX parallel port driver v1.0, (c) 2001 Axis Communications AB\n");
410 }
411
412 #ifdef CONFIG_ETRAX_PAR0_DMA
413 #define PAR0_USE_DMA 1
414 #else
415 #define PAR0_USE_DMA 0
416 #endif
417
418 #ifdef CONFIG_ETRAX_PAR1_DMA
419 #define PAR1_USE_DMA 1
420 #else
421 #define PAR1_USE_DMA 0
422 #endif
423
424 static void __init
425 parport_etrax_init_registers(void)
426 {
427 struct etrax100par_struct *info;
428 int i;
429
430 for (i = 0, info = port_table; i < 2; i++, info++) {
431 #ifndef CONFIG_ETRAX_PARALLEL_PORT0
432 if (i == 0)
433 continue;
434 #endif
435 #ifndef CONFIG_ETRAX_PARALLEL_PORT1
436 if (i == 1)
437 continue;
438 #endif
439 info->reg_config_shadow =
440 IO_STATE(R_PAR0_CONFIG, iseli, inv) |
441 IO_STATE(R_PAR0_CONFIG, iautofd, inv) |
442 IO_STATE(R_PAR0_CONFIG, istrb, inv) |
443 IO_STATE(R_PAR0_CONFIG, iinit, inv) |
444 IO_STATE(R_PAR0_CONFIG, rle_in, disable) |
445 IO_STATE(R_PAR0_CONFIG, rle_out, disable) |
446 IO_STATE(R_PAR0_CONFIG, enable, on) |
447 IO_STATE(R_PAR0_CONFIG, force, off) |
448 IO_STATE(R_PAR0_CONFIG, ign_ack, wait) |
449 IO_STATE(R_PAR0_CONFIG, oe_ack, wait_oe) |
450 IO_STATE(R_PAR0_CONFIG, mode, manual);
451
452 if ((i == 0 && PAR0_USE_DMA) || (i == 1 && PAR1_USE_DMA))
453 info->reg_config_shadow |=
454 IO_STATE(R_PAR0_CONFIG, dma, enable);
455 else
456 info->reg_config_shadow |=
457 IO_STATE(R_PAR0_CONFIG, dma, disable);
458
459 *info->reg_config = info->reg_config_shadow;
460
461 info->reg_ctrl_data_shadow =
462 IO_STATE(R_PAR0_CTRL_DATA, peri_int, nop) |
463 IO_STATE(R_PAR0_CTRL_DATA, oe, enable) |
464 IO_STATE(R_PAR0_CTRL_DATA, seli, inactive) |
465 IO_STATE(R_PAR0_CTRL_DATA, autofd, inactive) |
466 IO_STATE(R_PAR0_CTRL_DATA, strb, inactive) |
467 IO_STATE(R_PAR0_CTRL_DATA, init, inactive) |
468 IO_STATE(R_PAR0_CTRL_DATA, ecp_cmd, data) |
469 IO_FIELD(R_PAR0_CTRL_DATA, data, 0);
470 *info->reg_ctrl_data = info->reg_ctrl_data_shadow;
471
472 /* Clear peri int without setting shadow */
473 *info->reg_ctrl_data = info->reg_ctrl_data_shadow |
474 IO_STATE(R_PAR0_CTRL_DATA, peri_int, ack);
475
476 info->reg_delay_shadow =
477 IO_FIELD(R_PAR0_DELAY, setup, 5) |
478 IO_FIELD(R_PAR0_DELAY, strobe, 5) |
479 IO_FIELD(R_PAR0_DELAY, hold, 5);
480 *info->reg_delay = info->reg_delay_shadow;
481 }
482
483 #ifdef CONFIG_ETRAX_PARALLEL_PORT0
484 #ifdef CONFIG_ETRAX_PAR0_DMA
485 RESET_DMA(PAR0_TX_DMA_NBR);
486 WAIT_DMA(PAR0_TX_DMA_NBR);
487 #ifdef CONFIG_ETRAX_SERIAL_PORT2
488 printk(" Warning - DMA clash with ser2!\n");
489 #endif /* SERIAL_PORT2 */
490 #endif /* DMA */
491 #endif /* PORT0 */
492
493 #ifdef CONFIG_ETRAX_PARALLEL_PORT1
494 #ifdef CONFIG_ETRAX_PAR1_DMA
495 RESET_DMA(PAR1_TX_DMA_NBR);
496 WAIT_DMA(PAR1_TX_DMA_NBR);
497 #ifdef CONFIG_ETRAX_SERIAL_PORT3
498 printk(" Warning - DMA clash with ser3!\n");
499 #endif /* SERIAL_PORT3 */
500 #endif /* DMA */
501 #endif /* PORT1 */
502 }
503
504
505 int __init
506 parport_etrax_init(void)
507 {
508 struct parport *p;
509 int port_exists = 0;
510 int i;
511 struct etrax100par_struct *info;
512 const char *names[] = { "parallel 0 tx+rx", "parallel 1 tx+rx" };
513
514 parport_etrax_show_parallel_version();
515 parport_etrax_init_registers();
516
517 for (i = 0, info = port_table; i < NR_PORTS; i++, info++) {
518 #ifndef CONFIG_ETRAX_PARALLEL_PORT0
519 if (i == 0)
520 continue;
521 #endif
522 #ifndef CONFIG_ETRAX_PARALLEL_PORT1
523 if (i == 1)
524 continue;
525 #endif
526 p = parport_register_port((unsigned long)0, info->int_irq,
527 PARPORT_DMA_NONE, &pp_etrax_ops);
528 if (!p)
529 continue;
530
531 info->port = p;
532 p->private_data = info;
533 /* Axis FIXME: Set mode flags. */
534 /* p->modes = PARPORT_MODE_TRISTATE | PARPORT_MODE_SAFEININT; */
535
536 if(request_irq(info->int_irq, parport_etrax_interrupt,
537 SA_SHIRQ, names[i], p)) {
538 parport_unregister_port (p);
539 continue;
540 }
541
542 printk(KERN_INFO "%s: ETRAX 100LX port %d using irq\n",
543 p->name, i);
544 parport_proc_register(p);
545 parport_announce_port(p);
546 port_exists = 1;
547 }
548
549 return port_exists;
550 }
551
552 void __exit
553 parport_etrax_exit(void)
554 {
555 int i;
556 struct etrax100par_struct *info;
557
558 for (i = 0, info = port_table; i < NR_PORTS; i++, info++) {
559 #ifndef CONFIG_ETRAX_PARALLEL_PORT0
560 if (i == 0)
561 continue;
562 #endif
563 #ifndef CONFIG_ETRAX_PARALLEL_PORT1
564 if (i == 1)
565 continue;
566 #endif
567 if (info->int_irq != PARPORT_IRQ_NONE)
568 free_irq(info->int_irq, info->port);
569 parport_proc_unregister(info->port);
570 parport_unregister_port(info->port);
571 }
572 }
573