?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: serial: refactor read urb submission in generic driver
[linux-2.6.git] / drivers / pcmcia / tcic.c
blob56004a1b5bbaefa4683a584a57fbf86d46525ed1
1 /*======================================================================
2
3 Device driver for Databook TCIC-2 PCMCIA controller
4
5 tcic.c 1.111 2000/02/15 04:13:12
6
7 The contents of this file are subject to the Mozilla Public
8 License Version 1.1 (the "License"); you may not use this file
9 except in compliance with the License. You may obtain a copy of
10 the License at http://www.mozilla.org/MPL/
11
12 Software distributed under the License is distributed on an "AS
13 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14 implied. See the License for the specific language governing
15 rights and limitations under the License.
16
17 The initial developer of the original code is David A. Hinds
18 <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
19 are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
20
21 Alternatively, the contents of this file may be used under the
22 terms of the GNU General Public License version 2 (the "GPL"), in which
23 case the provisions of the GPL are applicable instead of the
24 above. If you wish to allow the use of your version of this file
25 only under the terms of the GPL and not to allow others to use
26 your version of this file under the MPL, indicate your decision
27 by deleting the provisions above and replace them with the notice
28 and other provisions required by the GPL. If you do not delete
29 the provisions above, a recipient may use your version of this
30 file under either the MPL or the GPL.
31
32 ======================================================================*/
33
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/init.h>
37 #include <linux/types.h>
38 #include <linux/fcntl.h>
39 #include <linux/string.h>
40 #include <linux/errno.h>
41 #include <linux/interrupt.h>
42 #include <linux/timer.h>
43 #include <linux/ioport.h>
44 #include <linux/delay.h>
45 #include <linux/workqueue.h>
46 #include <linux/platform_device.h>
47 #include <linux/bitops.h>
48
49 #include <asm/io.h>
50 #include <asm/system.h>
51
52 #include <pcmcia/cs_types.h>
53 #include <pcmcia/cs.h>
54 #include <pcmcia/ss.h>
55 #include "tcic.h"
56
57 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
58 MODULE_DESCRIPTION("Databook TCIC-2 PCMCIA socket driver");
59 MODULE_LICENSE("Dual MPL/GPL");
60
61 /*====================================================================*/
62
63 /* Parameters that can be set with 'insmod' */
64
65 /* The base port address of the TCIC-2 chip */
66 static unsigned long tcic_base = TCIC_BASE;
67
68 /* Specify a socket number to ignore */
69 static int ignore = -1;
70
71 /* Probe for safe interrupts? */
72 static int do_scan = 1;
73
74 /* Bit map of interrupts to choose from */
75 static u_int irq_mask = 0xffff;
76 static int irq_list[16];
77 static unsigned int irq_list_count;
78
79 /* The card status change interrupt -- 0 means autoselect */
80 static int cs_irq;
81
82 /* Poll status interval -- 0 means default to interrupt */
83 static int poll_interval;
84
85 /* Delay for card status double-checking */
86 static int poll_quick = HZ/20;
87
88 /* CCLK external clock time, in nanoseconds. 70 ns = 14.31818 MHz */
89 static int cycle_time = 70;
90
91 module_param(tcic_base, ulong, 0444);
92 module_param(ignore, int, 0444);
93 module_param(do_scan, int, 0444);
94 module_param(irq_mask, int, 0444);
95 module_param_array(irq_list, int, &irq_list_count, 0444);
96 module_param(cs_irq, int, 0444);
97 module_param(poll_interval, int, 0444);
98 module_param(poll_quick, int, 0444);
99 module_param(cycle_time, int, 0444);
100
101 /*====================================================================*/
102
103 static irqreturn_t tcic_interrupt(int irq, void *dev);
104 static void tcic_timer(u_long data);
105 static struct pccard_operations tcic_operations;
106
107 struct tcic_socket {
108 u_short psock;
109 u_char last_sstat;
110 u_char id;
111 struct pcmcia_socket socket;
112 };
113
114 static struct timer_list poll_timer;
115 static int tcic_timer_pending;
116
117 static int sockets;
118 static struct tcic_socket socket_table[2];
119
120 /*====================================================================*/
121
122 /* Trick when selecting interrupts: the TCIC sktirq pin is supposed
123 to map to irq 11, but is coded as 0 or 1 in the irq registers. */
124 #define TCIC_IRQ(x) ((x) ? (((x) == 11) ? 1 : (x)) : 15)
125
126 #ifdef DEBUG_X
127 static u_char tcic_getb(u_char reg)
128 {
129 u_char val = inb(tcic_base+reg);
130 printk(KERN_DEBUG "tcic_getb(%#lx) = %#x\n", tcic_base+reg, val);
131 return val;
132 }
133
134 static u_short tcic_getw(u_char reg)
135 {
136 u_short val = inw(tcic_base+reg);
137 printk(KERN_DEBUG "tcic_getw(%#lx) = %#x\n", tcic_base+reg, val);
138 return val;
139 }
140
141 static void tcic_setb(u_char reg, u_char data)
142 {
143 printk(KERN_DEBUG "tcic_setb(%#lx, %#x)\n", tcic_base+reg, data);
144 outb(data, tcic_base+reg);
145 }
146
147 static void tcic_setw(u_char reg, u_short data)
148 {
149 printk(KERN_DEBUG "tcic_setw(%#lx, %#x)\n", tcic_base+reg, data);
150 outw(data, tcic_base+reg);
151 }
152 #else
153 #define tcic_getb(reg) inb(tcic_base+reg)
154 #define tcic_getw(reg) inw(tcic_base+reg)
155 #define tcic_setb(reg, data) outb(data, tcic_base+reg)
156 #define tcic_setw(reg, data) outw(data, tcic_base+reg)
157 #endif
158
159 static void tcic_setl(u_char reg, u_int data)
160 {
161 #ifdef DEBUG_X
162 printk(KERN_DEBUG "tcic_setl(%#x, %#lx)\n", tcic_base+reg, data);
163 #endif
164 outw(data & 0xffff, tcic_base+reg);
165 outw(data >> 16, tcic_base+reg+2);
166 }
167
168 static void tcic_aux_setb(u_short reg, u_char data)
169 {
170 u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
171 tcic_setb(TCIC_MODE, mode);
172 tcic_setb(TCIC_AUX, data);
173 }
174
175 static u_short tcic_aux_getw(u_short reg)
176 {
177 u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
178 tcic_setb(TCIC_MODE, mode);
179 return tcic_getw(TCIC_AUX);
180 }
181
182 static void tcic_aux_setw(u_short reg, u_short data)
183 {
184 u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
185 tcic_setb(TCIC_MODE, mode);
186 tcic_setw(TCIC_AUX, data);
187 }
188
189 /*====================================================================*/
190
191 /* Time conversion functions */
192
193 static int to_cycles(int ns)
194 {
195 if (ns < 14)
196 return 0;
197 else
198 return 2*(ns-14)/cycle_time;
199 }
200
201 /*====================================================================*/
202
203 static volatile u_int irq_hits;
204
205 static irqreturn_t __init tcic_irq_count(int irq, void *dev)
206 {
207 irq_hits++;
208 return IRQ_HANDLED;
209 }
210
211 static u_int __init try_irq(int irq)
212 {
213 u_short cfg;
214
215 irq_hits = 0;
216 if (request_irq(irq, tcic_irq_count, 0, "irq scan", tcic_irq_count) != 0)
217 return -1;
218 mdelay(10);
219 if (irq_hits) {
220 free_irq(irq, tcic_irq_count);
221 return -1;
222 }
223
224 /* Generate one interrupt */
225 cfg = TCIC_SYSCFG_AUTOBUSY | 0x0a00;
226 tcic_aux_setw(TCIC_AUX_SYSCFG, cfg | TCIC_IRQ(irq));
227 tcic_setb(TCIC_IENA, TCIC_IENA_ERR | TCIC_IENA_CFG_HIGH);
228 tcic_setb(TCIC_ICSR, TCIC_ICSR_ERR | TCIC_ICSR_JAM);
229
230 udelay(1000);
231 free_irq(irq, tcic_irq_count);
232
233 /* Turn off interrupts */
234 tcic_setb(TCIC_IENA, TCIC_IENA_CFG_OFF);
235 while (tcic_getb(TCIC_ICSR))
236 tcic_setb(TCIC_ICSR, TCIC_ICSR_JAM);
237 tcic_aux_setw(TCIC_AUX_SYSCFG, cfg);
238
239 return (irq_hits != 1);
240 }
241
242 static u_int __init irq_scan(u_int mask0)
243 {
244 u_int mask1;
245 int i;
246
247 #ifdef __alpha__
248 #define PIC 0x4d0
249 /* Don't probe level-triggered interrupts -- reserved for PCI */
250 int level_mask = inb_p(PIC) | (inb_p(PIC+1) << 8);
251 if (level_mask)
252 mask0 &= ~level_mask;
253 #endif
254
255 mask1 = 0;
256 if (do_scan) {
257 for (i = 0; i < 16; i++)
258 if ((mask0 & (1 << i)) && (try_irq(i) == 0))
259 mask1 |= (1 << i);
260 for (i = 0; i < 16; i++)
261 if ((mask1 & (1 << i)) && (try_irq(i) != 0)) {
262 mask1 ^= (1 << i);
263 }
264 }
265
266 if (mask1) {
267 printk("scanned");
268 } else {
269 /* Fallback: just find interrupts that aren't in use */
270 for (i = 0; i < 16; i++)
271 if ((mask0 & (1 << i)) &&
272 (request_irq(i, tcic_irq_count, 0, "x", tcic_irq_count) == 0)) {
273 mask1 |= (1 << i);
274 free_irq(i, tcic_irq_count);
275 }
276 printk("default");
277 }
278
279 printk(") = ");
280 for (i = 0; i < 16; i++)
281 if (mask1 & (1<<i))
282 printk("%s%d", ((mask1 & ((1<<i)-1)) ? "," : ""), i);
283 printk(" ");
284
285 return mask1;
286 }
287
288 /*======================================================================
289
290 See if a card is present, powered up, in IO mode, and already
291 bound to a (non-PCMCIA) Linux driver.
292
293 We make an exception for cards that look like serial devices.
294
295 ======================================================================*/
296
297 static int __init is_active(int s)
298 {
299 u_short scf1, ioctl, base, num;
300 u_char pwr, sstat;
301 u_int addr;
302
303 tcic_setl(TCIC_ADDR, (s << TCIC_ADDR_SS_SHFT)
304 | TCIC_ADDR_INDREG | TCIC_SCF1(s));
305 scf1 = tcic_getw(TCIC_DATA);
306 pwr = tcic_getb(TCIC_PWR);
307 sstat = tcic_getb(TCIC_SSTAT);
308 addr = TCIC_IWIN(s, 0);
309 tcic_setw(TCIC_ADDR, addr + TCIC_IBASE_X);
310 base = tcic_getw(TCIC_DATA);
311 tcic_setw(TCIC_ADDR, addr + TCIC_ICTL_X);
312 ioctl = tcic_getw(TCIC_DATA);
313
314 if (ioctl & TCIC_ICTL_TINY)
315 num = 1;
316 else {
317 num = (base ^ (base-1));
318 base = base & (base-1);
319 }
320
321 if ((sstat & TCIC_SSTAT_CD) && (pwr & TCIC_PWR_VCC(s)) &&
322 (scf1 & TCIC_SCF1_IOSTS) && (ioctl & TCIC_ICTL_ENA) &&
323 ((base & 0xfeef) != 0x02e8)) {
324 struct resource *res = request_region(base, num, "tcic-2");
325 if (!res) /* region is busy */
326 return 1;
327 release_region(base, num);
328 }
329
330 return 0;
331 }
332
333 /*======================================================================
334
335 This returns the revision code for the specified socket.
336
337 ======================================================================*/
338
339 static int __init get_tcic_id(void)
340 {
341 u_short id;
342
343 tcic_aux_setw(TCIC_AUX_TEST, TCIC_TEST_DIAG);
344 id = tcic_aux_getw(TCIC_AUX_ILOCK);
345 id = (id & TCIC_ILOCKTEST_ID_MASK) >> TCIC_ILOCKTEST_ID_SH;
346 tcic_aux_setw(TCIC_AUX_TEST, 0);
347 return id;
348 }
349
350 /*====================================================================*/
351
352 static struct platform_driver tcic_driver = {
353 .driver = {
354 .name = "tcic-pcmcia",
355 .owner = THIS_MODULE,
356 },
357 };
358
359 static struct platform_device tcic_device = {
360 .name = "tcic-pcmcia",
361 .id = 0,
362 };
363
364
365 static int __init init_tcic(void)
366 {
367 int i, sock, ret = 0;
368 u_int mask, scan;
369
370 if (platform_driver_register(&tcic_driver))
371 return -1;
372
373 printk(KERN_INFO "Databook TCIC-2 PCMCIA probe: ");
374 sock = 0;
375
376 if (!request_region(tcic_base, 16, "tcic-2")) {
377 printk("could not allocate ports,\n ");
378 platform_driver_unregister(&tcic_driver);
379 return -ENODEV;
380 }
381 else {
382 tcic_setw(TCIC_ADDR, 0);
383 if (tcic_getw(TCIC_ADDR) == 0) {
384 tcic_setw(TCIC_ADDR, 0xc3a5);
385 if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2;
386 }
387 if (sock == 0) {
388 /* See if resetting the controller does any good */
389 tcic_setb(TCIC_SCTRL, TCIC_SCTRL_RESET);
390 tcic_setb(TCIC_SCTRL, 0);
391 tcic_setw(TCIC_ADDR, 0);
392 if (tcic_getw(TCIC_ADDR) == 0) {
393 tcic_setw(TCIC_ADDR, 0xc3a5);
394 if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2;
395 }
396 }
397 }
398 if (sock == 0) {
399 printk("not found.\n");
400 release_region(tcic_base, 16);
401 platform_driver_unregister(&tcic_driver);
402 return -ENODEV;
403 }
404
405 sockets = 0;
406 for (i = 0; i < sock; i++) {
407 if ((i == ignore) || is_active(i)) continue;
408 socket_table[sockets].psock = i;
409 socket_table[sockets].id = get_tcic_id();
410
411 socket_table[sockets].socket.owner = THIS_MODULE;
412 /* only 16-bit cards, memory windows must be size-aligned */
413 /* No PCI or CardBus support */
414 socket_table[sockets].socket.features = SS_CAP_PCCARD | SS_CAP_MEM_ALIGN;
415 /* irq 14, 11, 10, 7, 6, 5, 4, 3 */
416 socket_table[sockets].socket.irq_mask = 0x4cf8;
417 /* 4K minimum window size */
418 socket_table[sockets].socket.map_size = 0x1000;
419 sockets++;
420 }
421
422 switch (socket_table[0].id) {
423 case TCIC_ID_DB86082:
424 printk("DB86082"); break;
425 case TCIC_ID_DB86082A:
426 printk("DB86082A"); break;
427 case TCIC_ID_DB86084:
428 printk("DB86084"); break;
429 case TCIC_ID_DB86084A:
430 printk("DB86084A"); break;
431 case TCIC_ID_DB86072:
432 printk("DB86072"); break;
433 case TCIC_ID_DB86184:
434 printk("DB86184"); break;
435 case TCIC_ID_DB86082B:
436 printk("DB86082B"); break;
437 default:
438 printk("Unknown ID 0x%02x", socket_table[0].id);
439 }
440
441 /* Set up polling */
442 poll_timer.function = &tcic_timer;
443 poll_timer.data = 0;
444 init_timer(&poll_timer);
445
446 /* Build interrupt mask */
447 printk(KERN_CONT ", %d sockets\n", sockets);
448 printk(KERN_INFO " irq list (");
449 if (irq_list_count == 0)
450 mask = irq_mask;
451 else
452 for (i = mask = 0; i < irq_list_count; i++)
453 mask |= (1<<irq_list[i]);
454
455 /* irq 14, 11, 10, 7, 6, 5, 4, 3 */
456 mask &= 0x4cf8;
457 /* Scan interrupts */
458 mask = irq_scan(mask);
459 for (i=0;i<sockets;i++)
460 socket_table[i].socket.irq_mask = mask;
461
462 /* Check for only two interrupts available */
463 scan = (mask & (mask-1));
464 if (((scan & (scan-1)) == 0) && (poll_interval == 0))
465 poll_interval = HZ;
466
467 if (poll_interval == 0) {
468 /* Avoid irq 12 unless it is explicitly requested */
469 u_int cs_mask = mask & ((cs_irq) ? (1<<cs_irq) : ~(1<<12));
470 for (i = 15; i > 0; i--)
471 if ((cs_mask & (1 << i)) &&
472 (request_irq(i, tcic_interrupt, 0, "tcic",
473 tcic_interrupt) == 0))
474 break;
475 cs_irq = i;
476 if (cs_irq == 0) poll_interval = HZ;
477 }
478
479 if (socket_table[0].socket.irq_mask & (1 << 11))
480 printk("sktirq is irq 11, ");
481 if (cs_irq != 0)
482 printk("status change on irq %d\n", cs_irq);
483 else
484 printk("polled status, interval = %d ms\n",
485 poll_interval * 1000 / HZ);
486
487 for (i = 0; i < sockets; i++) {
488 tcic_setw(TCIC_ADDR+2, socket_table[i].psock << TCIC_SS_SHFT);
489 socket_table[i].last_sstat = tcic_getb(TCIC_SSTAT);
490 }
491
492 /* jump start interrupt handler, if needed */
493 tcic_interrupt(0, NULL);
494
495 platform_device_register(&tcic_device);
496
497 for (i = 0; i < sockets; i++) {
498 socket_table[i].socket.ops = &tcic_operations;
499 socket_table[i].socket.resource_ops = &pccard_nonstatic_ops;
500 socket_table[i].socket.dev.parent = &tcic_device.dev;
501 ret = pcmcia_register_socket(&socket_table[i].socket);
502 if (ret && i)
503 pcmcia_unregister_socket(&socket_table[0].socket);
504 }
505
506 return ret;
507
508 return 0;
509
510 } /* init_tcic */
511
512 /*====================================================================*/
513
514 static void __exit exit_tcic(void)
515 {
516 int i;
517
518 del_timer_sync(&poll_timer);
519 if (cs_irq != 0) {
520 tcic_aux_setw(TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY|0x0a00);
521 free_irq(cs_irq, tcic_interrupt);
522 }
523 release_region(tcic_base, 16);
524
525 for (i = 0; i < sockets; i++) {
526 pcmcia_unregister_socket(&socket_table[i].socket);
527 }
528
529 platform_device_unregister(&tcic_device);
530 platform_driver_unregister(&tcic_driver);
531 } /* exit_tcic */
532
533 /*====================================================================*/
534
535 static irqreturn_t tcic_interrupt(int irq, void *dev)
536 {
537 int i, quick = 0;
538 u_char latch, sstat;
539 u_short psock;
540 u_int events;
541 static volatile int active = 0;
542
543 if (active) {
544 printk(KERN_NOTICE "tcic: reentered interrupt handler!\n");
545 return IRQ_NONE;
546 } else
547 active = 1;
548
549 pr_debug("tcic_interrupt()\n");
550
551 for (i = 0; i < sockets; i++) {
552 psock = socket_table[i].psock;
553 tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
554 | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
555 sstat = tcic_getb(TCIC_SSTAT);
556 latch = sstat ^ socket_table[psock].last_sstat;
557 socket_table[i].last_sstat = sstat;
558 if (tcic_getb(TCIC_ICSR) & TCIC_ICSR_CDCHG) {
559 tcic_setb(TCIC_ICSR, TCIC_ICSR_CLEAR);
560 quick = 1;
561 }
562 if (latch == 0)
563 continue;
564 events = (latch & TCIC_SSTAT_CD) ? SS_DETECT : 0;
565 events |= (latch & TCIC_SSTAT_WP) ? SS_WRPROT : 0;
566 if (tcic_getw(TCIC_DATA) & TCIC_SCF1_IOSTS) {
567 events |= (latch & TCIC_SSTAT_LBAT1) ? SS_STSCHG : 0;
568 } else {
569 events |= (latch & TCIC_SSTAT_RDY) ? SS_READY : 0;
570 events |= (latch & TCIC_SSTAT_LBAT1) ? SS_BATDEAD : 0;
571 events |= (latch & TCIC_SSTAT_LBAT2) ? SS_BATWARN : 0;
572 }
573 if (events) {
574 pcmcia_parse_events(&socket_table[i].socket, events);
575 }
576 }
577
578 /* Schedule next poll, if needed */
579 if (((cs_irq == 0) || quick) && (!tcic_timer_pending)) {
580 poll_timer.expires = jiffies + (quick ? poll_quick : poll_interval);
581 add_timer(&poll_timer);
582 tcic_timer_pending = 1;
583 }
584 active = 0;
585
586 pr_debug("interrupt done\n");
587 return IRQ_HANDLED;
588 } /* tcic_interrupt */
589
590 static void tcic_timer(u_long data)
591 {
592 pr_debug("tcic_timer()\n");
593 tcic_timer_pending = 0;
594 tcic_interrupt(0, NULL);
595 } /* tcic_timer */
596
597 /*====================================================================*/
598
599 static int tcic_get_status(struct pcmcia_socket *sock, u_int *value)
600 {
601 u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
602 u_char reg;
603
604 tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
605 | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
606 reg = tcic_getb(TCIC_SSTAT);
607 *value = (reg & TCIC_SSTAT_CD) ? SS_DETECT : 0;
608 *value |= (reg & TCIC_SSTAT_WP) ? SS_WRPROT : 0;
609 if (tcic_getw(TCIC_DATA) & TCIC_SCF1_IOSTS) {
610 *value |= (reg & TCIC_SSTAT_LBAT1) ? SS_STSCHG : 0;
611 } else {
612 *value |= (reg & TCIC_SSTAT_RDY) ? SS_READY : 0;
613 *value |= (reg & TCIC_SSTAT_LBAT1) ? SS_BATDEAD : 0;
614 *value |= (reg & TCIC_SSTAT_LBAT2) ? SS_BATWARN : 0;
615 }
616 reg = tcic_getb(TCIC_PWR);
617 if (reg & (TCIC_PWR_VCC(psock)|TCIC_PWR_VPP(psock)))
618 *value |= SS_POWERON;
619 dev_dbg(&sock->dev, "GetStatus(%d) = %#2.2x\n", psock, *value);
620 return 0;
621 } /* tcic_get_status */
622
623 /*====================================================================*/
624
625 static int tcic_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
626 {
627 u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
628 u_char reg;
629 u_short scf1, scf2;
630
631 dev_dbg(&sock->dev, "SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
632 "io_irq %d, csc_mask %#2.2x)\n", psock, state->flags,
633 state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
634 tcic_setw(TCIC_ADDR+2, (psock << TCIC_SS_SHFT) | TCIC_ADR2_INDREG);
635
636 reg = tcic_getb(TCIC_PWR);
637 reg &= ~(TCIC_PWR_VCC(psock) | TCIC_PWR_VPP(psock));
638
639 if (state->Vcc == 50) {
640 switch (state->Vpp) {
641 case 0: reg |= TCIC_PWR_VCC(psock) | TCIC_PWR_VPP(psock); break;
642 case 50: reg |= TCIC_PWR_VCC(psock); break;
643 case 120: reg |= TCIC_PWR_VPP(psock); break;
644 default: return -EINVAL;
645 }
646 } else if (state->Vcc != 0)
647 return -EINVAL;
648
649 if (reg != tcic_getb(TCIC_PWR))
650 tcic_setb(TCIC_PWR, reg);
651
652 reg = TCIC_ILOCK_HOLD_CCLK | TCIC_ILOCK_CWAIT;
653 if (state->flags & SS_OUTPUT_ENA) {
654 tcic_setb(TCIC_SCTRL, TCIC_SCTRL_ENA);
655 reg |= TCIC_ILOCK_CRESENA;
656 } else
657 tcic_setb(TCIC_SCTRL, 0);
658 if (state->flags & SS_RESET)
659 reg |= TCIC_ILOCK_CRESET;
660 tcic_aux_setb(TCIC_AUX_ILOCK, reg);
661
662 tcic_setw(TCIC_ADDR, TCIC_SCF1(psock));
663 scf1 = TCIC_SCF1_FINPACK;
664 scf1 |= TCIC_IRQ(state->io_irq);
665 if (state->flags & SS_IOCARD) {
666 scf1 |= TCIC_SCF1_IOSTS;
667 if (state->flags & SS_SPKR_ENA)
668 scf1 |= TCIC_SCF1_SPKR;
669 if (state->flags & SS_DMA_MODE)
670 scf1 |= TCIC_SCF1_DREQ2 << TCIC_SCF1_DMA_SHIFT;
671 }
672 tcic_setw(TCIC_DATA, scf1);
673
674 /* Some general setup stuff, and configure status interrupt */
675 reg = TCIC_WAIT_ASYNC | TCIC_WAIT_SENSE | to_cycles(250);
676 tcic_aux_setb(TCIC_AUX_WCTL, reg);
677 tcic_aux_setw(TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY|0x0a00|
678 TCIC_IRQ(cs_irq));
679
680 /* Card status change interrupt mask */
681 tcic_setw(TCIC_ADDR, TCIC_SCF2(psock));
682 scf2 = TCIC_SCF2_MALL;
683 if (state->csc_mask & SS_DETECT) scf2 &= ~TCIC_SCF2_MCD;
684 if (state->flags & SS_IOCARD) {
685 if (state->csc_mask & SS_STSCHG) reg &= ~TCIC_SCF2_MLBAT1;
686 } else {
687 if (state->csc_mask & SS_BATDEAD) reg &= ~TCIC_SCF2_MLBAT1;
688 if (state->csc_mask & SS_BATWARN) reg &= ~TCIC_SCF2_MLBAT2;
689 if (state->csc_mask & SS_READY) reg &= ~TCIC_SCF2_MRDY;
690 }
691 tcic_setw(TCIC_DATA, scf2);
692 /* For the ISA bus, the irq should be active-high totem-pole */
693 tcic_setb(TCIC_IENA, TCIC_IENA_CDCHG | TCIC_IENA_CFG_HIGH);
694
695 return 0;
696 } /* tcic_set_socket */
697
698 /*====================================================================*/
699
700 static int tcic_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
701 {
702 u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
703 u_int addr;
704 u_short base, len, ioctl;
705
706 dev_dbg(&sock->dev, "SetIOMap(%d, %d, %#2.2x, %d ns, "
707 "%#llx-%#llx)\n", psock, io->map, io->flags, io->speed,
708 (unsigned long long)io->start, (unsigned long long)io->stop);
709 if ((io->map > 1) || (io->start > 0xffff) || (io->stop > 0xffff) ||
710 (io->stop < io->start)) return -EINVAL;
711 tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
712 addr = TCIC_IWIN(psock, io->map);
713
714 base = io->start; len = io->stop - io->start;
715 /* Check to see that len+1 is power of two, etc */
716 if ((len & (len+1)) || (base & len)) return -EINVAL;
717 base |= (len+1)>>1;
718 tcic_setw(TCIC_ADDR, addr + TCIC_IBASE_X);
719 tcic_setw(TCIC_DATA, base);
720
721 ioctl = (psock << TCIC_ICTL_SS_SHFT);
722 ioctl |= (len == 0) ? TCIC_ICTL_TINY : 0;
723 ioctl |= (io->flags & MAP_ACTIVE) ? TCIC_ICTL_ENA : 0;
724 ioctl |= to_cycles(io->speed) & TCIC_ICTL_WSCNT_MASK;
725 if (!(io->flags & MAP_AUTOSZ)) {
726 ioctl |= TCIC_ICTL_QUIET;
727 ioctl |= (io->flags & MAP_16BIT) ? TCIC_ICTL_BW_16 : TCIC_ICTL_BW_8;
728 }
729 tcic_setw(TCIC_ADDR, addr + TCIC_ICTL_X);
730 tcic_setw(TCIC_DATA, ioctl);
731
732 return 0;
733 } /* tcic_set_io_map */
734
735 /*====================================================================*/
736
737 static int tcic_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem)
738 {
739 u_short psock = container_of(sock, struct tcic_socket, socket)->psock;
740 u_short addr, ctl;
741 u_long base, len, mmap;
742
743 dev_dbg(&sock->dev, "SetMemMap(%d, %d, %#2.2x, %d ns, "
744 "%#llx-%#llx, %#x)\n", psock, mem->map, mem->flags,
745 mem->speed, (unsigned long long)mem->res->start,
746 (unsigned long long)mem->res->end, mem->card_start);
747 if ((mem->map > 3) || (mem->card_start > 0x3ffffff) ||
748 (mem->res->start > 0xffffff) || (mem->res->end > 0xffffff) ||
749 (mem->res->start > mem->res->end) || (mem->speed > 1000))
750 return -EINVAL;
751 tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
752 addr = TCIC_MWIN(psock, mem->map);
753
754 base = mem->res->start; len = mem->res->end - mem->res->start;
755 if ((len & (len+1)) || (base & len)) return -EINVAL;
756 if (len == 0x0fff)
757 base = (base >> TCIC_MBASE_HA_SHFT) | TCIC_MBASE_4K_BIT;
758 else
759 base = (base | (len+1)>>1) >> TCIC_MBASE_HA_SHFT;
760 tcic_setw(TCIC_ADDR, addr + TCIC_MBASE_X);
761 tcic_setw(TCIC_DATA, base);
762
763 mmap = mem->card_start - mem->res->start;
764 mmap = (mmap >> TCIC_MMAP_CA_SHFT) & TCIC_MMAP_CA_MASK;
765 if (mem->flags & MAP_ATTRIB) mmap |= TCIC_MMAP_REG;
766 tcic_setw(TCIC_ADDR, addr + TCIC_MMAP_X);
767 tcic_setw(TCIC_DATA, mmap);
768
769 ctl = TCIC_MCTL_QUIET | (psock << TCIC_MCTL_SS_SHFT);
770 ctl |= to_cycles(mem->speed) & TCIC_MCTL_WSCNT_MASK;
771 ctl |= (mem->flags & MAP_16BIT) ? 0 : TCIC_MCTL_B8;
772 ctl |= (mem->flags & MAP_WRPROT) ? TCIC_MCTL_WP : 0;
773 ctl |= (mem->flags & MAP_ACTIVE) ? TCIC_MCTL_ENA : 0;
774 tcic_setw(TCIC_ADDR, addr + TCIC_MCTL_X);
775 tcic_setw(TCIC_DATA, ctl);
776
777 return 0;
778 } /* tcic_set_mem_map */
779
780 /*====================================================================*/
781
782 static int tcic_init(struct pcmcia_socket *s)
783 {
784 int i;
785 struct resource res = { .start = 0, .end = 0x1000 };
786 pccard_io_map io = { 0, 0, 0, 0, 1 };
787 pccard_mem_map mem = { .res = &res, };
788
789 for (i = 0; i < 2; i++) {
790 io.map = i;
791 tcic_set_io_map(s, &io);
792 }
793 for (i = 0; i < 5; i++) {
794 mem.map = i;
795 tcic_set_mem_map(s, &mem);
796 }
797 return 0;
798 }
799
800 static struct pccard_operations tcic_operations = {
801 .init = tcic_init,
802 .get_status = tcic_get_status,
803 .set_socket = tcic_set_socket,
804 .set_io_map = tcic_set_io_map,
805 .set_mem_map = tcic_set_mem_map,
806 };
807
808 /*====================================================================*/
809
810 module_init(init_tcic);
811 module_exit(exit_tcic);
Linus' kernel tree