1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <linux/types.h>
3 #include <linux/init.h>
4 #include <linux/interrupt.h>
6 #include <linux/slab.h>
7 #include <linux/spinlock.h>
8 #include <linux/zorro.h>
9 #include <linux/module.h>
12 #include <asm/amigaints.h>
13 #include <asm/amigahw.h>
22 struct gvp11_hostdata
{
23 struct WD33C93_hostdata wh
;
24 struct gvp11_scsiregs
*regs
;
27 static irqreturn_t
gvp11_intr(int irq
, void *data
)
29 struct Scsi_Host
*instance
= data
;
30 struct gvp11_hostdata
*hdata
= shost_priv(instance
);
31 unsigned int status
= hdata
->regs
->CNTR
;
34 if (!(status
& GVP11_DMAC_INT_PENDING
))
37 spin_lock_irqsave(instance
->host_lock
, flags
);
38 wd33c93_intr(instance
);
39 spin_unlock_irqrestore(instance
->host_lock
, flags
);
43 static int gvp11_xfer_mask
= 0;
45 void gvp11_setup(char *str
, int *ints
)
47 gvp11_xfer_mask
= ints
[1];
50 static int dma_setup(struct scsi_cmnd
*cmd
, int dir_in
)
52 struct Scsi_Host
*instance
= cmd
->device
->host
;
53 struct gvp11_hostdata
*hdata
= shost_priv(instance
);
54 struct WD33C93_hostdata
*wh
= &hdata
->wh
;
55 struct gvp11_scsiregs
*regs
= hdata
->regs
;
56 unsigned short cntr
= GVP11_DMAC_INT_ENABLE
;
57 unsigned long addr
= virt_to_bus(cmd
->SCp
.ptr
);
59 static int scsi_alloc_out_of_range
= 0;
61 /* use bounce buffer if the physical address is bad */
62 if (addr
& wh
->dma_xfer_mask
) {
63 wh
->dma_bounce_len
= (cmd
->SCp
.this_residual
+ 511) & ~0x1ff;
65 if (!scsi_alloc_out_of_range
) {
66 wh
->dma_bounce_buffer
=
67 kmalloc(wh
->dma_bounce_len
, GFP_KERNEL
);
68 wh
->dma_buffer_pool
= BUF_SCSI_ALLOCED
;
71 if (scsi_alloc_out_of_range
||
72 !wh
->dma_bounce_buffer
) {
73 wh
->dma_bounce_buffer
=
74 amiga_chip_alloc(wh
->dma_bounce_len
,
75 "GVP II SCSI Bounce Buffer");
77 if (!wh
->dma_bounce_buffer
) {
78 wh
->dma_bounce_len
= 0;
82 wh
->dma_buffer_pool
= BUF_CHIP_ALLOCED
;
85 /* check if the address of the bounce buffer is OK */
86 addr
= virt_to_bus(wh
->dma_bounce_buffer
);
88 if (addr
& wh
->dma_xfer_mask
) {
89 /* fall back to Chip RAM if address out of range */
90 if (wh
->dma_buffer_pool
== BUF_SCSI_ALLOCED
) {
91 kfree(wh
->dma_bounce_buffer
);
92 scsi_alloc_out_of_range
= 1;
94 amiga_chip_free(wh
->dma_bounce_buffer
);
97 wh
->dma_bounce_buffer
=
98 amiga_chip_alloc(wh
->dma_bounce_len
,
99 "GVP II SCSI Bounce Buffer");
101 if (!wh
->dma_bounce_buffer
) {
102 wh
->dma_bounce_len
= 0;
106 addr
= virt_to_bus(wh
->dma_bounce_buffer
);
107 wh
->dma_buffer_pool
= BUF_CHIP_ALLOCED
;
111 /* copy to bounce buffer for a write */
112 memcpy(wh
->dma_bounce_buffer
, cmd
->SCp
.ptr
,
113 cmd
->SCp
.this_residual
);
117 /* setup dma direction */
119 cntr
|= GVP11_DMAC_DIR_WRITE
;
121 wh
->dma_dir
= dir_in
;
124 /* setup DMA *physical* address */
128 /* invalidate any cache */
129 cache_clear(addr
, cmd
->SCp
.this_residual
);
131 /* push any dirty cache */
132 cache_push(addr
, cmd
->SCp
.this_residual
);
135 bank_mask
= (~wh
->dma_xfer_mask
>> 18) & 0x01c0;
137 regs
->BANK
= bank_mask
& (addr
>> 18);
146 static void dma_stop(struct Scsi_Host
*instance
, struct scsi_cmnd
*SCpnt
,
149 struct gvp11_hostdata
*hdata
= shost_priv(instance
);
150 struct WD33C93_hostdata
*wh
= &hdata
->wh
;
151 struct gvp11_scsiregs
*regs
= hdata
->regs
;
155 /* remove write bit from CONTROL bits */
156 regs
->CNTR
= GVP11_DMAC_INT_ENABLE
;
158 /* copy from a bounce buffer, if necessary */
159 if (status
&& wh
->dma_bounce_buffer
) {
160 if (wh
->dma_dir
&& SCpnt
)
161 memcpy(SCpnt
->SCp
.ptr
, wh
->dma_bounce_buffer
,
162 SCpnt
->SCp
.this_residual
);
164 if (wh
->dma_buffer_pool
== BUF_SCSI_ALLOCED
)
165 kfree(wh
->dma_bounce_buffer
);
167 amiga_chip_free(wh
->dma_bounce_buffer
);
169 wh
->dma_bounce_buffer
= NULL
;
170 wh
->dma_bounce_len
= 0;
174 static struct scsi_host_template gvp11_scsi_template
= {
175 .module
= THIS_MODULE
,
176 .name
= "GVP Series II SCSI",
177 .show_info
= wd33c93_show_info
,
178 .write_info
= wd33c93_write_info
,
179 .proc_name
= "GVP11",
180 .queuecommand
= wd33c93_queuecommand
,
181 .eh_abort_handler
= wd33c93_abort
,
182 .eh_host_reset_handler
= wd33c93_host_reset
,
183 .can_queue
= CAN_QUEUE
,
185 .sg_tablesize
= SG_ALL
,
186 .cmd_per_lun
= CMD_PER_LUN
,
187 .dma_boundary
= PAGE_SIZE
- 1,
190 static int check_wd33c93(struct gvp11_scsiregs
*regs
)
193 volatile unsigned char *sasr_3393
, *scmd_3393
;
194 unsigned char save_sasr
;
198 * These darn GVP boards are a problem - it can be tough to tell
199 * whether or not they include a SCSI controller. This is the
200 * ultimate Yet-Another-GVP-Detection-Hack in that it actually
201 * probes for a WD33c93 chip: If we find one, it's extremely
202 * likely that this card supports SCSI, regardless of Product_
203 * Code, Board_Size, etc.
206 /* Get pointers to the presumed register locations and save contents */
208 sasr_3393
= ®s
->SASR
;
209 scmd_3393
= ®s
->SCMD
;
210 save_sasr
= *sasr_3393
;
212 /* First test the AuxStatus Reg */
214 q
= *sasr_3393
; /* read it */
215 if (q
& 0x08) /* bit 3 should always be clear */
217 *sasr_3393
= WD_AUXILIARY_STATUS
; /* setup indirect address */
218 if (*sasr_3393
== WD_AUXILIARY_STATUS
) { /* shouldn't retain the write */
219 *sasr_3393
= save_sasr
; /* Oops - restore this byte */
222 if (*sasr_3393
!= q
) { /* should still read the same */
223 *sasr_3393
= save_sasr
; /* Oops - restore this byte */
226 if (*scmd_3393
!= q
) /* and so should the image at 0x1f */
230 * Ok, we probably have a wd33c93, but let's check a few other places
231 * for good measure. Make sure that this works for both 'A and 'B
235 *sasr_3393
= WD_SCSI_STATUS
;
237 *sasr_3393
= WD_SCSI_STATUS
;
239 *sasr_3393
= WD_SCSI_STATUS
;
241 *sasr_3393
= WD_SCSI_STATUS
;
243 if (qq
!= q
) /* should be read only */
245 *sasr_3393
= 0x1e; /* this register is unimplemented */
253 if (qq
!= q
|| qq
!= 0xff) /* should be read only, all 1's */
255 *sasr_3393
= WD_TIMEOUT_PERIOD
;
257 *sasr_3393
= WD_TIMEOUT_PERIOD
;
259 *sasr_3393
= WD_TIMEOUT_PERIOD
;
261 *sasr_3393
= WD_TIMEOUT_PERIOD
;
263 if (qq
!= (~q
& 0xff)) /* should be read/write */
265 #endif /* CHECK_WD33C93 */
270 static int gvp11_probe(struct zorro_dev
*z
, const struct zorro_device_id
*ent
)
272 struct Scsi_Host
*instance
;
273 unsigned long address
;
276 unsigned int default_dma_xfer_mask
;
277 struct gvp11_hostdata
*hdata
;
278 struct gvp11_scsiregs
*regs
;
281 default_dma_xfer_mask
= ent
->driver_data
;
284 * Rumors state that some GVP ram boards use the same product
285 * code as the SCSI controllers. Therefore if the board-size
286 * is not 64KB we assume it is a ram board and bail out.
288 if (zorro_resource_len(z
) != 0x10000)
291 address
= z
->resource
.start
;
292 if (!request_mem_region(address
, 256, "wd33c93"))
295 regs
= ZTWO_VADDR(address
);
297 error
= check_wd33c93(regs
);
299 goto fail_check_or_alloc
;
301 instance
= scsi_host_alloc(&gvp11_scsi_template
,
302 sizeof(struct gvp11_hostdata
));
305 goto fail_check_or_alloc
;
308 instance
->irq
= IRQ_AMIGA_PORTS
;
309 instance
->unique_id
= z
->slotaddr
;
314 while (regs
->CNTR
& GVP11_DMAC_BUSY
)
319 wdregs
.SASR
= ®s
->SASR
;
320 wdregs
.SCMD
= ®s
->SCMD
;
322 hdata
= shost_priv(instance
);
324 hdata
->wh
.dma_xfer_mask
= gvp11_xfer_mask
;
326 hdata
->wh
.dma_xfer_mask
= default_dma_xfer_mask
;
328 hdata
->wh
.no_sync
= 0xff;
330 hdata
->wh
.dma_mode
= CTRL_DMA
;
334 * Check for 14MHz SCSI clock
336 epc
= *(unsigned short *)(ZTWO_VADDR(address
) + 0x8000);
337 wd33c93_init(instance
, wdregs
, dma_setup
, dma_stop
,
338 (epc
& GVP_SCSICLKMASK
) ? WD33C93_FS_8_10
341 error
= request_irq(IRQ_AMIGA_PORTS
, gvp11_intr
, IRQF_SHARED
,
342 "GVP11 SCSI", instance
);
346 regs
->CNTR
= GVP11_DMAC_INT_ENABLE
;
348 error
= scsi_add_host(instance
, NULL
);
352 zorro_set_drvdata(z
, instance
);
353 scsi_scan_host(instance
);
357 free_irq(IRQ_AMIGA_PORTS
, instance
);
359 scsi_host_put(instance
);
361 release_mem_region(address
, 256);
365 static void gvp11_remove(struct zorro_dev
*z
)
367 struct Scsi_Host
*instance
= zorro_get_drvdata(z
);
368 struct gvp11_hostdata
*hdata
= shost_priv(instance
);
370 hdata
->regs
->CNTR
= 0;
371 scsi_remove_host(instance
);
372 free_irq(IRQ_AMIGA_PORTS
, instance
);
373 scsi_host_put(instance
);
374 release_mem_region(z
->resource
.start
, 256);
378 * This should (hopefully) be the correct way to identify
379 * all the different GVP SCSI controllers (except for the
383 static struct zorro_device_id gvp11_zorro_tbl
[] = {
384 { ZORRO_PROD_GVP_COMBO_030_R3_SCSI
, ~0x00ffffff },
385 { ZORRO_PROD_GVP_SERIES_II
, ~0x00ffffff },
386 { ZORRO_PROD_GVP_GFORCE_030_SCSI
, ~0x01ffffff },
387 { ZORRO_PROD_GVP_A530_SCSI
, ~0x01ffffff },
388 { ZORRO_PROD_GVP_COMBO_030_R4_SCSI
, ~0x01ffffff },
389 { ZORRO_PROD_GVP_A1291
, ~0x07ffffff },
390 { ZORRO_PROD_GVP_GFORCE_040_SCSI_1
, ~0x07ffffff },
393 MODULE_DEVICE_TABLE(zorro
, gvp11_zorro_tbl
);
395 static struct zorro_driver gvp11_driver
= {
397 .id_table
= gvp11_zorro_tbl
,
398 .probe
= gvp11_probe
,
399 .remove
= gvp11_remove
,
402 static int __init
gvp11_init(void)
404 return zorro_register_driver(&gvp11_driver
);
406 module_init(gvp11_init
);
408 static void __exit
gvp11_exit(void)
410 zorro_unregister_driver(&gvp11_driver
);
412 module_exit(gvp11_exit
);
414 MODULE_DESCRIPTION("GVP Series II SCSI");
415 MODULE_LICENSE("GPL");