]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * This file is subject to the terms and conditions of the GNU General Public | |
3 | * License. See the file "COPYING" in the main directory of this archive | |
4 | * for more details. | |
5 | * | |
6 | * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com) | |
7 | * Copyright (C) 1999 Andrew R. Baker (andrewb@uab.edu) | |
8 | * Copyright (C) 2001 Florian Lohoff (flo@rfc822.org) | |
df9f5408 | 9 | * Copyright (C) 2003, 07 Ralf Baechle (ralf@linux-mips.org) |
1da177e4 LT |
10 | * |
11 | * (In all truth, Jed Schimmel wrote all this code.) | |
12 | */ | |
df9f5408 RB |
13 | |
14 | #undef DEBUG | |
15 | ||
1da177e4 LT |
16 | #include <linux/delay.h> |
17 | #include <linux/dma-mapping.h> | |
df9f5408 RB |
18 | #include <linux/gfp.h> |
19 | #include <linux/interrupt.h> | |
20 | #include <linux/init.h> | |
21 | #include <linux/kernel.h> | |
22 | #include <linux/types.h> | |
23 | #include <linux/module.h> | |
24 | #include <linux/platform_device.h> | |
1da177e4 LT |
25 | #include <linux/spinlock.h> |
26 | ||
1da177e4 LT |
27 | #include <asm/sgi/hpc3.h> |
28 | #include <asm/sgi/ip22.h> | |
df9f5408 | 29 | #include <asm/sgi/wd.h> |
1da177e4 LT |
30 | |
31 | #include "scsi.h" | |
1da177e4 | 32 | #include "wd33c93.h" |
1da177e4 | 33 | |
1da177e4 LT |
34 | struct ip22_hostdata { |
35 | struct WD33C93_hostdata wh; | |
36 | struct hpc_data { | |
37 | dma_addr_t dma; | |
df9f5408 | 38 | void *cpu; |
1da177e4 LT |
39 | } hd; |
40 | }; | |
41 | ||
df9f5408 RB |
42 | #define host_to_hostdata(host) ((struct ip22_hostdata *)((host)->hostdata)) |
43 | ||
1da177e4 LT |
44 | struct hpc_chunk { |
45 | struct hpc_dma_desc desc; | |
46 | u32 _padding; /* align to quadword boundary */ | |
47 | }; | |
48 | ||
7d12e780 | 49 | static irqreturn_t sgiwd93_intr(int irq, void *dev_id) |
1da177e4 | 50 | { |
df9f5408 | 51 | struct Scsi_Host * host = dev_id; |
1da177e4 LT |
52 | unsigned long flags; |
53 | ||
54 | spin_lock_irqsave(host->host_lock, flags); | |
55 | wd33c93_intr(host); | |
56 | spin_unlock_irqrestore(host->host_lock, flags); | |
57 | ||
58 | return IRQ_HANDLED; | |
59 | } | |
60 | ||
61 | static inline | |
65396410 | 62 | void fill_hpc_entries(struct hpc_chunk *hcp, struct scsi_cmnd *cmd, int datainp) |
1da177e4 LT |
63 | { |
64 | unsigned long len = cmd->SCp.this_residual; | |
65 | void *addr = cmd->SCp.ptr; | |
66 | dma_addr_t physaddr; | |
67 | unsigned long count; | |
68 | ||
69 | physaddr = dma_map_single(NULL, addr, len, cmd->sc_data_direction); | |
70 | cmd->SCp.dma_handle = physaddr; | |
71 | ||
72 | while (len) { | |
73 | /* | |
74 | * even cntinfo could be up to 16383, without | |
75 | * magic only 8192 works correctly | |
76 | */ | |
77 | count = len > 8192 ? 8192 : len; | |
78 | hcp->desc.pbuf = physaddr; | |
79 | hcp->desc.cntinfo = count; | |
80 | hcp++; | |
81 | len -= count; | |
82 | physaddr += count; | |
83 | } | |
84 | ||
85 | /* | |
86 | * To make sure, if we trip an HPC bug, that we transfer every single | |
87 | * byte, we tag on an extra zero length dma descriptor at the end of | |
88 | * the chain. | |
89 | */ | |
90 | hcp->desc.pbuf = 0; | |
91 | hcp->desc.cntinfo = HPCDMA_EOX; | |
92 | } | |
93 | ||
65396410 | 94 | static int dma_setup(struct scsi_cmnd *cmd, int datainp) |
1da177e4 | 95 | { |
df9f5408 | 96 | struct ip22_hostdata *hdata = host_to_hostdata(cmd->device->host); |
1da177e4 LT |
97 | struct hpc3_scsiregs *hregs = |
98 | (struct hpc3_scsiregs *) cmd->device->host->base; | |
99 | struct hpc_chunk *hcp = (struct hpc_chunk *) hdata->hd.cpu; | |
100 | ||
df9f5408 | 101 | pr_debug("dma_setup: datainp<%d> hcp<%p> ", datainp, hcp); |
1da177e4 LT |
102 | |
103 | hdata->wh.dma_dir = datainp; | |
104 | ||
105 | /* | |
106 | * wd33c93 shouldn't pass us bogus dma_setups, but it does:-( The | |
107 | * other wd33c93 drivers deal with it the same way (which isn't that | |
108 | * obvious). IMHO a better fix would be, not to do these dma setups | |
109 | * in the first place. | |
110 | */ | |
111 | if (cmd->SCp.ptr == NULL || cmd->SCp.this_residual == 0) | |
112 | return 1; | |
113 | ||
114 | fill_hpc_entries(hcp, cmd, datainp); | |
115 | ||
df9f5408 | 116 | pr_debug(" HPCGO\n"); |
1da177e4 LT |
117 | |
118 | /* Start up the HPC. */ | |
119 | hregs->ndptr = hdata->hd.dma; | |
120 | if (datainp) | |
121 | hregs->ctrl = HPC3_SCTRL_ACTIVE; | |
122 | else | |
123 | hregs->ctrl = HPC3_SCTRL_ACTIVE | HPC3_SCTRL_DIR; | |
124 | ||
125 | return 0; | |
126 | } | |
127 | ||
65396410 | 128 | static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt, |
1da177e4 LT |
129 | int status) |
130 | { | |
df9f5408 | 131 | struct ip22_hostdata *hdata = host_to_hostdata(instance); |
1da177e4 LT |
132 | struct hpc3_scsiregs *hregs; |
133 | ||
134 | if (!SCpnt) | |
135 | return; | |
136 | ||
137 | hregs = (struct hpc3_scsiregs *) SCpnt->device->host->base; | |
138 | ||
df9f5408 | 139 | pr_debug("dma_stop: status<%d> ", status); |
1da177e4 LT |
140 | |
141 | /* First stop the HPC and flush it's FIFO. */ | |
142 | if (hdata->wh.dma_dir) { | |
143 | hregs->ctrl |= HPC3_SCTRL_FLUSH; | |
144 | while (hregs->ctrl & HPC3_SCTRL_ACTIVE) | |
145 | barrier(); | |
146 | } | |
147 | hregs->ctrl = 0; | |
148 | dma_unmap_single(NULL, SCpnt->SCp.dma_handle, SCpnt->SCp.this_residual, | |
149 | SCpnt->sc_data_direction); | |
150 | ||
df9f5408 | 151 | pr_debug("\n"); |
1da177e4 LT |
152 | } |
153 | ||
154 | void sgiwd93_reset(unsigned long base) | |
155 | { | |
156 | struct hpc3_scsiregs *hregs = (struct hpc3_scsiregs *) base; | |
157 | ||
158 | hregs->ctrl = HPC3_SCTRL_CRESET; | |
159 | udelay(50); | |
160 | hregs->ctrl = 0; | |
161 | } | |
162 | ||
163 | static inline void init_hpc_chain(struct hpc_data *hd) | |
164 | { | |
165 | struct hpc_chunk *hcp = (struct hpc_chunk *) hd->cpu; | |
166 | struct hpc_chunk *dma = (struct hpc_chunk *) hd->dma; | |
167 | unsigned long start, end; | |
168 | ||
169 | start = (unsigned long) hcp; | |
170 | end = start + PAGE_SIZE; | |
171 | while (start < end) { | |
172 | hcp->desc.pnext = (u32) (dma + 1); | |
173 | hcp->desc.cntinfo = HPCDMA_EOX; | |
174 | hcp++; dma++; | |
175 | start += sizeof(struct hpc_chunk); | |
176 | }; | |
177 | hcp--; | |
178 | hcp->desc.pnext = hd->dma; | |
179 | } | |
180 | ||
df9f5408 RB |
181 | static int sgiwd93_bus_reset(struct scsi_cmnd *cmd) |
182 | { | |
183 | /* FIXME perform bus-specific reset */ | |
184 | ||
185 | /* FIXME 2: kill this function, and let midlayer fallback | |
186 | to the same result, calling wd33c93_host_reset() */ | |
187 | ||
188 | spin_lock_irq(cmd->device->host->host_lock); | |
189 | wd33c93_host_reset(cmd); | |
190 | spin_unlock_irq(cmd->device->host->host_lock); | |
191 | ||
192 | return SUCCESS; | |
193 | } | |
194 | ||
195 | /* | |
196 | * Kludge alert - the SCSI code calls the abort and reset method with int | |
197 | * arguments not with pointers. So this is going to blow up beautyfully | |
198 | * on 64-bit systems with memory outside the compat address spaces. | |
199 | */ | |
200 | static struct scsi_host_template sgiwd93_template = { | |
201 | .module = THIS_MODULE, | |
202 | .proc_name = "SGIWD93", | |
203 | .name = "SGI WD93", | |
204 | .queuecommand = wd33c93_queuecommand, | |
205 | .eh_abort_handler = wd33c93_abort, | |
206 | .eh_bus_reset_handler = sgiwd93_bus_reset, | |
207 | .eh_host_reset_handler = wd33c93_host_reset, | |
208 | .can_queue = 16, | |
209 | .this_id = 7, | |
210 | .sg_tablesize = SG_ALL, | |
211 | .cmd_per_lun = 8, | |
212 | .use_clustering = DISABLE_CLUSTERING, | |
213 | }; | |
214 | ||
215 | static int __init sgiwd93_probe(struct platform_device *pdev) | |
1da177e4 | 216 | { |
df9f5408 RB |
217 | struct sgiwd93_platform_data *pd = pdev->dev.platform_data; |
218 | unsigned char *wdregs = pd->wdregs; | |
219 | struct hpc3_scsiregs *hregs = pd->hregs; | |
1da177e4 LT |
220 | struct ip22_hostdata *hdata; |
221 | struct Scsi_Host *host; | |
222 | wd33c93_regs regs; | |
df9f5408 RB |
223 | unsigned int unit = pd->unit; |
224 | unsigned int irq = pd->irq; | |
225 | int err; | |
226 | ||
227 | host = scsi_host_alloc(&sgiwd93_template, sizeof(struct ip22_hostdata)); | |
228 | if (!host) { | |
229 | err = -ENOMEM; | |
230 | goto out; | |
231 | } | |
1da177e4 LT |
232 | |
233 | host->base = (unsigned long) hregs; | |
234 | host->irq = irq; | |
235 | ||
df9f5408 RB |
236 | hdata = host_to_hostdata(host); |
237 | hdata->hd.cpu = dma_alloc_coherent(&pdev->dev, PAGE_SIZE, | |
238 | &hdata->hd.dma, GFP_KERNEL); | |
1da177e4 LT |
239 | if (!hdata->hd.cpu) { |
240 | printk(KERN_WARNING "sgiwd93: Could not allocate memory for " | |
241 | "host %d buffer.\n", unit); | |
df9f5408 RB |
242 | err = -ENOMEM; |
243 | goto out_put; | |
1da177e4 | 244 | } |
df9f5408 | 245 | |
1da177e4 LT |
246 | init_hpc_chain(&hdata->hd); |
247 | ||
248 | regs.SASR = wdregs + 3; | |
249 | regs.SCMD = wdregs + 7; | |
250 | ||
8f3334ed | 251 | wd33c93_init(host, regs, dma_setup, dma_stop, WD33C93_FS_MHZ(20)); |
1da177e4 | 252 | |
8f3334ed | 253 | if (hdata->wh.no_sync == 0xff) |
254 | hdata->wh.no_sync = 0; | |
1da177e4 | 255 | |
df9f5408 RB |
256 | err = request_irq(irq, sgiwd93_intr, 0, "SGI WD93", host); |
257 | if (err) { | |
1da177e4 LT |
258 | printk(KERN_WARNING "sgiwd93: Could not register irq %d " |
259 | "for host %d.\n", irq, unit); | |
260 | goto out_free; | |
261 | } | |
1da177e4 | 262 | |
df9f5408 | 263 | platform_set_drvdata(pdev, host); |
1da177e4 | 264 | |
df9f5408 RB |
265 | err = scsi_add_host(host, NULL); |
266 | if (err) | |
267 | goto out_irq; | |
1da177e4 | 268 | |
df9f5408 | 269 | scsi_scan_host(host); |
1da177e4 | 270 | |
df9f5408 | 271 | return 0; |
1da177e4 | 272 | |
df9f5408 RB |
273 | out_irq: |
274 | free_irq(irq, host); | |
275 | out_free: | |
1da177e4 | 276 | dma_free_coherent(NULL, PAGE_SIZE, hdata->hd.cpu, hdata->hd.dma); |
df9f5408 RB |
277 | out_put: |
278 | scsi_host_put(host); | |
279 | out: | |
1da177e4 | 280 | |
df9f5408 | 281 | return err; |
1da177e4 LT |
282 | } |
283 | ||
df9f5408 | 284 | static void __exit sgiwd93_remove(struct platform_device *pdev) |
1da177e4 | 285 | { |
df9f5408 RB |
286 | struct Scsi_Host *host = platform_get_drvdata(pdev); |
287 | struct ip22_hostdata *hdata = (struct ip22_hostdata *) host->hostdata; | |
288 | struct sgiwd93_platform_data *pd = pdev->dev.platform_data; | |
289 | ||
290 | scsi_remove_host(host); | |
291 | free_irq(pd->irq, host); | |
292 | dma_free_coherent(&pdev->dev, PAGE_SIZE, hdata->hd.cpu, hdata->hd.dma); | |
293 | scsi_host_put(host); | |
294 | } | |
68b3aa7c | 295 | |
df9f5408 RB |
296 | static struct platform_driver sgiwd93_driver = { |
297 | .probe = sgiwd93_probe, | |
298 | .remove = __devexit_p(sgiwd93_remove), | |
299 | .driver = { | |
300 | .name = "sgiwd93" | |
301 | } | |
302 | }; | |
df0ae249 | 303 | |
df9f5408 RB |
304 | static int __init sgiwd93_module_init(void) |
305 | { | |
306 | return platform_driver_register(&sgiwd93_driver); | |
307 | } | |
68b3aa7c | 308 | |
df9f5408 RB |
309 | static void __exit sgiwd93_module_exit(void) |
310 | { | |
311 | return platform_driver_unregister(&sgiwd93_driver); | |
1da177e4 LT |
312 | } |
313 | ||
df9f5408 RB |
314 | module_init(sgiwd93_module_init); |
315 | module_exit(sgiwd93_module_exit); | |
316 | ||
317 | MODULE_DESCRIPTION("SGI WD33C93 driver"); | |
318 | MODULE_AUTHOR("Ralf Baechle <ralf@linux-mips.org>"); | |
319 | MODULE_LICENSE("GPL"); |