[PATCH] pcmcia: remove dev_list from drivers
[linux-2.6] / drivers / scsi / pcmcia / sym53c500_cs.c
1 /*
2 *  sym53c500_cs.c       Bob Tracy (rct@frus.com)
3 *
4 *  A rewrite of the pcmcia-cs add-on driver for newer (circa 1997)
5 *  New Media Bus Toaster PCMCIA SCSI cards using the Symbios Logic
6 *  53c500 controller: intended for use with 2.6 and later kernels.
7 *  The pcmcia-cs add-on version of this driver is not supported
8 *  beyond 2.4.  It consisted of three files with history/copyright
9 *  information as follows:
10 *
11 *  SYM53C500.h
12 *       Bob Tracy (rct@frus.com)
13 *       Original by Tom Corner (tcorner@via.at).
14 *       Adapted from NCR53c406a.h which is Copyrighted (C) 1994
15 *       Normunds Saumanis (normunds@rx.tech.swh.lv)
16 *
17 *  SYM53C500.c
18 *       Bob Tracy (rct@frus.com)
19 *       Original driver by Tom Corner (tcorner@via.at) was adapted
20 *       from NCR53c406a.c which is Copyrighted (C) 1994, 1995, 1996 
21 *       Normunds Saumanis (normunds@fi.ibm.com)
22 *
23 *  sym53c500.c
24 *       Bob Tracy (rct@frus.com)
25 *       Original by Tom Corner (tcorner@via.at) was adapted from a
26 *       driver for the Qlogic SCSI card written by
27 *       David Hinds (dhinds@allegro.stanford.edu).
28
29 *  This program is free software; you can redistribute it and/or modify it
30 *  under the terms of the GNU General Public License as published by the
31 *  Free Software Foundation; either version 2, or (at your option) any
32 *  later version.
33 *
34 *  This program is distributed in the hope that it will be useful, but
35 *  WITHOUT ANY WARRANTY; without even the implied warranty of
36 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
37 *  General Public License for more details.
38 */
39
40 #define SYM53C500_DEBUG 0
41 #define VERBOSE_SYM53C500_DEBUG 0
42
43 /*
44 *  Set this to 0 if you encounter kernel lockups while transferring 
45 *  data in PIO mode.  Note this can be changed via "sysfs".
46 */
47 #define USE_FAST_PIO 1
48
49 /* =============== End of user configurable parameters ============== */
50
51 #include <linux/module.h>
52 #include <linux/moduleparam.h>
53 #include <linux/errno.h>
54 #include <linux/init.h>
55 #include <linux/interrupt.h>
56 #include <linux/kernel.h>
57 #include <linux/sched.h>
58 #include <linux/slab.h>
59 #include <linux/string.h>
60 #include <linux/ioport.h>
61 #include <linux/blkdev.h>
62 #include <linux/spinlock.h>
63 #include <linux/bitops.h>
64
65 #include <asm/io.h>
66 #include <asm/dma.h>
67 #include <asm/irq.h>
68
69 #include <scsi/scsi_ioctl.h>
70 #include <scsi/scsi_cmnd.h>
71 #include <scsi/scsi_device.h>
72 #include <scsi/scsi.h>
73 #include <scsi/scsi_host.h>
74
75 #include <pcmcia/cs_types.h>
76 #include <pcmcia/cs.h>
77 #include <pcmcia/cistpl.h>
78 #include <pcmcia/ds.h>
79 #include <pcmcia/ciscode.h>
80
81 /* ================================================================== */
82
83 #ifdef PCMCIA_DEBUG
84 static int pc_debug = PCMCIA_DEBUG;
85 module_param(pc_debug, int, 0);
86 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
87 static char *version =
88 "sym53c500_cs.c 0.9c 2004/10/27 (Bob Tracy)";
89 #else
90 #define DEBUG(n, args...)
91 #endif
92
93 /* ================================================================== */
94
95 #define SYNC_MODE 0             /* Synchronous transfer mode */
96
97 /* Default configuration */
98 #define C1_IMG   0x07           /* ID=7 */
99 #define C2_IMG   0x48           /* FE SCSI2 */
100 #define C3_IMG   0x20           /* CDB */
101 #define C4_IMG   0x04           /* ANE */
102 #define C5_IMG   0xa4           /* ? changed from b6= AA PI SIE POL */
103 #define C7_IMG   0x80           /* added for SYM53C500 t. corner */
104
105 /* Hardware Registers: offsets from io_port (base) */
106
107 /* Control Register Set 0 */
108 #define TC_LSB          0x00            /* transfer counter lsb */
109 #define TC_MSB          0x01            /* transfer counter msb */
110 #define SCSI_FIFO       0x02            /* scsi fifo register */
111 #define CMD_REG         0x03            /* command register */
112 #define STAT_REG        0x04            /* status register */
113 #define DEST_ID         0x04            /* selection/reselection bus id */
114 #define INT_REG         0x05            /* interrupt status register */
115 #define SRTIMOUT        0x05            /* select/reselect timeout reg */
116 #define SEQ_REG         0x06            /* sequence step register */
117 #define SYNCPRD         0x06            /* synchronous transfer period */
118 #define FIFO_FLAGS      0x07            /* indicates # of bytes in fifo */
119 #define SYNCOFF         0x07            /* synchronous offset register */
120 #define CONFIG1         0x08            /* configuration register */
121 #define CLKCONV         0x09            /* clock conversion register */
122 /* #define TESTREG      0x0A */         /* test mode register */
123 #define CONFIG2         0x0B            /* configuration 2 register */
124 #define CONFIG3         0x0C            /* configuration 3 register */
125 #define CONFIG4         0x0D            /* configuration 4 register */
126 #define TC_HIGH         0x0E            /* transfer counter high */
127 /* #define FIFO_BOTTOM  0x0F */         /* reserve FIFO byte register */
128
129 /* Control Register Set 1 */
130 /* #define JUMPER_SENSE 0x00 */         /* jumper sense port reg (r/w) */
131 /* #define SRAM_PTR     0x01 */         /* SRAM address pointer reg (r/w) */
132 /* #define SRAM_DATA    0x02 */         /* SRAM data register (r/w) */
133 #define PIO_FIFO        0x04            /* PIO FIFO registers (r/w) */
134 /* #define PIO_FIFO1    0x05 */         /*  */
135 /* #define PIO_FIFO2    0x06 */         /*  */
136 /* #define PIO_FIFO3    0x07 */         /*  */
137 #define PIO_STATUS      0x08            /* PIO status (r/w) */
138 /* #define ATA_CMD      0x09 */         /* ATA command/status reg (r/w) */
139 /* #define ATA_ERR      0x0A */         /* ATA features/error reg (r/w) */
140 #define PIO_FLAG        0x0B            /* PIO flag interrupt enable (r/w) */
141 #define CONFIG5         0x09            /* configuration 5 register */
142 /* #define SIGNATURE    0x0E */         /* signature register (r) */
143 /* #define CONFIG6      0x0F */         /* configuration 6 register (r) */
144 #define CONFIG7         0x0d
145
146 /* select register set 0 */
147 #define REG0(x)         (outb(C4_IMG, (x) + CONFIG4))
148 /* select register set 1 */
149 #define REG1(x)         outb(C7_IMG, (x) + CONFIG7); outb(C5_IMG, (x) + CONFIG5)
150
151 #if SYM53C500_DEBUG
152 #define DEB(x) x
153 #else
154 #define DEB(x)
155 #endif
156
157 #if VERBOSE_SYM53C500_DEBUG
158 #define VDEB(x) x
159 #else
160 #define VDEB(x)
161 #endif
162
163 #define LOAD_DMA_COUNT(x, count) \
164   outb(count & 0xff, (x) + TC_LSB); \
165   outb((count >> 8) & 0xff, (x) + TC_MSB); \
166   outb((count >> 16) & 0xff, (x) + TC_HIGH);
167
168 /* Chip commands */
169 #define DMA_OP               0x80
170
171 #define SCSI_NOP             0x00
172 #define FLUSH_FIFO           0x01
173 #define CHIP_RESET           0x02
174 #define SCSI_RESET           0x03
175 #define RESELECT             0x40
176 #define SELECT_NO_ATN        0x41
177 #define SELECT_ATN           0x42
178 #define SELECT_ATN_STOP      0x43
179 #define ENABLE_SEL           0x44
180 #define DISABLE_SEL          0x45
181 #define SELECT_ATN3          0x46
182 #define RESELECT3            0x47
183 #define TRANSFER_INFO        0x10
184 #define INIT_CMD_COMPLETE    0x11
185 #define MSG_ACCEPT           0x12
186 #define TRANSFER_PAD         0x18
187 #define SET_ATN              0x1a
188 #define RESET_ATN            0x1b
189 #define SEND_MSG             0x20
190 #define SEND_STATUS          0x21
191 #define SEND_DATA            0x22
192 #define DISCONN_SEQ          0x23
193 #define TERMINATE_SEQ        0x24
194 #define TARG_CMD_COMPLETE    0x25
195 #define DISCONN              0x27
196 #define RECV_MSG             0x28
197 #define RECV_CMD             0x29
198 #define RECV_DATA            0x2a
199 #define RECV_CMD_SEQ         0x2b
200 #define TARGET_ABORT_DMA     0x04
201
202 /* ================================================================== */
203
204 struct scsi_info_t {
205         dev_link_t link;
206         dev_node_t node;
207         struct Scsi_Host *host;
208         unsigned short manf_id;
209 };
210
211 /*
212 *  Repository for per-instance host data.
213 */
214 struct sym53c500_data {
215         struct scsi_cmnd *current_SC;
216         int fast_pio;
217 };
218
219 enum Phase {
220     idle,
221     data_out,
222     data_in,
223     command_ph,
224     status_ph,
225     message_out,
226     message_in
227 };
228
229 /* ================================================================== */
230
231 /*
232 *  Global (within this module) variables other than
233 *  sym53c500_driver_template (the scsi_host_template).
234 */
235 static dev_info_t dev_info = "sym53c500_cs";
236
237 /* ================================================================== */
238
239 static void
240 chip_init(int io_port)
241 {
242         REG1(io_port);
243         outb(0x01, io_port + PIO_STATUS);
244         outb(0x00, io_port + PIO_FLAG);
245
246         outb(C4_IMG, io_port + CONFIG4);        /* REG0(io_port); */
247         outb(C3_IMG, io_port + CONFIG3);
248         outb(C2_IMG, io_port + CONFIG2);
249         outb(C1_IMG, io_port + CONFIG1);
250
251         outb(0x05, io_port + CLKCONV);  /* clock conversion factor */
252         outb(0x9C, io_port + SRTIMOUT); /* Selection timeout */
253         outb(0x05, io_port + SYNCPRD);  /* Synchronous transfer period */
254         outb(SYNC_MODE, io_port + SYNCOFF);     /* synchronous mode */  
255 }
256
257 static void
258 SYM53C500_int_host_reset(int io_port)
259 {
260         outb(C4_IMG, io_port + CONFIG4);        /* REG0(io_port); */
261         outb(CHIP_RESET, io_port + CMD_REG);
262         outb(SCSI_NOP, io_port + CMD_REG);      /* required after reset */
263         outb(SCSI_RESET, io_port + CMD_REG);
264         chip_init(io_port);
265 }
266
267 static __inline__ int
268 SYM53C500_pio_read(int fast_pio, int base, unsigned char *request, unsigned int reqlen)
269 {
270         int i;
271         int len;        /* current scsi fifo size */
272
273         REG1(base);
274         while (reqlen) {
275                 i = inb(base + PIO_STATUS);
276                 /* VDEB(printk("pio_status=%x\n", i)); */
277                 if (i & 0x80) 
278                         return 0;
279
280                 switch (i & 0x1e) {
281                 default:
282                 case 0x10:      /* fifo empty */
283                         len = 0;
284                         break;
285                 case 0x0:
286                         len = 1;
287                         break; 
288                 case 0x8:       /* fifo 1/3 full */
289                         len = 42;
290                         break;
291                 case 0xc:       /* fifo 2/3 full */
292                         len = 84;
293                         break;
294                 case 0xe:       /* fifo full */
295                         len = 128;
296                         break;
297                 }
298
299                 if ((i & 0x40) && len == 0) { /* fifo empty and interrupt occurred */
300                         return 0;
301                 }
302
303                 if (len) {
304                         if (len > reqlen) 
305                                 len = reqlen;
306
307                         if (fast_pio && len > 3) {
308                                 insl(base + PIO_FIFO, request, len >> 2);
309                                 request += len & 0xfc; 
310                                 reqlen -= len & 0xfc; 
311                         } else {
312                                 while (len--) {
313                                         *request++ = inb(base + PIO_FIFO);
314                                         reqlen--;
315                                 }
316                         } 
317                 }
318         }
319         return 0;
320 }
321
322 static __inline__ int
323 SYM53C500_pio_write(int fast_pio, int base, unsigned char *request, unsigned int reqlen)
324 {
325         int i = 0;
326         int len;        /* current scsi fifo size */
327
328         REG1(base);
329         while (reqlen && !(i & 0x40)) {
330                 i = inb(base + PIO_STATUS);
331                 /* VDEB(printk("pio_status=%x\n", i)); */
332                 if (i & 0x80)   /* error */
333                         return 0;
334
335                 switch (i & 0x1e) {
336                 case 0x10:
337                         len = 128;
338                         break;
339                 case 0x0:
340                         len = 84;
341                         break;
342                 case 0x8:
343                         len = 42;
344                         break;
345                 case 0xc:
346                         len = 1;
347                         break;
348                 default:
349                 case 0xe:
350                         len = 0;
351                         break;
352                 }
353
354                 if (len) {
355                         if (len > reqlen)
356                                 len = reqlen;
357
358                         if (fast_pio && len > 3) {
359                                 outsl(base + PIO_FIFO, request, len >> 2);
360                                 request += len & 0xfc;
361                                 reqlen -= len & 0xfc;
362                         } else {
363                                 while (len--) {
364                                         outb(*request++, base + PIO_FIFO);
365                                         reqlen--;
366                                 }
367                         }
368                 }
369         }
370         return 0;
371 }
372
373 static irqreturn_t
374 SYM53C500_intr(int irq, void *dev_id, struct pt_regs *regs)
375 {
376         unsigned long flags;
377         struct Scsi_Host *dev = dev_id;
378         DEB(unsigned char fifo_size;)
379         DEB(unsigned char seq_reg;)
380         unsigned char status, int_reg;
381         unsigned char pio_status;
382         struct scatterlist *sglist;
383         unsigned int sgcount;
384         int port_base = dev->io_port;
385         struct sym53c500_data *data =
386             (struct sym53c500_data *)dev->hostdata;
387         struct scsi_cmnd *curSC = data->current_SC;
388         int fast_pio = data->fast_pio;
389
390         spin_lock_irqsave(dev->host_lock, flags);
391
392         VDEB(printk("SYM53C500_intr called\n"));
393
394         REG1(port_base);
395         pio_status = inb(port_base + PIO_STATUS);
396         REG0(port_base);
397         status = inb(port_base + STAT_REG);
398         DEB(seq_reg = inb(port_base + SEQ_REG));
399         int_reg = inb(port_base + INT_REG);
400         DEB(fifo_size = inb(port_base + FIFO_FLAGS) & 0x1f);
401
402 #if SYM53C500_DEBUG
403         printk("status=%02x, seq_reg=%02x, int_reg=%02x, fifo_size=%02x", 
404             status, seq_reg, int_reg, fifo_size);
405         printk(", pio=%02x\n", pio_status);
406 #endif /* SYM53C500_DEBUG */
407
408         if (int_reg & 0x80) {   /* SCSI reset intr */
409                 DEB(printk("SYM53C500: reset intr received\n"));
410                 curSC->result = DID_RESET << 16;
411                 goto idle_out;
412         }
413
414         if (pio_status & 0x80) {
415                 printk("SYM53C500: Warning: PIO error!\n");
416                 curSC->result = DID_ERROR << 16;
417                 goto idle_out;
418         }
419
420         if (status & 0x20) {            /* Parity error */
421                 printk("SYM53C500: Warning: parity error!\n");
422                 curSC->result = DID_PARITY << 16;
423                 goto idle_out;
424         }
425
426         if (status & 0x40) {            /* Gross error */
427                 printk("SYM53C500: Warning: gross error!\n");
428                 curSC->result = DID_ERROR << 16;
429                 goto idle_out;
430         }
431
432         if (int_reg & 0x20) {           /* Disconnect */
433                 DEB(printk("SYM53C500: disconnect intr received\n"));
434                 if (curSC->SCp.phase != message_in) {   /* Unexpected disconnect */
435                         curSC->result = DID_NO_CONNECT << 16;
436                 } else {        /* Command complete, return status and message */
437                         curSC->result = (curSC->SCp.Status & 0xff)
438                             | ((curSC->SCp.Message & 0xff) << 8) | (DID_OK << 16);
439                 }
440                 goto idle_out;
441         }
442
443         switch (status & 0x07) {        /* scsi phase */
444         case 0x00:                      /* DATA-OUT */
445                 if (int_reg & 0x10) {   /* Target requesting info transfer */
446                         curSC->SCp.phase = data_out;
447                         VDEB(printk("SYM53C500: Data-Out phase\n"));
448                         outb(FLUSH_FIFO, port_base + CMD_REG);
449                         LOAD_DMA_COUNT(port_base, curSC->request_bufflen);      /* Max transfer size */
450                         outb(TRANSFER_INFO | DMA_OP, port_base + CMD_REG);
451                         if (!curSC->use_sg)     /* Don't use scatter-gather */
452                                 SYM53C500_pio_write(fast_pio, port_base, curSC->request_buffer, curSC->request_bufflen);
453                         else {  /* use scatter-gather */
454                                 sgcount = curSC->use_sg;
455                                 sglist = curSC->request_buffer;
456                                 while (sgcount--) {
457                                         SYM53C500_pio_write(fast_pio, port_base, page_address(sglist->page) + sglist->offset, sglist->length);
458                                         sglist++;
459                                 }
460                         }
461                         REG0(port_base);
462                 }
463                 break;
464
465         case 0x01:              /* DATA-IN */
466                 if (int_reg & 0x10) {   /* Target requesting info transfer */
467                         curSC->SCp.phase = data_in;
468                         VDEB(printk("SYM53C500: Data-In phase\n"));
469                         outb(FLUSH_FIFO, port_base + CMD_REG);
470                         LOAD_DMA_COUNT(port_base, curSC->request_bufflen);      /* Max transfer size */
471                         outb(TRANSFER_INFO | DMA_OP, port_base + CMD_REG);
472                         if (!curSC->use_sg)     /* Don't use scatter-gather */
473                                 SYM53C500_pio_read(fast_pio, port_base, curSC->request_buffer, curSC->request_bufflen);
474                         else {  /* Use scatter-gather */
475                                 sgcount = curSC->use_sg;
476                                 sglist = curSC->request_buffer;
477                                 while (sgcount--) {
478                                         SYM53C500_pio_read(fast_pio, port_base, page_address(sglist->page) + sglist->offset, sglist->length);
479                                         sglist++;
480                                 }
481                         }
482                         REG0(port_base);
483                 }
484                 break;
485
486         case 0x02:              /* COMMAND */
487                 curSC->SCp.phase = command_ph;
488                 printk("SYM53C500: Warning: Unknown interrupt occurred in command phase!\n");
489                 break;
490
491         case 0x03:              /* STATUS */
492                 curSC->SCp.phase = status_ph;
493                 VDEB(printk("SYM53C500: Status phase\n"));
494                 outb(FLUSH_FIFO, port_base + CMD_REG);
495                 outb(INIT_CMD_COMPLETE, port_base + CMD_REG);
496                 break;
497
498         case 0x04:              /* Reserved */
499         case 0x05:              /* Reserved */
500                 printk("SYM53C500: WARNING: Reserved phase!!!\n");
501                 break;
502
503         case 0x06:              /* MESSAGE-OUT */
504                 DEB(printk("SYM53C500: Message-Out phase\n"));
505                 curSC->SCp.phase = message_out;
506                 outb(SET_ATN, port_base + CMD_REG);     /* Reject the message */
507                 outb(MSG_ACCEPT, port_base + CMD_REG);
508                 break;
509
510         case 0x07:              /* MESSAGE-IN */
511                 VDEB(printk("SYM53C500: Message-In phase\n"));
512                 curSC->SCp.phase = message_in;
513
514                 curSC->SCp.Status = inb(port_base + SCSI_FIFO);
515                 curSC->SCp.Message = inb(port_base + SCSI_FIFO);
516
517                 VDEB(printk("SCSI FIFO size=%d\n", inb(port_base + FIFO_FLAGS) & 0x1f));
518                 DEB(printk("Status = %02x  Message = %02x\n", curSC->SCp.Status, curSC->SCp.Message));
519
520                 if (curSC->SCp.Message == SAVE_POINTERS || curSC->SCp.Message == DISCONNECT) {
521                         outb(SET_ATN, port_base + CMD_REG);     /* Reject message */
522                         DEB(printk("Discarding SAVE_POINTERS message\n"));
523                 }
524                 outb(MSG_ACCEPT, port_base + CMD_REG);
525                 break;
526         }
527 out:
528         spin_unlock_irqrestore(dev->host_lock, flags);
529         return IRQ_HANDLED;
530
531 idle_out:
532         curSC->SCp.phase = idle;
533         curSC->scsi_done(curSC);
534         goto out;
535 }
536
537 static void
538 SYM53C500_release(dev_link_t *link)
539 {
540         struct scsi_info_t *info = link->priv;
541         struct Scsi_Host *shost = info->host;
542
543         DEBUG(0, "SYM53C500_release(0x%p)\n", link);
544
545         /*
546         *  Do this before releasing/freeing resources.
547         */
548         scsi_remove_host(shost);
549
550         /*
551         *  Interrupts getting hosed on card removal.  Try
552         *  the following code, mostly from qlogicfas.c.
553         */
554         if (shost->irq)
555                 free_irq(shost->irq, shost);
556         if (shost->dma_channel != 0xff)
557                 free_dma(shost->dma_channel);
558         if (shost->io_port && shost->n_io_port)
559                 release_region(shost->io_port, shost->n_io_port);
560
561         link->dev = NULL;
562
563         pcmcia_release_configuration(link->handle);
564         pcmcia_release_io(link->handle, &link->io);
565         pcmcia_release_irq(link->handle, &link->irq);
566
567         link->state &= ~DEV_CONFIG;
568
569         scsi_host_put(shost);
570 } /* SYM53C500_release */
571
572 static const char*
573 SYM53C500_info(struct Scsi_Host *SChost)
574 {
575         static char info_msg[256];
576         struct sym53c500_data *data =
577             (struct sym53c500_data *)SChost->hostdata;
578
579         DEB(printk("SYM53C500_info called\n"));
580         (void)snprintf(info_msg, sizeof(info_msg),
581             "SYM53C500 at 0x%lx, IRQ %d, %s PIO mode.", 
582             SChost->io_port, SChost->irq, data->fast_pio ? "fast" : "slow");
583         return (info_msg);
584 }
585
586 static int 
587 SYM53C500_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
588 {
589         int i;
590         int port_base = SCpnt->device->host->io_port;
591         struct sym53c500_data *data =
592             (struct sym53c500_data *)SCpnt->device->host->hostdata;
593
594         VDEB(printk("SYM53C500_queue called\n"));
595
596         DEB(printk("cmd=%02x, cmd_len=%02x, target=%02x, lun=%02x, bufflen=%d\n", 
597             SCpnt->cmnd[0], SCpnt->cmd_len, SCpnt->device->id, 
598             SCpnt->device->lun,  SCpnt->request_bufflen));
599
600         VDEB(for (i = 0; i < SCpnt->cmd_len; i++)
601             printk("cmd[%d]=%02x  ", i, SCpnt->cmnd[i]));
602         VDEB(printk("\n"));
603
604         data->current_SC = SCpnt;
605         data->current_SC->scsi_done = done;
606         data->current_SC->SCp.phase = command_ph;
607         data->current_SC->SCp.Status = 0;
608         data->current_SC->SCp.Message = 0;
609
610         /* We are locked here already by the mid layer */
611         REG0(port_base);
612         outb(scmd_id(SCpnt), port_base + DEST_ID);      /* set destination */
613         outb(FLUSH_FIFO, port_base + CMD_REG);  /* reset the fifos */
614
615         for (i = 0; i < SCpnt->cmd_len; i++) {
616                 outb(SCpnt->cmnd[i], port_base + SCSI_FIFO);
617         }
618         outb(SELECT_NO_ATN, port_base + CMD_REG);
619
620         return 0;
621 }
622
623 static int 
624 SYM53C500_host_reset(struct scsi_cmnd *SCpnt)
625 {
626         int port_base = SCpnt->device->host->io_port;
627
628         DEB(printk("SYM53C500_host_reset called\n"));
629         spin_lock_irq(SCpnt->device->host->host_lock);
630         SYM53C500_int_host_reset(port_base);
631         spin_unlock_irq(SCpnt->device->host->host_lock);
632
633         return SUCCESS;
634 }
635
636 static int 
637 SYM53C500_biosparm(struct scsi_device *disk,
638     struct block_device *dev,
639     sector_t capacity, int *info_array)
640 {
641         int size;
642
643         DEB(printk("SYM53C500_biosparm called\n"));
644
645         size = capacity;
646         info_array[0] = 64;             /* heads */
647         info_array[1] = 32;             /* sectors */
648         info_array[2] = size >> 11;     /* cylinders */
649         if (info_array[2] > 1024) {     /* big disk */
650                 info_array[0] = 255;
651                 info_array[1] = 63;
652                 info_array[2] = size / (255 * 63);
653         }
654         return 0;
655 }
656
657 static ssize_t
658 SYM53C500_show_pio(struct class_device *cdev, char *buf)
659 {
660         struct Scsi_Host *SHp = class_to_shost(cdev);
661         struct sym53c500_data *data =
662             (struct sym53c500_data *)SHp->hostdata;
663
664         return snprintf(buf, 4, "%d\n", data->fast_pio);
665 }
666
667 static ssize_t
668 SYM53C500_store_pio(struct class_device *cdev, const char *buf, size_t count)
669 {
670         int pio;
671         struct Scsi_Host *SHp = class_to_shost(cdev);
672         struct sym53c500_data *data =
673             (struct sym53c500_data *)SHp->hostdata;
674
675         pio = simple_strtoul(buf, NULL, 0);
676         if (pio == 0 || pio == 1) {
677                 data->fast_pio = pio;
678                 return count;
679         }
680         else
681                 return -EINVAL;
682 }
683
684 /*
685 *  SCSI HBA device attributes we want to
686 *  make available via sysfs.
687 */
688 static struct class_device_attribute SYM53C500_pio_attr = {
689         .attr = {
690                 .name = "fast_pio",
691                 .mode = (S_IRUGO | S_IWUSR),
692         },
693         .show = SYM53C500_show_pio,
694         .store = SYM53C500_store_pio,
695 };
696
697 static struct class_device_attribute *SYM53C500_shost_attrs[] = {
698         &SYM53C500_pio_attr,
699         NULL,
700 };
701
702 /*
703 *  scsi_host_template initializer
704 */
705 static struct scsi_host_template sym53c500_driver_template = {
706      .module                    = THIS_MODULE,
707      .name                      = "SYM53C500",
708      .info                      = SYM53C500_info,
709      .queuecommand              = SYM53C500_queue,
710      .eh_host_reset_handler     = SYM53C500_host_reset,
711      .bios_param                = SYM53C500_biosparm,
712      .proc_name                 = "SYM53C500",
713      .can_queue                 = 1,
714      .this_id                   = 7,
715      .sg_tablesize              = 32,
716      .cmd_per_lun               = 1,
717      .use_clustering            = ENABLE_CLUSTERING,
718      .shost_attrs               = SYM53C500_shost_attrs
719 };
720
721 #define CS_CHECK(fn, ret) \
722 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
723
724 static void
725 SYM53C500_config(dev_link_t *link)
726 {
727         client_handle_t handle = link->handle;
728         struct scsi_info_t *info = link->priv;
729         tuple_t tuple;
730         cisparse_t parse;
731         int i, last_ret, last_fn;
732         int irq_level, port_base;
733         unsigned short tuple_data[32];
734         struct Scsi_Host *host;
735         struct scsi_host_template *tpnt = &sym53c500_driver_template;
736         struct sym53c500_data *data;
737
738         DEBUG(0, "SYM53C500_config(0x%p)\n", link);
739
740         tuple.TupleData = (cisdata_t *)tuple_data;
741         tuple.TupleDataMax = 64;
742         tuple.TupleOffset = 0;
743         tuple.DesiredTuple = CISTPL_CONFIG;
744         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
745         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
746         CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
747         link->conf.ConfigBase = parse.config.base;
748
749         tuple.DesiredTuple = CISTPL_MANFID;
750         if ((pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) &&
751             (pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS))
752                 info->manf_id = le16_to_cpu(tuple.TupleData[0]);
753
754         /* Configure card */
755         link->state |= DEV_CONFIG;
756
757         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
758         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
759         while (1) {
760                 if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
761                     pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
762                         goto next_entry;
763                 link->conf.ConfigIndex = parse.cftable_entry.index;
764                 link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
765                 link->io.NumPorts1 = parse.cftable_entry.io.win[0].len;
766
767                 if (link->io.BasePort1 != 0) {
768                         i = pcmcia_request_io(handle, &link->io);
769                         if (i == CS_SUCCESS)
770                                 break;
771                 }
772 next_entry:
773                 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
774         }
775
776         CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
777         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
778
779         /*
780         *  That's the trouble with copying liberally from another driver.
781         *  Some things probably aren't relevant, and I suspect this entire
782         *  section dealing with manufacturer IDs can be scrapped.       --rct
783         */
784         if ((info->manf_id == MANFID_MACNICA) ||
785             (info->manf_id == MANFID_PIONEER) ||
786             (info->manf_id == 0x0098)) {
787                 /* set ATAcmd */
788                 outb(0xb4, link->io.BasePort1 + 0xd);
789                 outb(0x24, link->io.BasePort1 + 0x9);
790                 outb(0x04, link->io.BasePort1 + 0xd);
791         }
792
793         /*
794         *  irq_level == 0 implies tpnt->can_queue == 0, which
795         *  is not supported in 2.6.  Thus, only irq_level > 0
796         *  will be allowed.
797         *
798         *  Possible port_base values are as follows:
799         *
800         *       0x130, 0x230, 0x280, 0x290,
801         *       0x320, 0x330, 0x340, 0x350
802         */
803         port_base = link->io.BasePort1;
804         irq_level = link->irq.AssignedIRQ;
805
806         DEB(printk("SYM53C500: port_base=0x%x, irq=%d, fast_pio=%d\n",
807             port_base, irq_level, USE_FAST_PIO);)
808
809         chip_init(port_base);
810
811         host = scsi_host_alloc(tpnt, sizeof(struct sym53c500_data));
812         if (!host) {
813                 printk("SYM53C500: Unable to register host, giving up.\n");
814                 goto err_release;
815         }
816
817         data = (struct sym53c500_data *)host->hostdata;
818
819         if (irq_level > 0) {
820                 if (request_irq(irq_level, SYM53C500_intr, SA_SHIRQ, "SYM53C500", host)) {
821                         printk("SYM53C500: unable to allocate IRQ %d\n", irq_level);
822                         goto err_free_scsi;
823                 }
824                 DEB(printk("SYM53C500: allocated IRQ %d\n", irq_level));
825         } else if (irq_level == 0) {
826                 DEB(printk("SYM53C500: No interrupts detected\n"));
827                 goto err_free_scsi;
828         } else {
829                 DEB(printk("SYM53C500: Shouldn't get here!\n"));
830                 goto err_free_scsi;
831         }
832
833         host->unique_id = port_base;
834         host->irq = irq_level;
835         host->io_port = port_base;
836         host->n_io_port = 0x10;
837         host->dma_channel = -1;
838
839         /*
840         *  Note fast_pio is set to USE_FAST_PIO by
841         *  default, but can be changed via "sysfs".
842         */
843         data->fast_pio = USE_FAST_PIO;
844
845         sprintf(info->node.dev_name, "scsi%d", host->host_no);
846         link->dev = &info->node;
847         info->host = host;
848
849         if (scsi_add_host(host, NULL))
850                 goto err_free_irq;
851
852         scsi_scan_host(host);
853
854         goto out;       /* SUCCESS */
855
856 err_free_irq:
857         free_irq(irq_level, host);
858 err_free_scsi:
859         scsi_host_put(host);
860 err_release:
861         release_region(port_base, 0x10);
862         printk(KERN_INFO "sym53c500_cs: no SCSI devices found\n");
863
864 out:
865         link->state &= ~DEV_CONFIG_PENDING;
866         return;
867
868 cs_failed:
869         cs_error(link->handle, last_fn, last_ret);
870         SYM53C500_release(link);
871         return;
872 } /* SYM53C500_config */
873
874 static int sym53c500_suspend(struct pcmcia_device *dev)
875 {
876         dev_link_t *link = dev_to_instance(dev);
877
878         link->state |= DEV_SUSPEND;
879         if (link->state & DEV_CONFIG)
880                 pcmcia_release_configuration(link->handle);
881
882         return 0;
883 }
884
885 static int sym53c500_resume(struct pcmcia_device *dev)
886 {
887         dev_link_t *link = dev_to_instance(dev);
888         struct scsi_info_t *info = link->priv;
889
890         link->state &= ~DEV_SUSPEND;
891         if (link->state & DEV_CONFIG) {
892                 pcmcia_request_configuration(link->handle, &link->conf);
893
894                 /* See earlier comment about manufacturer IDs. */
895                 if ((info->manf_id == MANFID_MACNICA) ||
896                     (info->manf_id == MANFID_PIONEER) ||
897                     (info->manf_id == 0x0098)) {
898                         outb(0x80, link->io.BasePort1 + 0xd);
899                         outb(0x24, link->io.BasePort1 + 0x9);
900                         outb(0x04, link->io.BasePort1 + 0xd);
901                 }
902                 /*
903                  *  If things don't work after a "resume",
904                  *  this is a good place to start looking.
905                  */
906                 SYM53C500_int_host_reset(link->io.BasePort1);
907         }
908
909         return 0;
910 }
911
912 static int
913 SYM53C500_event(event_t event, int priority, event_callback_args_t *args)
914 {
915         dev_link_t *link = args->client_data;
916
917         DEBUG(1, "SYM53C500_event(0x%06x)\n", event);
918
919         switch (event) {
920         case CS_EVENT_CARD_INSERTION:
921                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
922                 SYM53C500_config(link);
923                 break;
924         }
925         return 0;
926 } /* SYM53C500_event */
927
928 static void
929 SYM53C500_detach(struct pcmcia_device *p_dev)
930 {
931         dev_link_t *link = dev_to_instance(p_dev);
932
933         DEBUG(0, "SYM53C500_detach(0x%p)\n", link);
934
935         if (link->state & DEV_CONFIG)
936                 SYM53C500_release(link);
937
938         kfree(link->priv);
939         link->priv = NULL;
940 } /* SYM53C500_detach */
941
942 static dev_link_t *
943 SYM53C500_attach(void)
944 {
945         struct scsi_info_t *info;
946         client_reg_t client_reg;
947         dev_link_t *link;
948         int ret;
949
950         DEBUG(0, "SYM53C500_attach()\n");
951
952         /* Create new SCSI device */
953         info = kmalloc(sizeof(*info), GFP_KERNEL);
954         if (!info)
955                 return NULL;
956         memset(info, 0, sizeof(*info));
957         link = &info->link;
958         link->priv = info;
959         link->io.NumPorts1 = 16;
960         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
961         link->io.IOAddrLines = 10;
962         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
963         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
964         link->conf.Attributes = CONF_ENABLE_IRQ;
965         link->conf.Vcc = 50;
966         link->conf.IntType = INT_MEMORY_AND_IO;
967         link->conf.Present = PRESENT_OPTION;
968
969         /* Register with Card Services */
970         link->next = NULL;
971         client_reg.dev_info = &dev_info;
972         client_reg.Version = 0x0210;
973         client_reg.event_callback_args.client_data = link;
974         ret = pcmcia_register_client(&link->handle, &client_reg);
975         if (ret != 0) {
976                 cs_error(link->handle, RegisterClient, ret);
977                 SYM53C500_detach(link->handle);
978                 return NULL;
979         }
980
981         return link;
982 } /* SYM53C500_attach */
983
984 MODULE_AUTHOR("Bob Tracy <rct@frus.com>");
985 MODULE_DESCRIPTION("SYM53C500 PCMCIA SCSI driver");
986 MODULE_LICENSE("GPL");
987
988 static struct pcmcia_device_id sym53c500_ids[] = {
989         PCMCIA_DEVICE_PROD_ID12("BASICS by New Media Corporation", "SCSI Sym53C500", 0x23c78a9d, 0x0099e7f7),
990         PCMCIA_DEVICE_PROD_ID12("New Media Corporation", "SCSI Bus Toaster Sym53C500", 0x085a850b, 0x45432eb8),
991         PCMCIA_DEVICE_PROD_ID2("SCSI9000", 0x21648f44),
992         PCMCIA_DEVICE_NULL,
993 };
994 MODULE_DEVICE_TABLE(pcmcia, sym53c500_ids);
995
996 static struct pcmcia_driver sym53c500_cs_driver = {
997         .owner          = THIS_MODULE,
998         .drv            = {
999                 .name   = "sym53c500_cs",
1000         },
1001         .attach         = SYM53C500_attach,
1002         .event          = SYM53C500_event,
1003         .remove         = SYM53C500_detach,
1004         .id_table       = sym53c500_ids,
1005         .suspend        = sym53c500_suspend,
1006         .resume         = sym53c500_resume,
1007 };
1008
1009 static int __init
1010 init_sym53c500_cs(void)
1011 {
1012         return pcmcia_register_driver(&sym53c500_cs_driver);
1013 }
1014
1015 static void __exit
1016 exit_sym53c500_cs(void)
1017 {
1018         pcmcia_unregister_driver(&sym53c500_cs_driver);
1019 }
1020
1021 module_init(init_sym53c500_cs);
1022 module_exit(exit_sym53c500_cs);