PM: Remove CONFIG_PM_OPS
[linux-2.6.git] / drivers / scsi / gvp11.c
1 #include <linux/types.h>
2 #include <linux/init.h>
3 #include <linux/interrupt.h>
4 #include <linux/mm.h>
5 #include <linux/slab.h>
6 #include <linux/spinlock.h>
7 #include <linux/zorro.h>
8
9 #include <asm/page.h>
10 #include <asm/pgtable.h>
11 #include <asm/amigaints.h>
12 #include <asm/amigahw.h>
13
14 #include "scsi.h"
15 #include "wd33c93.h"
16 #include "gvp11.h"
17
18
19 #define CHECK_WD33C93
20
21 struct gvp11_hostdata {
22         struct WD33C93_hostdata wh;
23         struct gvp11_scsiregs *regs;
24 };
25
26 static irqreturn_t gvp11_intr(int irq, void *data)
27 {
28         struct Scsi_Host *instance = data;
29         struct gvp11_hostdata *hdata = shost_priv(instance);
30         unsigned int status = hdata->regs->CNTR;
31         unsigned long flags;
32
33         if (!(status & GVP11_DMAC_INT_PENDING))
34                 return IRQ_NONE;
35
36         spin_lock_irqsave(instance->host_lock, flags);
37         wd33c93_intr(instance);
38         spin_unlock_irqrestore(instance->host_lock, flags);
39         return IRQ_HANDLED;
40 }
41
42 static int gvp11_xfer_mask = 0;
43
44 void gvp11_setup(char *str, int *ints)
45 {
46         gvp11_xfer_mask = ints[1];
47 }
48
49 static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
50 {
51         struct Scsi_Host *instance = cmd->device->host;
52         struct gvp11_hostdata *hdata = shost_priv(instance);
53         struct WD33C93_hostdata *wh = &hdata->wh;
54         struct gvp11_scsiregs *regs = hdata->regs;
55         unsigned short cntr = GVP11_DMAC_INT_ENABLE;
56         unsigned long addr = virt_to_bus(cmd->SCp.ptr);
57         int bank_mask;
58         static int scsi_alloc_out_of_range = 0;
59
60         /* use bounce buffer if the physical address is bad */
61         if (addr & wh->dma_xfer_mask) {
62                 wh->dma_bounce_len = (cmd->SCp.this_residual + 511) & ~0x1ff;
63
64                 if (!scsi_alloc_out_of_range) {
65                         wh->dma_bounce_buffer =
66                                 kmalloc(wh->dma_bounce_len, GFP_KERNEL);
67                         wh->dma_buffer_pool = BUF_SCSI_ALLOCED;
68                 }
69
70                 if (scsi_alloc_out_of_range ||
71                     !wh->dma_bounce_buffer) {
72                         wh->dma_bounce_buffer =
73                                 amiga_chip_alloc(wh->dma_bounce_len,
74                                                  "GVP II SCSI Bounce Buffer");
75
76                         if (!wh->dma_bounce_buffer) {
77                                 wh->dma_bounce_len = 0;
78                                 return 1;
79                         }
80
81                         wh->dma_buffer_pool = BUF_CHIP_ALLOCED;
82                 }
83
84                 /* check if the address of the bounce buffer is OK */
85                 addr = virt_to_bus(wh->dma_bounce_buffer);
86
87                 if (addr & wh->dma_xfer_mask) {
88                         /* fall back to Chip RAM if address out of range */
89                         if (wh->dma_buffer_pool == BUF_SCSI_ALLOCED) {
90                                 kfree(wh->dma_bounce_buffer);
91                                 scsi_alloc_out_of_range = 1;
92                         } else {
93                                 amiga_chip_free(wh->dma_bounce_buffer);
94                         }
95
96                         wh->dma_bounce_buffer =
97                                 amiga_chip_alloc(wh->dma_bounce_len,
98                                                  "GVP II SCSI Bounce Buffer");
99
100                         if (!wh->dma_bounce_buffer) {
101                                 wh->dma_bounce_len = 0;
102                                 return 1;
103                         }
104
105                         addr = virt_to_bus(wh->dma_bounce_buffer);
106                         wh->dma_buffer_pool = BUF_CHIP_ALLOCED;
107                 }
108
109                 if (!dir_in) {
110                         /* copy to bounce buffer for a write */
111                         memcpy(wh->dma_bounce_buffer, cmd->SCp.ptr,
112                                cmd->SCp.this_residual);
113                 }
114         }
115
116         /* setup dma direction */
117         if (!dir_in)
118                 cntr |= GVP11_DMAC_DIR_WRITE;
119
120         wh->dma_dir = dir_in;
121         regs->CNTR = cntr;
122
123         /* setup DMA *physical* address */
124         regs->ACR = addr;
125
126         if (dir_in) {
127                 /* invalidate any cache */
128                 cache_clear(addr, cmd->SCp.this_residual);
129         } else {
130                 /* push any dirty cache */
131                 cache_push(addr, cmd->SCp.this_residual);
132         }
133
134         bank_mask = (~wh->dma_xfer_mask >> 18) & 0x01c0;
135         if (bank_mask)
136                 regs->BANK = bank_mask & (addr >> 18);
137
138         /* start DMA */
139         regs->ST_DMA = 1;
140
141         /* return success */
142         return 0;
143 }
144
145 static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt,
146                      int status)
147 {
148         struct gvp11_hostdata *hdata = shost_priv(instance);
149         struct WD33C93_hostdata *wh = &hdata->wh;
150         struct gvp11_scsiregs *regs = hdata->regs;
151
152         /* stop DMA */
153         regs->SP_DMA = 1;
154         /* remove write bit from CONTROL bits */
155         regs->CNTR = GVP11_DMAC_INT_ENABLE;
156
157         /* copy from a bounce buffer, if necessary */
158         if (status && wh->dma_bounce_buffer) {
159                 if (wh->dma_dir && SCpnt)
160                         memcpy(SCpnt->SCp.ptr, wh->dma_bounce_buffer,
161                                SCpnt->SCp.this_residual);
162
163                 if (wh->dma_buffer_pool == BUF_SCSI_ALLOCED)
164                         kfree(wh->dma_bounce_buffer);
165                 else
166                         amiga_chip_free(wh->dma_bounce_buffer);
167
168                 wh->dma_bounce_buffer = NULL;
169                 wh->dma_bounce_len = 0;
170         }
171 }
172
173 static int gvp11_bus_reset(struct scsi_cmnd *cmd)
174 {
175         struct Scsi_Host *instance = cmd->device->host;
176
177         /* FIXME perform bus-specific reset */
178
179         /* FIXME 2: shouldn't we no-op this function (return
180            FAILED), and fall back to host reset function,
181            wd33c93_host_reset ? */
182
183         spin_lock_irq(instance->host_lock);
184         wd33c93_host_reset(cmd);
185         spin_unlock_irq(instance->host_lock);
186
187         return SUCCESS;
188 }
189
190 static struct scsi_host_template gvp11_scsi_template = {
191         .module                 = THIS_MODULE,
192         .name                   = "GVP Series II SCSI",
193         .proc_info              = wd33c93_proc_info,
194         .proc_name              = "GVP11",
195         .queuecommand           = wd33c93_queuecommand,
196         .eh_abort_handler       = wd33c93_abort,
197         .eh_bus_reset_handler   = gvp11_bus_reset,
198         .eh_host_reset_handler  = wd33c93_host_reset,
199         .can_queue              = CAN_QUEUE,
200         .this_id                = 7,
201         .sg_tablesize           = SG_ALL,
202         .cmd_per_lun            = CMD_PER_LUN,
203         .use_clustering         = DISABLE_CLUSTERING
204 };
205
206 static int __devinit check_wd33c93(struct gvp11_scsiregs *regs)
207 {
208 #ifdef CHECK_WD33C93
209         volatile unsigned char *sasr_3393, *scmd_3393;
210         unsigned char save_sasr;
211         unsigned char q, qq;
212
213         /*
214          * These darn GVP boards are a problem - it can be tough to tell
215          * whether or not they include a SCSI controller. This is the
216          * ultimate Yet-Another-GVP-Detection-Hack in that it actually
217          * probes for a WD33c93 chip: If we find one, it's extremely
218          * likely that this card supports SCSI, regardless of Product_
219          * Code, Board_Size, etc.
220          */
221
222         /* Get pointers to the presumed register locations and save contents */
223
224         sasr_3393 = &regs->SASR;
225         scmd_3393 = &regs->SCMD;
226         save_sasr = *sasr_3393;
227
228         /* First test the AuxStatus Reg */
229
230         q = *sasr_3393; /* read it */
231         if (q & 0x08)   /* bit 3 should always be clear */
232                 return -ENODEV;
233         *sasr_3393 = WD_AUXILIARY_STATUS;       /* setup indirect address */
234         if (*sasr_3393 == WD_AUXILIARY_STATUS) {        /* shouldn't retain the write */
235                 *sasr_3393 = save_sasr; /* Oops - restore this byte */
236                 return -ENODEV;
237         }
238         if (*sasr_3393 != q) {  /* should still read the same */
239                 *sasr_3393 = save_sasr; /* Oops - restore this byte */
240                 return -ENODEV;
241         }
242         if (*scmd_3393 != q)    /* and so should the image at 0x1f */
243                 return -ENODEV;
244
245         /*
246          * Ok, we probably have a wd33c93, but let's check a few other places
247          * for good measure. Make sure that this works for both 'A and 'B
248          * chip versions.
249          */
250
251         *sasr_3393 = WD_SCSI_STATUS;
252         q = *scmd_3393;
253         *sasr_3393 = WD_SCSI_STATUS;
254         *scmd_3393 = ~q;
255         *sasr_3393 = WD_SCSI_STATUS;
256         qq = *scmd_3393;
257         *sasr_3393 = WD_SCSI_STATUS;
258         *scmd_3393 = q;
259         if (qq != q)    /* should be read only */
260                 return -ENODEV;
261         *sasr_3393 = 0x1e;      /* this register is unimplemented */
262         q = *scmd_3393;
263         *sasr_3393 = 0x1e;
264         *scmd_3393 = ~q;
265         *sasr_3393 = 0x1e;
266         qq = *scmd_3393;
267         *sasr_3393 = 0x1e;
268         *scmd_3393 = q;
269         if (qq != q || qq != 0xff)      /* should be read only, all 1's */
270                 return -ENODEV;
271         *sasr_3393 = WD_TIMEOUT_PERIOD;
272         q = *scmd_3393;
273         *sasr_3393 = WD_TIMEOUT_PERIOD;
274         *scmd_3393 = ~q;
275         *sasr_3393 = WD_TIMEOUT_PERIOD;
276         qq = *scmd_3393;
277         *sasr_3393 = WD_TIMEOUT_PERIOD;
278         *scmd_3393 = q;
279         if (qq != (~q & 0xff))  /* should be read/write */
280                 return -ENODEV;
281 #endif /* CHECK_WD33C93 */
282
283         return 0;
284 }
285
286 static int __devinit gvp11_probe(struct zorro_dev *z,
287                                  const struct zorro_device_id *ent)
288 {
289         struct Scsi_Host *instance;
290         unsigned long address;
291         int error;
292         unsigned int epc;
293         unsigned int default_dma_xfer_mask;
294         struct gvp11_hostdata *hdata;
295         struct gvp11_scsiregs *regs;
296         wd33c93_regs wdregs;
297
298         default_dma_xfer_mask = ent->driver_data;
299
300         /*
301          * Rumors state that some GVP ram boards use the same product
302          * code as the SCSI controllers. Therefore if the board-size
303          * is not 64KB we asume it is a ram board and bail out.
304          */
305         if (zorro_resource_len(z) != 0x10000)
306                 return -ENODEV;
307
308         address = z->resource.start;
309         if (!request_mem_region(address, 256, "wd33c93"))
310                 return -EBUSY;
311
312         regs = (struct gvp11_scsiregs *)(ZTWO_VADDR(address));
313
314         error = check_wd33c93(regs);
315         if (error)
316                 goto fail_check_or_alloc;
317
318         instance = scsi_host_alloc(&gvp11_scsi_template,
319                                    sizeof(struct gvp11_hostdata));
320         if (!instance) {
321                 error = -ENOMEM;
322                 goto fail_check_or_alloc;
323         }
324
325         instance->irq = IRQ_AMIGA_PORTS;
326         instance->unique_id = z->slotaddr;
327
328         regs->secret2 = 1;
329         regs->secret1 = 0;
330         regs->secret3 = 15;
331         while (regs->CNTR & GVP11_DMAC_BUSY)
332                 ;
333         regs->CNTR = 0;
334         regs->BANK = 0;
335
336         wdregs.SASR = &regs->SASR;
337         wdregs.SCMD = &regs->SCMD;
338
339         hdata = shost_priv(instance);
340         if (gvp11_xfer_mask)
341                 hdata->wh.dma_xfer_mask = gvp11_xfer_mask;
342         else
343                 hdata->wh.dma_xfer_mask = default_dma_xfer_mask;
344
345         hdata->wh.no_sync = 0xff;
346         hdata->wh.fast = 0;
347         hdata->wh.dma_mode = CTRL_DMA;
348         hdata->regs = regs;
349
350         /*
351          * Check for 14MHz SCSI clock
352          */
353         epc = *(unsigned short *)(ZTWO_VADDR(address) + 0x8000);
354         wd33c93_init(instance, wdregs, dma_setup, dma_stop,
355                      (epc & GVP_SCSICLKMASK) ? WD33C93_FS_8_10
356                                              : WD33C93_FS_12_15);
357
358         error = request_irq(IRQ_AMIGA_PORTS, gvp11_intr, IRQF_SHARED,
359                             "GVP11 SCSI", instance);
360         if (error)
361                 goto fail_irq;
362
363         regs->CNTR = GVP11_DMAC_INT_ENABLE;
364
365         error = scsi_add_host(instance, NULL);
366         if (error)
367                 goto fail_host;
368
369         zorro_set_drvdata(z, instance);
370         scsi_scan_host(instance);
371         return 0;
372
373 fail_host:
374         free_irq(IRQ_AMIGA_PORTS, instance);
375 fail_irq:
376         scsi_host_put(instance);
377 fail_check_or_alloc:
378         release_mem_region(address, 256);
379         return error;
380 }
381
382 static void __devexit gvp11_remove(struct zorro_dev *z)
383 {
384         struct Scsi_Host *instance = zorro_get_drvdata(z);
385         struct gvp11_hostdata *hdata = shost_priv(instance);
386
387         hdata->regs->CNTR = 0;
388         scsi_remove_host(instance);
389         free_irq(IRQ_AMIGA_PORTS, instance);
390         scsi_host_put(instance);
391         release_mem_region(z->resource.start, 256);
392 }
393
394         /*
395          * This should (hopefully) be the correct way to identify
396          * all the different GVP SCSI controllers (except for the
397          * SERIES I though).
398          */
399
400 static struct zorro_device_id gvp11_zorro_tbl[] __devinitdata = {
401         { ZORRO_PROD_GVP_COMBO_030_R3_SCSI,     ~0x00ffffff },
402         { ZORRO_PROD_GVP_SERIES_II,             ~0x00ffffff },
403         { ZORRO_PROD_GVP_GFORCE_030_SCSI,       ~0x01ffffff },
404         { ZORRO_PROD_GVP_A530_SCSI,             ~0x01ffffff },
405         { ZORRO_PROD_GVP_COMBO_030_R4_SCSI,     ~0x01ffffff },
406         { ZORRO_PROD_GVP_A1291,                 ~0x07ffffff },
407         { ZORRO_PROD_GVP_GFORCE_040_SCSI_1,     ~0x07ffffff },
408         { 0 }
409 };
410 MODULE_DEVICE_TABLE(zorro, gvp11_zorro_tbl);
411
412 static struct zorro_driver gvp11_driver = {
413         .name           = "gvp11",
414         .id_table       = gvp11_zorro_tbl,
415         .probe          = gvp11_probe,
416         .remove         = __devexit_p(gvp11_remove),
417 };
418
419 static int __init gvp11_init(void)
420 {
421         return zorro_register_driver(&gvp11_driver);
422 }
423 module_init(gvp11_init);
424
425 static void __exit gvp11_exit(void)
426 {
427         zorro_unregister_driver(&gvp11_driver);
428 }
429 module_exit(gvp11_exit);
430
431 MODULE_DESCRIPTION("GVP Series II SCSI");
432 MODULE_LICENSE("GPL");